@mx-space/cli 0.14.2 → 0.15.1

package/dist/test/services/Resolver.test.js

@@ -0,0 +1,320 @@
+import { Effect, Layer } from 'effect';
+import { describe, expect, it, vi } from 'vitest';
+import { Api, } from '../../src/services/Api';
+import { Generic } from '../../src/domain/errors';
+import { isSnowflakeId, layer as resolverLayer, make, matchItem, Resolver, } from '../../src/services/Resolver';
+function mockApi(responses) {
+    const raw = (path, _options) => Effect.tryPromise({
+        try: async () => {
+            if (!(path in responses)) {
+                throw new Error(`unexpected request: ${path}`);
+            }
+            const v = responses[path];
+            return typeof v === 'function' ? await v() : v;
+        },
+        catch: (e) => new Generic({
+            message: String(e?.message ?? e),
+        }),
+    });
+    const request = (path, options) => raw(path, options);
+    return { request, raw };
+}
+// ---------------------------------------------------------------------------
+// Pure helpers
+// ---------------------------------------------------------------------------
+describe('isSnowflakeId', () => {
+    it('accepts 15-digit numeric ids', () => {
+        expect(isSnowflakeId('123456789012345')).toBe(true);
+        expect(isSnowflakeId('1234567890123456789')).toBe(true);
+    });
+    it('rejects short ids and slugs', () => {
+        expect(isSnowflakeId('12345')).toBe(false);
+        expect(isSnowflakeId('hello-world')).toBe(false);
+    });
+});
+describe('matchItem', () => {
+    const items = [
+        { id: 'a', slug: 'blog', name: 'Blog' },
+        { id: 'b', slug: 'tech', name: 'Technology' },
+    ];
+    it('matches by exact slug', () => {
+        expect(matchItem(items, 'tech')?.id).toBe('b');
+    });
+    it('matches by exact name', () => {
+        expect(matchItem(items, 'Blog')?.id).toBe('a');
+    });
+    it('matches case-insensitively as fallback', () => {
+        expect(matchItem(items, 'BLOG')?.id).toBe('a');
+    });
+    it('returns null when nothing matches', () => {
+        expect(matchItem(items, 'nope')).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// resolveCategory / resolveTopic via in-memory mock Api
+// ---------------------------------------------------------------------------
+describe('resolveCategory / resolveTopic', () => {
+    it('returns snowflake ids unchanged without a request', async () => {
+        const api = mockApi({});
+        const svc = make(api);
+        const id = await Effect.runPromise(svc.resolveCategory('123456789012345'));
+        expect(id).toBe('123456789012345');
+    });
+    it('resolves a slug through /categories', async () => {
+        const api = mockApi({
+            '/categories': { data: [{ id: 'cat-1', slug: 'blog', name: 'Blog' }] },
+        });
+        const svc = make(api);
+        const id = await Effect.runPromise(svc.resolveCategory('blog'));
+        expect(id).toBe('cat-1');
+    });
+    it('fails ValidationFailed with suggestions on unknown slug', async () => {
+        const api = mockApi({
+            '/categories': { data: [{ id: 'cat-1', slug: 'blog', name: 'Blog' }] },
+        });
+        const svc = make(api);
+        const exit = await Effect.runPromiseExit(svc.resolveCategory('blo'));
+        expect(exit._tag).toBe('Failure');
+        if (exit._tag === 'Failure') {
+            const err = extractError(exit.cause);
+            expect(err?._tag).toBe('ValidationFailed');
+            expect(err.message).toMatch(/category "blo" not found/);
+            // suggestion label picks `name` before `slug` (legacy fuzzySuggest behavior)
+            expect(err.details?.issues?.[0]?.suggestions).toContain('Blog');
+        }
+    });
+    it('hits topic endpoint /topics/all', async () => {
+        const api = mockApi({
+            '/topics/all': [{ id: 'topic-1', slug: 'misc', name: 'Misc' }],
+        });
+        const svc = make(api);
+        const id = await Effect.runPromise(svc.resolveTopic('misc'));
+        expect(id).toBe('topic-1');
+    });
+    it('caches list within ttl window', async () => {
+        const responses = {
+            '/categories': vi.fn(() => ({
+                data: [{ id: 'cat-1', slug: 'blog' }],
+            })),
+        };
+        const api = mockApi(responses);
+        const svc = make(api);
+        await Effect.runPromise(svc.resolveCategory('blog'));
+        await Effect.runPromise(svc.resolveCategory('blog'));
+        expect(responses['/categories']).toHaveBeenCalledTimes(1);
+    });
+    it('invalidate(kind) forces re-fetch', async () => {
+        const responses = {
+            '/categories': vi.fn(() => ({
+                data: [{ id: 'cat-1', slug: 'blog' }],
+            })),
+        };
+        const api = mockApi(responses);
+        const svc = make(api);
+        await Effect.runPromise(svc.resolveCategory('blog'));
+        await Effect.runPromise(svc.invalidate('category'));
+        await Effect.runPromise(svc.resolveCategory('blog'));
+        expect(responses['/categories']).toHaveBeenCalledTimes(2);
+    });
+});
+// ---------------------------------------------------------------------------
+// resolveCategoryRefs
+// ---------------------------------------------------------------------------
+describe('resolveCategoryRefs', () => {
+    it('maps a list of slugs/ids to ids', async () => {
+        const api = mockApi({
+            '/categories': {
+                data: [
+                    { id: 'cat-1', slug: 'blog' },
+                    { id: 'cat-2', slug: 'tech' },
+                ],
+            },
+        });
+        const svc = make(api);
+        const ids = await Effect.runPromise(svc.resolveCategoryRefs(['blog', '999999999999999', 'tech']));
+        expect(ids).toEqual(['cat-1', '999999999999999', 'cat-2']);
+    });
+    it('fails on first unknown ref', async () => {
+        const api = mockApi({
+            '/categories': { data: [{ id: 'cat-1', slug: 'blog' }] },
+        });
+        const svc = make(api);
+        const exit = await Effect.runPromiseExit(svc.resolveCategoryRefs(['blog', 'missing']));
+        expect(exit._tag).toBe('Failure');
+        if (exit._tag === 'Failure') {
+            expect(extractError(exit.cause)?._tag).toBe('ValidationFailed');
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// Direct API resolvers (port of commands/post/note/category/resolve.ts)
+// ---------------------------------------------------------------------------
+describe('resolvePostReadPath / resolvePostId', () => {
+    it('resolves ordinary post slugs through /posts/get-url', async () => {
+        const api = mockApi({
+            '/posts/get-url/hello-world': { path: '/writing/hello-world' },
+        });
+        const svc = make(api);
+        expect(await Effect.runPromise(svc.resolvePostReadPath('hello-world'))).toBe('/posts/writing/hello-world');
+    });
+    it('resolves a post id by reading the resolved category route', async () => {
+        const api = mockApi({
+            '/posts/get-url/hello-world': { path: '/writing/hello-world' },
+            '/posts/writing/hello-world': { id: 'post-1' },
+        });
+        const svc = make(api);
+        expect(await Effect.runPromise(svc.resolvePostId('hello-world'))).toBe('post-1');
+    });
+    it('keeps snowflake ids without a network round-trip', async () => {
+        const api = mockApi({});
+        const svc = make(api);
+        expect(await Effect.runPromise(svc.resolvePostReadPath('123456789012345'))).toBe('/posts/123456789012345');
+    });
+    it('fails ResourceNotFound when /posts/get-url returns no path', async () => {
+        const api = mockApi({
+            '/posts/get-url/missing': {},
+        });
+        const svc = make(api);
+        const exit = await Effect.runPromiseExit(svc.resolvePostId('missing'));
+        expect(exit._tag).toBe('Failure');
+        if (exit._tag === 'Failure') {
+            expect(extractError(exit.cause)?._tag).toBe('ResourceNotFound');
+        }
+    });
+    it('unwraps the response envelope ({ data: { path } }) from /posts/get-url', async () => {
+        const api = mockApi({
+            '/posts/get-url/aws-vless': { data: { path: '/writing/aws-vless' } },
+        });
+        const svc = make(api);
+        expect(await Effect.runPromise(svc.resolvePostReadPath('aws-vless'))).toBe('/posts/writing/aws-vless');
+    });
+    it('unwraps the response envelope ({ data: { id } }) from the post detail route', async () => {
+        const api = mockApi({
+            '/posts/get-url/aws-vless': { data: { path: '/writing/aws-vless' } },
+            '/posts/writing/aws-vless': { data: { id: 'post-9' }, meta: {} },
+        });
+        const svc = make(api);
+        expect(await Effect.runPromise(svc.resolvePostId('aws-vless'))).toBe('post-9');
+    });
+});
+describe('resolveNoteId', () => {
+    it('returns snowflake ids unchanged', async () => {
+        const api = mockApi({});
+        const svc = make(api);
+        expect(await Effect.runPromise(svc.resolveNoteId('123456789012345'))).toBe('123456789012345');
+    });
+    it('resolves numeric nid through /notes/nid/:nid envelope', async () => {
+        const api = mockApi({
+            '/notes/nid/42': { data: { id: 'note-1', nid: 42 } },
+        });
+        const svc = make(api);
+        expect(await Effect.runPromise(svc.resolveNoteId('42'))).toBe('note-1');
+    });
+    it('accepts the flat envelope shape', async () => {
+        const api = mockApi({
+            '/notes/nid/7': { id: 'note-flat' },
+        });
+        const svc = make(api);
+        expect(await Effect.runPromise(svc.resolveNoteId('7'))).toBe('note-flat');
+    });
+    it('rejects non-snowflake non-numeric input with ValidationFailed', async () => {
+        const api = mockApi({});
+        const svc = make(api);
+        const exit = await Effect.runPromiseExit(svc.resolveNoteId('hello-world'));
+        expect(exit._tag).toBe('Failure');
+        if (exit._tag === 'Failure') {
+            const err = extractError(exit.cause);
+            expect(err?._tag).toBe('ValidationFailed');
+            expect(err.message).toMatch(/invalid note reference: hello-world/);
+        }
+    });
+    it('fails ResourceNotFound when nid lookup returns no id', async () => {
+        const api = mockApi({
+            '/notes/nid/99': { data: {} },
+        });
+        const svc = make(api);
+        const exit = await Effect.runPromiseExit(svc.resolveNoteId('99'));
+        expect(exit._tag).toBe('Failure');
+        if (exit._tag === 'Failure') {
+            expect(extractError(exit.cause)?._tag).toBe('ResourceNotFound');
+        }
+    });
+});
+describe('resolveCategoryId (direct /categories/:slug envelope)', () => {
+    it('returns snowflake ids unchanged', async () => {
+        const api = mockApi({});
+        const svc = make(api);
+        expect(await Effect.runPromise(svc.resolveCategoryId('123456789012345'))).toBe('123456789012345');
+    });
+    it('unwraps the double envelope', async () => {
+        const api = mockApi({
+            '/categories/blog': { data: { id: 'cat-1', name: 'Blog' } },
+        });
+        const svc = make(api);
+        expect(await Effect.runPromise(svc.resolveCategoryId('blog'))).toBe('cat-1');
+    });
+    it('percent-encodes slug characters before hitting the API', async () => {
+        const api = mockApi({
+            '/categories/hello%20world': { data: { id: 'cat-2' } },
+        });
+        const svc = make(api);
+        expect(await Effect.runPromise(svc.resolveCategoryId('hello world'))).toBe('cat-2');
+    });
+    it('fails ResourceNotFound when envelope has no id', async () => {
+        const api = mockApi({
+            '/categories/missing': { data: {} },
+        });
+        const svc = make(api);
+        const exit = await Effect.runPromiseExit(svc.resolveCategoryId('missing'));
+        expect(exit._tag).toBe('Failure');
+        if (exit._tag === 'Failure') {
+            const err = extractError(exit.cause);
+            expect(err?._tag).toBe('ResourceNotFound');
+            expect(err.message).toMatch(/category not found: missing/);
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// Layer wiring: Default Resolver layer composes from Api
+// ---------------------------------------------------------------------------
+describe('Resolver tag layer wiring', () => {
+    it('composes via Layer with an ambient Api service', async () => {
+        const api = mockApi({
+            '/categories': { data: [{ id: 'cat-1', slug: 'blog' }] },
+        });
+        const program = Effect.gen(function* () {
+            const r = yield* Resolver;
+            return yield* r.resolveCategory('blog');
+        });
+        const apiLayer = Layer.succeed(Api, api);
+        const out = await Effect.runPromise(program.pipe(Effect.provide(Resolver.Default), Effect.provide(apiLayer)));
+        expect(out).toBe('cat-1');
+    });
+    it('layer(api) helper exposes Resolver service directly', async () => {
+        const api = mockApi({
+            '/categories': { data: [{ id: 'cat-1', slug: 'blog' }] },
+        });
+        const program = Effect.flatMap(Resolver, (r) => r.resolveCategory('blog'));
+        const out = await Effect.runPromise(program.pipe(Effect.provide(resolverLayer(api))));
+        expect(out).toBe('cat-1');
+    });
+});
+function extractError(cause) {
+    const seen = new Set();
+    const visit = (node) => {
+        if (!node || typeof node !== 'object' || seen.has(node))
+            return undefined;
+        seen.add(node);
+        const obj = node;
+        if (typeof obj._tag === 'string' && obj._tag !== 'Die' && obj._tag !== 'Fail' && obj._tag !== 'Sequential' && obj._tag !== 'Parallel' && obj._tag !== 'Interrupt' && obj._tag !== 'Empty' && obj._tag !== 'Annotated') {
+            return obj;
+        }
+        for (const v of Object.values(obj)) {
+            const t = visit(v);
+            if (t)
+                return t;
+        }
+        return undefined;
+    };
+    return visit(cause);
+}

package/dist/test/services/Skill.test.d.ts

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

package/dist/test/services/Skill.test.js

@@ -0,0 +1,261 @@
+import { Effect, Exit, Layer } from 'effect';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { Skill } from '../../src/services/Skill';
+import { makeMemFs, TestFsLive, TestPathLive } from '../helper/test-fs';
+const CLI_DIR = '/test/cli-skills';
+const HAKLEX_DIR = '/test/haklex-skills';
+const chapter = (slug, title, description, order, body) => `---\nslug: ${slug}\ntitle: ${title}\ndescription: ${description}\norder: ${order}\n---\n\n${body}\n`;
+const makeLayer = (seed) => {
+    const mem = makeMemFs();
+    seed(mem);
+    const fsLayer = TestFsLive(mem);
+    const baseLayer = Layer.merge(fsLayer, TestPathLive);
+    const skillLayer = Skill.Default.pipe(Layer.provide(baseLayer));
+    return Layer.mergeAll(baseLayer, skillLayer);
+};
+const tagOf = (cause) => {
+    const err = cause?.error ?? cause?.failure ?? cause;
+    return err?._tag ?? err?.error?._tag ?? err?.failure?._tag;
+};
+beforeEach(() => {
+    process.env.MXS_SKILL_CLI_DIR = CLI_DIR;
+    process.env.MXS_SKILL_HAKLEX_DIR = HAKLEX_DIR;
+});
+afterEach(() => {
+    delete process.env.MXS_SKILL_CLI_DIR;
+    delete process.env.MXS_SKILL_HAKLEX_DIR;
+});
+describe('Skill.list', () => {
+    it('returns chapters sorted by order, with cli + haklex sources merged', async () => {
+        const layer = makeLayer((mem) => {
+            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
+            mem.nodes.set(HAKLEX_DIR, { type: 'dir', mode: 0o755 });
+            mem.nodes.set(`${HAKLEX_DIR}/references`, { type: 'dir', mode: 0o755 });
+            mem.nodes.set(`${CLI_DIR}/overview.md`, {
+                type: 'file',
+                data: chapter('overview', 'Overview', 'desc-0', 0, 'body 0'),
+                mode: 0o644,
+            });
+            mem.nodes.set(`${CLI_DIR}/safety.md`, {
+                type: 'file',
+                data: chapter('safety', 'Safety', 'desc-60', 60, 'body 60'),
+                mode: 0o644,
+            });
+            mem.nodes.set(`${HAKLEX_DIR}/SKILL.md`, {
+                type: 'file',
+                data: `---\nname: litexml-authoring\ndescription: haklex overview\n---\n\nliteXML body\n`,
+                mode: 0o644,
+            });
+            mem.nodes.set(`${HAKLEX_DIR}/references/cli.md`, {
+                type: 'file',
+                data: `# cli reference\n\nbody\n`,
+                mode: 0o644,
+            });
+        });
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const skill = yield* Skill;
+            return yield* skill.list;
+        }).pipe(Effect.provide(layer)));
+        expect(result.map((c) => c.slug)).toEqual([
+            'overview',
+            'safety',
+            'litexml',
+            'litexml-cli',
+        ]);
+        expect(result.find((c) => c.slug === 'litexml')?.source).toBe('haklex');
+        expect(result.find((c) => c.slug === 'litexml-cli')?.source).toBe('haklex');
+        expect(result[0].source).toBe('cli');
+    });
+    it('fails with SkillCorpusEmpty when both sources are empty', async () => {
+        const layer = makeLayer(() => { });
+        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
+            const skill = yield* Skill;
+            return yield* skill.list;
+        }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit)) {
+            expect(tagOf(exit.cause)).toBe('SkillCorpusEmpty');
+        }
+    });
+});
+describe('Skill.get', () => {
+    it('fetches a chapter by slug', async () => {
+        const layer = makeLayer((mem) => {
+            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
+            mem.nodes.set(`${CLI_DIR}/overview.md`, {
+                type: 'file',
+                data: chapter('overview', 'Overview', 'desc', 0, 'body'),
+                mode: 0o644,
+            });
+        });
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const skill = yield* Skill;
+            return yield* skill.get('overview');
+        }).pipe(Effect.provide(layer)));
+        expect(result.title).toBe('Overview');
+        expect(result.body.trim()).toBe('body');
+    });
+    it('fails with ChapterNotFound when slug is missing', async () => {
+        const layer = makeLayer((mem) => {
+            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
+            mem.nodes.set(`${CLI_DIR}/overview.md`, {
+                type: 'file',
+                data: chapter('overview', 'Overview', 'desc', 0, 'body'),
+                mode: 0o644,
+            });
+        });
+        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
+            const skill = yield* Skill;
+            return yield* skill.get('nonexistent');
+        }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit)) {
+            expect(tagOf(exit.cause)).toBe('ChapterNotFound');
+        }
+    });
+    it('hints at haklex upgrade when missing slug starts with litexml', async () => {
+        const layer = makeLayer((mem) => {
+            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
+            mem.nodes.set(`${CLI_DIR}/overview.md`, {
+                type: 'file',
+                data: chapter('overview', 'Overview', 'desc', 0, 'body'),
+                mode: 0o644,
+            });
+        });
+        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
+            const skill = yield* Skill;
+            return yield* skill.get('litexml');
+        }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit)) {
+            const err = exit.cause.error ?? exit.cause.failure;
+            expect(err?.hint).toMatch(/haklex/);
+        }
+    });
+});
+describe('Skill.search', () => {
+    it('returns chapters ranked by match, with snippets', async () => {
+        const layer = makeLayer((mem) => {
+            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
+            mem.nodes.set(`${CLI_DIR}/a.md`, {
+                type: 'file',
+                data: chapter('a', 'Alpha dryrun', 'd', 0, 'first dryrun appears here\nand again dryrun in body'),
+                mode: 0o644,
+            });
+            mem.nodes.set(`${CLI_DIR}/b.md`, {
+                type: 'file',
+                data: chapter('b', 'Beta', 'all about dryrun', 1, 'no body match'),
+                mode: 0o644,
+            });
+            mem.nodes.set(`${CLI_DIR}/c.md`, {
+                type: 'file',
+                data: chapter('c', 'Gamma', 'd', 2, 'totally unrelated content'),
+                mode: 0o644,
+            });
+        });
+        const hits = await Effect.runPromise(Effect.gen(function* () {
+            const skill = yield* Skill;
+            return yield* skill.search('dryrun');
+        }).pipe(Effect.provide(layer)));
+        expect(hits.length).toBe(2);
+        expect(hits[0].slug).toBe('a');
+        expect(hits[0].snippets.length).toBeGreaterThanOrEqual(2);
+        expect(hits[1].slug).toBe('b');
+    });
+    it('matches a multi-word AND query across hyphen-joined tokens', async () => {
+        const layer = makeLayer((mem) => {
+            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
+            mem.nodes.set(`${CLI_DIR}/a.md`, {
+                type: 'file',
+                data: chapter('a', 'AI Authoring', 'AI involvement disclosure', 0, 'Fully AI-generated bodies should declare aiGen 2.'),
+                mode: 0o644,
+            });
+            mem.nodes.set(`${CLI_DIR}/b.md`, {
+                type: 'file',
+                data: chapter('b', 'Other', 'unrelated', 1, 'only ai here, no second token'),
+                mode: 0o644,
+            });
+        });
+        const hits = await Effect.runPromise(Effect.gen(function* () {
+            const skill = yield* Skill;
+            return yield* skill.search('ai generated');
+        }).pipe(Effect.provide(layer)));
+        expect(hits.map((h) => h.slug)).toEqual(['a']);
+        expect(hits[0].snippets.length).toBeGreaterThan(0);
+    });
+    it('matches a prefix query (aigen → aiGen)', async () => {
+        const layer = makeLayer((mem) => {
+            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
+            mem.nodes.set(`${CLI_DIR}/a.md`, {
+                type: 'file',
+                data: chapter('a', 'Authoring', 'meta presets', 0, 'set meta.aiGen to 2 for full AI'),
+                mode: 0o644,
+            });
+        });
+        const hits = await Effect.runPromise(Effect.gen(function* () {
+            const skill = yield* Skill;
+            return yield* skill.search('aigen');
+        }).pipe(Effect.provide(layer)));
+        expect(hits.length).toBe(1);
+        expect(hits[0].slug).toBe('a');
+        expect(hits[0].snippets[0]).toMatch(/aiGen/);
+    });
+    it('returns empty array for blank keyword', async () => {
+        const layer = makeLayer((mem) => {
+            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
+            mem.nodes.set(`${CLI_DIR}/a.md`, {
+                type: 'file',
+                data: chapter('a', 'A', 'd', 0, 'body'),
+                mode: 0o644,
+            });
+        });
+        const hits = await Effect.runPromise(Effect.gen(function* () {
+            const skill = yield* Skill;
+            return yield* skill.search('   ');
+        }).pipe(Effect.provide(layer)));
+        expect(hits).toEqual([]);
+    });
+});
+describe('Skill frontmatter parser', () => {
+    it('fails when required field is missing', async () => {
+        const layer = makeLayer((mem) => {
+            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
+            mem.nodes.set(`${CLI_DIR}/bad.md`, {
+                type: 'file',
+                data: `---\nslug: bad\ntitle: B\n---\n\nbody\n`,
+                mode: 0o644,
+            });
+        });
+        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
+            const skill = yield* Skill;
+            return yield* skill.list;
+        }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit)) {
+            expect(tagOf(exit.cause)).toBe('SkillCorpusEmpty');
+        }
+    });
+    it('fails when two cli chapters declare the same slug', async () => {
+        const layer = makeLayer((mem) => {
+            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
+            mem.nodes.set(`${CLI_DIR}/a.md`, {
+                type: 'file',
+                data: chapter('dup', 'A', 'd', 0, 'a'),
+                mode: 0o644,
+            });
+            mem.nodes.set(`${CLI_DIR}/b.md`, {
+                type: 'file',
+                data: chapter('dup', 'B', 'd', 1, 'b'),
+                mode: 0o644,
+            });
+        });
+        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
+            const skill = yield* Skill;
+            return yield* skill.list;
+        }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit)) {
+            expect(tagOf(exit.cause)).toBe('SkillCorpusEmpty');
+        }
+    });
+});

