@north-light/crouter 0.3.227 → 0.3.228

package/dist/core/__tests__/profile-project-memory-delivery.test.js

@@ -5,9 +5,10 @@
 //
 // One real fixture drives the real scope resolver, the real boot renderer, the
 // real workspace-open renderer, and the real `crtr memory read` leaf: a profile
-// whose four projects sit at none/name/preview/content in manifest order, with
-// the `preview` project as cwd and canonical-name collisions across projects and
-// against the wider user scope.
+// whose first four projects sit at none/name/preview/content in manifest order,
+// with the `preview` project as cwd, plus two more projects declaring ONE shared
+// namespace so a single canonical identity has two physical candidates split
+// across a `none` and a `content` relationship.
 //
 // Migration convergence is NOT here — it lives in migration.test.ts.
 //
@@ -25,8 +26,13 @@ import { memoryDir } from '../runtime/memory.js';
 import { clearSessionCache } from '../substrate/session-cache.js';
 import { renderKnowledgeBlock } from '../substrate/render-node.js';
 import { renderWorkspaceOpenDocs } from '../substrate/on-read-node.js';
-import { deliveredAtOrAbove, loadInjectedDocs, saveInjectedDocs, } from '../substrate/injected-store.js';
+import { documentExposedAtOrAbove, emptyContextExposureState, exposedAtOrAbove, exposureTarget, loadContextExposureState, saveContextExposureState, } from '../substrate/injected-store.js';
 import { readLeaf } from '../../commands/memory/read.js';