package/dist/test/services/UpdateNotifier.spawn.test.d.ts

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

package/dist/test/services/UpdateNotifier.spawn.test.js

@@ -0,0 +1,73 @@
+import { EventEmitter } from 'node:events';
+import { Effect } from 'effect';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const spawnMock = vi.hoisted(() => vi.fn());
+vi.mock('node:child_process', () => ({ spawn: spawnMock }));
+import { make } from '../../src/services/UpdateNotifier';
+const makeFetchOK = () => async () => ({
+    ok: true,
+    status: 200,
+    headers: { get: () => null },
+    async json() {
+        return { version: '9.9.9', engines: { node: '>=22' } };
+    },
+    async text() {
+        return '';
+    },
+});
+const makeChild = () => {
+    const child = new EventEmitter();
+    child.stderr = new EventEmitter();
+    return child;
+};
+describe('UpdateNotifier default spawn adapter', () => {
+    beforeEach(() => {
+        spawnMock.mockReset();
+    });
+    it('uses child_process.spawn when no spawn override is supplied', async () => {
+        spawnMock.mockImplementation(() => {
+            const child = makeChild();
+            queueMicrotask(() => {
+                child.stderr.emit('data', Buffer.from('npm notice\n'));
+                child.emit('exit', 0);
+            });
+            return child;
+        });
+        const stderrSpy = vi
+            .spyOn(process.stderr, 'write')
+            .mockImplementation(() => true);
+        try {
+            const svc = make({ fetchImpl: makeFetchOK() });
+            const res = await Effect.runPromise(svc.runUpdate({
+                currentVersion: '0.2.0',
+                entrypoint: '/usr/local/lib/node_modules/@mx-space/cli/dist/bin/mxs.mjs',
+                yes: true,
+                json: true,
+            }));
+            expect(res.upgraded).toBe(true);
+            expect(spawnMock).toHaveBeenCalledWith('npm', ['install', '-g', '@mx-space/cli@latest'], expect.objectContaining({
+                stdio: ['ignore', 'inherit', 'pipe'],
+            }));
+        }
+        finally {
+            stderrSpy.mockRestore();
+        }
+    });
+    it('turns child spawn errors into a failed update result', async () => {
+        spawnMock.mockImplementation(() => {
+            const child = makeChild();
+            queueMicrotask(() => {
+                child.emit('error', new Error('spawn denied'));
+            });
+            return child;
+        });
+        const svc = make({ fetchImpl: makeFetchOK() });
+        const exit = await Effect.runPromiseExit(svc.runUpdate({
+            currentVersion: '0.2.0',
+            entrypoint: '/usr/local/lib/node_modules/@mx-space/cli/dist/bin/mxs.mjs',
+            yes: true,
+            json: true,
+        }));
+        expect(exit._tag).toBe('Failure');
+    });
+});

package/dist/test/services/UpdateNotifier.test.d.ts

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