+import { listLeaf } from '../../commands/memory/list.js';
+import { findLeaf } from '../../commands/memory/find.js';
+function freshTranscriptTarget() {
+    return exposureTarget(emptyContextExposureState(), 'transcript');
+}
 const B = {
     pnone: 'BODY-T9-PNONE',
     pname: 'BODY-T9-PNAME',
@@ -38,6 +44,8 @@ const B = {
     nameFromPcontent: 'BODY-T9-NAMEDUP-FROM-PCONTENT',
     userDupFromPnone: 'BODY-T9-USERDUP-FROM-PNONE',
     userDupFromUser: 'BODY-T9-USERDUP-FROM-USER',
+    dupNear: 'BODY-T9-DUP-FROM-NEAR',
+    dupFar: 'BODY-T9-DUP-FROM-FAR',
     kindSplit: 'BODY-T9-KIND-SPLIT',
     documentGateWins: 'BODY-T9-DOCUMENT-GATE-WINS',
 };
@@ -91,31 +99,50 @@ before(() => {
     canvasHome = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-ppm-canvas-')));
     process.env['HOME'] = home;
     process.env['CRTR_HOME'] = canvasHome;
-    const store = (slug) => {
+    // A project store answers only under the namespace its root INDEX.md
+    // declares; without that declaration the store does not mount at all.
+    const store = (slug, namespace) => {
         const dir = join(home, slug, '.crouter', 'memory');
         mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, 'INDEX.md'), [
+            '---',
+            'kind: knowledge',
+            `namespace: ${namespace}`,
+            `when-and-why-to-read: "When the ${slug} store is addressed"`,
+            '---',
+            '',
+            `STORE-ROOT-${slug.toUpperCase()}`,
+            '',
+        ].join('\n'));
         return dir;
     };
-    const pnone = store('pnone');
-    const pname = store('pname');
-    const ppreview = store('ppreview');
-    const pcontent = store('pcontent');
+    const pnone = store('pnone', 'pnone');
+    const pname = store('pname', 'pname');
+    const ppreview = store('ppreview', 'ppreview');
+    const pcontent = store('pcontent', 'pcontent');
+    // Two stores declaring ONE namespace — the only way two projects can hold the
+    // same canonical identity.
+    const pdupnear = store('pdupnear', 'shared');
+    const pdupfar = store('pdupfar', 'shared');
     const user = join(home, '.crouter', 'memory');
     mkdirSync(user, { recursive: true });
     writeDoc(pnone, 't9-pnone-doc', autoDoc('When the none project delivers', B.pnone));
     writeDoc(pname, 't9-pname-doc', autoDoc('When the name project delivers', B.pname));
     ppreviewDocPath = writeDoc(ppreview, 't9-ppreview-doc', autoDoc('When the cwd project delivers', B.ppreview));
     writeDoc(pcontent, 't9-pcontent-doc', autoDoc('When the content project delivers', B.pcontent));
-    // Collision one: `none` (earlier in manifest order) vs `content`. The cap must
-    // apply before name dedupe, so the dropped entry cannot shadow the winner.
+    // Equal-canonical collision: `shared/dup-doc` in both stores that declare
+    // `shared`, the `none`-capped one nearer in source order. The cap must apply
+    // BEFORE dedupe, so the capped nearer candidate yields to the farther one
+    // instead of suppressing it.
+    writeDoc(pdupnear, 'dup-doc', autoDoc('When the shared identity resolves', B.dupNear));
+    writeDoc(pdupfar, 'dup-doc', autoDoc('When the shared identity resolves', B.dupFar));
+    // Distinct identities that only LOOK like collisions: each project composes
+    // its own namespace, so a capped project cannot suppress another store's
+    // document that merely shares a local name.
     writeDoc(pnone, 't9-shared-doc', autoDoc('When the shared name resolves', B.sharedFromPnone));
     writeDoc(pcontent, 't9-shared-doc', autoDoc('When the shared name resolves', B.sharedFromPcontent));
-    // Collision two: `name` vs `content`. A non-none cap keeps its project's
-    // precedence and discloses at the capped rung — it does not step aside.
     writeDoc(pname, 't9-namedup-doc', autoDoc('When the name-capped duplicate resolves', B.nameFromPname));
     writeDoc(pcontent, 't9-namedup-doc', autoDoc('When the name-capped duplicate resolves', B.nameFromPcontent));
-    // Collision three: `none` vs the wider user scope, which project precedence
-    // would otherwise beat.
     writeDoc(pnone, 't9-userdup-doc', autoDoc('When the user duplicate resolves', B.userDupFromPnone));
     writeDoc(user, 't9-userdup-doc', autoDoc('When the user duplicate resolves', B.userDupFromUser));
     writeDoc(user, 't9-kind-split', [
@@ -151,6 +178,8 @@ before(() => {
         { path: join(home, 'pname'), memory: 'name' },
         { path: join(home, 'ppreview'), memory: 'preview' },
         { path: join(home, 'pcontent'), memory: 'content' },
+        { path: join(home, 'pdupnear'), memory: 'none' },
+        { path: join(home, 'pdupfar'), memory: 'content' },
     ]).profileId;
     process.env['CRTR_PROFILE_ID'] = profileId;
     // The node works INSIDE a capped project: the reported failure.
@@ -183,7 +212,7 @@ function newNode(kind = 'general') {
     return spawnNode({ kind, cwd: cwdProject, parent: null, profile_id: profileId }).node_id;
 }
 test('boot delivery caps every profile project at its relationship, including the one used as cwd', () => {
-    const boot = renderKnowledgeBlock(newNode(), new Map());
+    const boot = renderKnowledgeBlock(newNode(), freshTranscriptTarget());
     // The control: an uncapped relationship still renders its authored content.
     assert.ok(boot.includes(B.pcontent), `the content-capped project renders its body; got:\n${boot}`);
     // The reported failure. cwd reaches this root before the manifest pointer
@@ -197,20 +226,20 @@ test('boot delivery caps every profile project at its relationship, including th
 });
 test('surface-entry gates select the rung by node kind while the document gate remains absolute', () => {
     for (const kind of ['design', 'spec', 'plan', 'developer']) {
-        const boot = renderKnowledgeBlock(newNode(kind), new Map());
+        const boot = renderKnowledgeBlock(newNode(kind), freshTranscriptTarget());
         assert.ok(boot.includes(B.kindSplit), `${kind} receives the content rung; got:\n${boot}`);
     }
     for (const kind of ['general', 'review', 'advisor']) {
-        const boot = renderKnowledgeBlock(newNode(kind), new Map());
+        const boot = renderKnowledgeBlock(newNode(kind), freshTranscriptTarget());
         assert.match(boot, /t9-kind-split {2}# read when: When the node needs this kind-specific guide\./, `${kind} receives the preview rung; got:\n${boot}`);
         assert.ok(!boot.includes(B.kindSplit), `${kind} does not receive the body`);
     }
     for (const kind of ['explore', 'personal-assistant']) {
-        const boot = renderKnowledgeBlock(newNode(kind), new Map());
+        const boot = renderKnowledgeBlock(newNode(kind), freshTranscriptTarget());
         assert.ok(!boot.includes('t9-kind-split'), `${kind} receives no kind-split entry; got:\n${boot}`);
         assert.ok(!boot.includes(B.kindSplit), `${kind} receives no kind-split body`);
     }
-    const developer = renderKnowledgeBlock(newNode('developer'), new Map());
+    const developer = renderKnowledgeBlock(newNode('developer'), freshTranscriptTarget());
     assert.ok(!developer.includes('t9-document-gate-wins'), `a failing document gate excludes every entry; got:\n${developer}`);
     assert.ok(!developer.includes(B.documentGateWins), 'a failing document gate excludes its content');
 });
@@ -229,56 +258,121 @@ test('a node-local doc floors to name only without boot entries', () => {
         'BODY-T9-NODE-LOCAL-ENTRY-GATED',
         '',
     ].join('\n'));
-    const boot = renderKnowledgeBlock(node, new Map());
+    const boot = renderKnowledgeBlock(node, freshTranscriptTarget());
     assert.match(boot, /[├└]─ t9-node-local-bootless$/m, `a bootless node-local doc falls to name; got:\n${boot}`);
     assert.ok(!boot.includes('BODY-T9-NODE-LOCAL-BOOTLESS'), 'the fallback discloses no body');
     assert.ok(!boot.includes('t9-node-local-entry-gated'), `ineligible boot entries keep a node-local doc absent; got:\n${boot}`);
     assert.ok(!boot.includes('BODY-T9-NODE-LOCAL-ENTRY-GATED'), 'ineligible boot entries disclose no body');
 });
 test('a `none` project contributes nothing to boot — no body, no name, no hidden count, no shadow', () => {
-    const boot = renderKnowledgeBlock(newNode(), new Map());
+    const boot = renderKnowledgeBlock(newNode(), freshTranscriptTarget());
     assert.ok(!boot.includes(B.pnone), 'a none-capped body must not render');
-    assert.ok(!boot.includes('t9-pnone-doc'), 'a none-capped doc must not appear as a name either');
-    // Hidden counts are disclosure too: the control dir proves a bootless doc
-    // does surface as a `[+N more]` count, so the none project's absence is the cap.
-    assert.match(boot, /t9-hidden-control\/\n.*\[\+1 more\]/, `the control dir shows its hidden count; got:\n${boot}`);
+    assert.ok(!boot.includes('pnone'), 'a none-capped store must not appear as a name either — not even its namespace row');
+    // Hidden counts are disclosure too: the control project's namespace row proves
+    // a bootless doc does surface as a `[+N more]` count, so the none project's
+    // total absence is the cap and not a rendering quirk.
+    assert.match(boot, /pcontent\/\n[^\n]*\[\+\d+ more\]/, `the control project's row shows its hidden count; got:\n${boot}`);
     assert.ok(!boot.includes('t9-none-hidden'), 'a none-capped project contributes no `[+N more]` count');
     // Shadowing: `none` wins name dedupe on precedence, so a cap applied after
     // dedupe would silently delete the winner instead of deferring to it.
-    assert.ok(boot.includes(B.sharedFromPcontent) && !boot.includes(B.sharedFromPnone), `the content project wins the collision the none project would have taken; got:\n${boot}`);
-    assert.ok(boot.includes(B.userDupFromUser) && !boot.includes(B.userDupFromPnone), `a none project does not shadow the wider user-scope winner; got:\n${boot}`);
+    // A capped project cannot suppress a document it never shared an identity
+    // with: each store composes its own namespace, so these are distinct names.
+    assert.ok(boot.includes(B.sharedFromPcontent) && !boot.includes(B.sharedFromPnone), `pcontent/t9-shared-doc delivers while the none project contributes nothing; got:\n${boot}`);
+    assert.ok(boot.includes(B.userDupFromUser) && !boot.includes(B.userDupFromPnone), `the unqualified user identity delivers while the none project contributes nothing; got:\n${boot}`);
+});
+test('a capped nearer candidate yields the shared identity instead of suppressing it', async () => {
+    // Two project stores declare the SAME namespace, so `shared/dup-doc` has two
+    // physical candidates. Automatic delivery filters candidates by the profile
+    // cap BEFORE dedupe, so the `none`-capped nearer one drops out and the farther
+    // one delivers; a deliberate read stays winner-only on source order.
+    const boot = renderKnowledgeBlock(newNode(), freshTranscriptTarget());
+    assert.ok(boot.includes(B.dupFar), `the farther uncapped candidate delivers the shared identity; got:\n${boot}`);
+    assert.ok(!boot.includes(B.dupNear), 'the none-capped nearer candidate delivers nothing');
+    const read = (await readLeaf.run({
+        name: 'shared/dup-doc',
+        kind: undefined,
+        frontmatter: false,
+        scope: undefined,
+        dir: undefined,
+    }));
+    assert.ok(read.content.includes(B.dupNear) && !read.content.includes(B.dupFar), `a deliberate read resolves the source-order winner; got:\n${read.content}`);
 });
 test('a non-none cap keeps its project precedence and discloses the duplicate at the capped rung', () => {
-    const boot = renderKnowledgeBlock(newNode(), new Map());
-    assert.match(boot, /[├└]─ t9-namedup-doc$/m, `the name-capped duplicate wins dedupe; got:\n${boot}`);
-    assert.ok(!boot.includes(B.nameFromPname), 'the winner discloses at `name`, never its body');
-    assert.ok(!boot.includes(B.nameFromPcontent), 'the content project does not take a collision the name project already won');
+    const boot = renderKnowledgeBlock(newNode(), freshTranscriptTarget());
+    assert.match(boot, /[├└]─ t9-namedup-doc$/m, `the name-capped project discloses its doc as a bare name; got:\n${boot}`);
+    assert.ok(!boot.includes(B.nameFromPname), 'a name-capped doc discloses at `name`, never its body');
+    assert.ok(boot.includes(B.nameFromPcontent), 'the content project delivers its own distinct identity in full');
 });
 test('workspace-open clamps each project store the same way boot does', () => {
-    const opened = renderWorkspaceOpenDocs(newNode(), new Map());
+    const opened = renderWorkspaceOpenDocs(newNode(), freshTranscriptTarget());
     assert.ok(opened.includes(B.pcontent), `the content-capped project delivers its body; got:\n${opened}`);
     assert.ok(!opened.includes(B.ppreview), `the cwd project must not deliver its body; got:\n${opened}`);
-    assert.match(opened, /name="t9-ppreview-doc" readWhen="When the cwd project delivers\./, `the cwd project delivers its preview line; got:\n${opened}`);
-    assert.match(opened, /name="t9-pname-doc"[^>]*\/>/, `the name-capped doc delivers name-only; got:\n${opened}`);
+    assert.match(opened, /name="ppreview\/t9-ppreview-doc" readWhen="When the cwd project delivers\./, `the cwd project delivers its preview line under its canonical name; got:\n${opened}`);
+    assert.match(opened, /name="pname\/t9-pname-doc"[^>]*\/>/, `the name-capped doc delivers name-only; got:\n${opened}`);
     assert.ok(!opened.includes('t9-pnone-doc'), 'the none-capped project delivers nothing at workspace-open');
     assert.ok(!opened.includes(B.sharedFromPnone), 'nor its side of a name collision');
 });
+test('memory list and find record synthetic pages without crediting matched documents', async () => {
+    const node = newNode();
+    process.env['CRTR_NODE_ID'] = node;
+    try {
+        const listed = await listLeaf.run({
+            kind: undefined,
+            scope: undefined,
+            dir: undefined,
+            paths: false,
+            limit: 50,
+            cursor: undefined,
+        });
+        const found = await findLeaf.run({
+            query: 'ppreview/t9-ppreview-doc',
+            kind: undefined,
+            scope: undefined,
+            dir: undefined,
+            grep: false,
+            body: false,
+            limit: 10,
+            cursor: undefined,
+            minScore: undefined,
+            paths: false,
+        });
+        assert.ok(listed.items.some((item) => item.name === 'ppreview/t9-ppreview-doc'), 'the inventory page listed the fixture document under its canonical name');
+        assert.ok(found.hits.some((hit) => hit.name === 'ppreview/t9-ppreview-doc'), 'the search page matched the fixture document under its canonical name');
+        const state = loadContextExposureState(node);
+        const listingKeys = [...state.exposures.keys()].filter((identity) => identity.startsWith('listing:memory-'));
+        assert.equal(listingKeys.length, 2, 'list and find each register their delivered page');
+        assert.ok(listingKeys.some((identity) => identity.startsWith('listing:memory-list:')));
+        assert.ok(listingKeys.some((identity) => identity.startsWith('listing:memory-find:')));
+        assert.ok(listingKeys.every((identity) => exposedAtOrAbove(state, identity, 'content')), 'each synthetic page is registered at its complete delivered representation');
+        assert.equal(documentExposedAtOrAbove(state, ppreviewDocPath, B.ppreview, 'name'), false, 'inventory metadata and matching lines never claim disclosure of the document itself');
+    }
+    finally {
+        delete process.env['CRTR_NODE_ID'];
+    }
+});
 test('an explicit `crtr memory read` returns and records the full body a cap withheld', async () => {
     const node = newNode();
     process.env['CRTR_NODE_ID'] = node;
-    const seen = loadInjectedDocs(node);
-    const opened = renderWorkspaceOpenDocs(node, seen);
+    const state = loadContextExposureState(node);
+    const transcript = exposureTarget(state, 'transcript');
+    const opened = renderWorkspaceOpenDocs(node, transcript);
     assert.ok(!opened.includes(B.ppreview), 'workspace-open disclosed the capped doc at preview only');
-    saveInjectedDocs(node, seen);
-    const result = (await readLeaf.run({ name: 't9-ppreview-doc', frontmatter: false }));
+    saveContextExposureState(node, state);
+    const result = (await readLeaf.run({
+        name: 'ppreview/t9-ppreview-doc',
+        kind: undefined,
+        frontmatter: false,
+        scope: undefined,
+        dir: undefined,
+    }));
     assert.equal(result.path, ppreviewDocPath, 'the read resolved the cwd project doc');
     assert.ok(result.content.includes(B.ppreview), `an explicit read is uncapped and returns the full body; got:\n${result.content}`);
-    const afterRead = loadInjectedDocs(node);
-    assert.ok(deliveredAtOrAbove(afterRead, ppreviewDocPath, 'content'), 'the explicit read records a content delivery, upgrading the preview disclosure');
+    const afterRead = loadContextExposureState(node);
+    assert.ok(documentExposedAtOrAbove(afterRead, ppreviewDocPath, B.ppreview, 'content'), 'the explicit read records a content delivery, upgrading the preview disclosure');
     // A later automatic event runs at the capped rung, which is now below what the
     // transcript holds, so it re-delivers nothing.
-    assert.equal(renderWorkspaceOpenDocs(node, afterRead), '', 'a later lower automatic event re-delivers nothing');
-    // ...and the emptiness is the dedup set, not a dead render.
-    assert.ok(renderWorkspaceOpenDocs(node, new Map()).includes('t9-ppreview-doc'), 'the same call against a fresh transcript still delivers');
+    assert.equal(renderWorkspaceOpenDocs(node, exposureTarget(afterRead, 'transcript')), '', 'a later lower automatic event re-delivers nothing');
+    // A fresh ledger proves the renderer itself is still live.
+    assert.ok(renderWorkspaceOpenDocs(node, freshTranscriptTarget()).includes('ppreview/t9-ppreview-doc'), 'the same call against a fresh transcript still delivers');
     delete process.env['CRTR_NODE_ID'];
 });

package/dist/core/__tests__/repository-association.test.d.ts

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

package/dist/core/__tests__/repository-association.test.js

@@ -0,0 +1,153 @@
+import { test, before, beforeEach, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { gitSync } from '../git.js';
+import { realpathOrSelf } from '../fs-utils.js';
+import { associateRepository, normalizeOwnerRelativePath, resetRepositoryAssociationCache, } from '../memory/repository-association.js';
+import { slugCanonicalPath, slugCanonicalSegment } from '../memory/identity.js';
+const cleanups = [];
+let previousHome;
+before(() => {
+    previousHome = process.env['HOME'];
+});
+beforeEach(() => {
+    process.env['HOME'] = realpathOrSelf(mkdtempSync(join('/tmp', 'crtr-association-home-')));
+    cleanups.push(process.env['HOME']);
+    resetRepositoryAssociationCache();
+});
+after(() => {
+    resetRepositoryAssociationCache();
+    for (const path of cleanups)
+        rmSync(path, { recursive: true, force: true });
+    if (previousHome === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = previousHome;
+});
+function temp(prefix) {
+    const path = realpathOrSelf(mkdtempSync(join('/tmp', prefix)));
+    cleanups.push(path);
+    return path;
+}
+function initGit(path) {
+    mkdirSync(path, { recursive: true });
+    assert.equal(gitSync(['-C', path, 'init', '-q'], undefined).status, 0);
+}
+function makeStore(owner) {
+    mkdirSync(join(owner, '.crouter', 'memory'), { recursive: true });
+    writeFileSync(join(owner, '.crouter', 'memory', 'INDEX.md'), '# store\n');
+}
+test('associates git roots, nested owners, and embedded repositories', () => {
+    const root = temp('crtr-association-git-');
+    initGit(root);
+    const nested = join(root, 'packages', 'api');
+    mkdirSync(nested, { recursive: true });
+    const atRoot = associateRepository(root);
+    assert.equal(atRoot.ok, true);
+    if (!atRoot.ok)
+        return;
+    assert.equal(atRoot.association.kind, 'git');
+    assert.equal(atRoot.association.repositoryRoot, root);
+    assert.equal(atRoot.association.ownerRelativePath, '');
+    assert.match(atRoot.association.repositoryKey, /^git:/);
+    assert.equal(atRoot.association.declarationPath, join(root, '.crouter', 'memory', 'INDEX.md'));
+    const belowRoot = associateRepository(nested);
+    assert.equal(belowRoot.ok, true);
+    if (!belowRoot.ok)
+        return;
+    assert.equal(belowRoot.association.repositoryRoot, root);
+    assert.equal(belowRoot.association.ownerRelativePath, 'packages/api');
+    const embedded = join(root, 'embedded');
+    initGit(embedded);
+    const embeddedOwner = join(embedded, 'pkg');
+    mkdirSync(embeddedOwner, { recursive: true });
+    const embeddedResult = associateRepository(embeddedOwner);
+    assert.equal(embeddedResult.ok, true);
+    if (!embeddedResult.ok)
+        return;
+    assert.equal(embeddedResult.association.repositoryRoot, embedded);
+    assert.equal(embeddedResult.association.ownerRelativePath, 'pkg');
+});
+test('linked worktrees share repository key and owner-relative path', () => {
+    const main = temp('crtr-association-main-');
+    initGit(main);
+    writeFileSync(join(main, 'README'), 'repo\n');
+    assert.equal(gitSync(['-C', main, 'add', 'README'], undefined).status, 0);
+    assert.equal(gitSync(['-C', main, '-c', 'user.name=Test', '-c', 'user.email=test@example.com', 'commit', '-qm', 'initial'], undefined).status, 0);
+    const linked = join(temp('crtr-association-linked-parent-'), 'checkout');
+    assert.equal(gitSync(['-C', main, 'worktree', 'add', '-q', linked, 'HEAD'], undefined).status, 0);
+    const mainOwner = join(main, 'packages', 'api');
+    const linkedOwner = join(linked, 'packages', 'api');
+    mkdirSync(mainOwner, { recursive: true });
+    mkdirSync(linkedOwner, { recursive: true });
+    const first = associateRepository(mainOwner);
+    const second = associateRepository(linkedOwner);
+    assert.equal(first.ok, true);
+    assert.equal(second.ok, true);
+    if (!first.ok || !second.ok)
+        return;
+    assert.equal(first.association.repositoryKey, second.association.repositoryKey);
+    assert.equal(first.association.ownerRelativePath, second.association.ownerRelativePath);
+    assert.notEqual(first.association.repositoryRoot, second.association.repositoryRoot);
+});
+test('non-git association chooses the outermost ancestor store and respects the home fence', () => {
+    const outer = join(homedir(), 'workspace');
+    const inner = join(outer, 'packages', 'api');
+    mkdirSync(inner, { recursive: true });
+    makeStore(outer);
+    makeStore(inner);
+    const result = associateRepository(inner);
+    assert.equal(result.ok, true);
+    if (!result.ok)
+        return;
+    assert.equal(result.association.kind, 'non-git');
+    assert.equal(result.association.repositoryRoot, outer);
+    assert.equal(result.association.repositoryKey, `path:${outer}`);
+    assert.equal(result.association.ownerRelativePath, 'packages/api');
+    const homeStoreOwner = join(homedir(), 'not-a-project');
+    mkdirSync(homeStoreOwner, { recursive: true });
+    makeStore(homedir());
+    const fenced = associateRepository(homeStoreOwner);
+    assert.equal(fenced.ok, false);
+    if (!fenced.ok)
+        assert.equal(fenced.code, 'no-project-root');
+});
+test('non-git failures are not cached and symlinked owners realpath before deriving paths', () => {
+    const root = temp('crtr-association-heal-');
+    const owner = join(root, 'docs');
+    mkdirSync(owner, { recursive: true });
+    const before = associateRepository(owner);
+    assert.equal(before.ok, false);
+    if (!before.ok)
+        assert.equal(before.code, 'no-project-root');
+    makeStore(root);
+    const healed = associateRepository(owner);
+    assert.equal(healed.ok, true);
+    if (!healed.ok)
+        return;
+    assert.equal(healed.association.repositoryRoot, root);
+    assert.equal(healed.association.ownerRelativePath, 'docs');
+    const link = join(root, 'alias');
+    symlinkSync(owner, link, 'dir');
+    const linked = associateRepository(link);
+    assert.equal(linked.ok, true);
+    if (!linked.ok)
+        return;
+    assert.equal(linked.association.ownerRelativePath, 'docs');
+    assert.equal(linked.association.repositoryRoot, root);
+});
+test('slugging and owner-path validation are explicit and lossless', () => {
+    assert.equal(slugCanonicalSegment('  My Notes!!!  '), 'my-notes');
+    assert.equal(slugCanonicalSegment('notes.md'), 'notes.md');
+    assert.equal(slugCanonicalPath('01-My Notes!!!/notes.md'), 'my-notes/notes');
+    assert.deepEqual(normalizeOwnerRelativePath('My Notes!!!\\notes.md'), { ok: true, path: 'my-notes/notes.md' });
+    assert.deepEqual(normalizeOwnerRelativePath('01-api/00-Notes'), { ok: true, path: 'api/notes' });
+    assert.deepEqual(normalizeOwnerRelativePath(''), { ok: true, path: '' });
+    assert.deepEqual(normalizeOwnerRelativePath('.'), { ok: true, path: '' });
+    for (const path of ['!!!', 'INDEX']) {
+        const result = normalizeOwnerRelativePath(path);
+        assert.equal(result.ok, false, `${path} must be rejected`);
+    }
+});

package/dist/core/__tests__/repository-root-identity.test.d.ts

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