claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/__tests__/agentModelResolve.test.cjs

@@ -1,311 +0,0 @@
-/**
- * agentModelResolve.test.cjs — unit tests for resolveEpicModel: the shared
- * persona-model resolver both EpicTerminalPane.tsx's Terminal-view launch
- * and chatRunner.cjs's headless Chat-view launch should agree with.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/agentModelResolve.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const {
-  FALLBACK_MODEL,
-  resolveEpicModel,
-  findAgentTypeByClaudeSessionId,
-  readOverlayAwarePersonaModel,
-  resolvePrdPersonaForSpawn,
-} = require('../lib/agentModelResolve.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkTmpDir(prefix) {
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), prefix));
-  tmpDirs.push(dir);
-  return dir;
-}
-
-function writeIndex(cwd, sessions) {
-  const dir = path.join(cwd, 'session-manager-operations', 'prompt-sessions');
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, 'active-index.json'), JSON.stringify({ sessions, events: {} }, null, 2));
-}
-
-function writePersona(globalDir, name, frontmatter) {
-  fs.mkdirSync(globalDir, { recursive: true });
-  const lines = ['---', `name: ${name}`, ...frontmatter, '---', 'body'];
-  fs.writeFileSync(path.join(globalDir, `${name}.md`), lines.join('\n'));
-}
-
-const noopValidatePath = (p) => p;
-
-test('resolves the agentType persona model for a matching Epic', async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  const globalDir = await mkTmpDir('sm-agentmodel-agents-');
-  writeIndex(cwd, { 'epic-1': { id: 'epic-1', claudeSessionId: 'sess-opus', agentType: 'opus-persona' } });
-  writePersona(globalDir, 'opus-persona', ['model: opus']);
-
-  const model = resolveEpicModel({
-    cwd,
-    claudeSessionId: 'sess-opus',
-    deps: { globalDir, validatePath: noopValidatePath },
-  });
-
-  expect(model).toBe('opus');
-});
-
-test('falls back to the fallback model when the Epic has no agentType', async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  writeIndex(cwd, { 'epic-1': { id: 'epic-1', claudeSessionId: 'sess-none' } });
-
-  const model = resolveEpicModel({ cwd, claudeSessionId: 'sess-none' });
-
-  expect(model).toBe(FALLBACK_MODEL);
-});
-
-test("falls back when the persona's model is 'inherit'", async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  const globalDir = await mkTmpDir('sm-agentmodel-agents-');
-  writeIndex(cwd, { 'epic-1': { id: 'epic-1', claudeSessionId: 'sess-inherit', agentType: 'inherit-persona' } });
-  writePersona(globalDir, 'inherit-persona', ['model: inherit']);
-
-  const model = resolveEpicModel({
-    cwd,
-    claudeSessionId: 'sess-inherit',
-    deps: { globalDir, validatePath: noopValidatePath },
-  });
-
-  expect(model).toBe(FALLBACK_MODEL);
-});
-
-test('falls back when no Epic matches the claudeSessionId', () => {
-  const model = resolveEpicModel({ cwd: '/nonexistent-cwd-xyz', claudeSessionId: 'no-such-session' });
-  expect(model).toBe(FALLBACK_MODEL);
-});
-
-test('never throws when cwd/claudeSessionId are missing', () => {
-  expect(resolveEpicModel({})).toBe(FALLBACK_MODEL);
-});
-
-test('findAgentTypeByClaudeSessionId returns null for no match', async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  writeIndex(cwd, {});
-  expect(findAgentTypeByClaudeSessionId(cwd, 'missing')).toBeNull();
-});
-
-test('readOverlayAwarePersonaModel returns null for a persona with no model field', async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  const globalDir = await mkTmpDir('sm-agentmodel-agents-');
-  writePersona(globalDir, 'no-model-persona', []);
-  expect(readOverlayAwarePersonaModel('no-model-persona', { cwd, globalDir, validatePath: noopValidatePath })).toBeNull();
-});
-
-test('readOverlayAwarePersonaModel returns null (never throws) for a path-traversal agentType rejected by validatePath', async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  const globalDir = await mkTmpDir('sm-agentmodel-agents-');
-  const realValidatePath = (p) => {
-    const real = path.resolve(p);
-    if (!real.startsWith(path.resolve(globalDir) + path.sep)) throw new Error('outside allowed boundaries');
-    return real;
-  };
-  expect(readOverlayAwarePersonaModel('../../../etc/passwd', { cwd, globalDir, validatePath: realValidatePath })).toBeNull();
-});
-
-// READ side of the agentType FK: a persona that was valid when the Epic was
-// created but got deleted afterward (rename/deletion in Agent Library) must
-// still resolve to null, not throw — the WRITE side (epicMint.cjs's
-// ensureEpic) is what refuses a bad reference at creation time.
-test('readOverlayAwarePersonaModel returns null (does not throw) for a persona deleted after the Epic was created, and logs it once via opsErrorLog', async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  const globalDir = await mkTmpDir('sm-agentmodel-agents-'); // never written to — simulates a deleted persona
-
-  expect(() => readOverlayAwarePersonaModel('deleted-persona', { globalDir, validatePath: noopValidatePath, cwd })).not.toThrow();
-  expect(readOverlayAwarePersonaModel('deleted-persona', { globalDir, validatePath: noopValidatePath, cwd })).toBeNull();
-
-  const { todayFile } = require('../lib/opsErrorLog.cjs');
-  const lines = fs.readFileSync(todayFile(cwd), 'utf8').split('\n').filter(Boolean).map((l) => JSON.parse(l));
-  const matches = lines.filter((l) => l.message.includes('deleted-persona'));
-  // Logged once despite two readOverlayAwarePersonaModel calls above — dedup key is (cwd, agentType).
-  expect(matches).toHaveLength(1);
-  expect(matches[0].level).toBe('warn');
-});
-
-// resolvePrdPersonaForSpawn — the PRD-path resolver scheduler.cjs's executeJob
-// calls to turn a job's agentType into a --append-system-prompt body and a
-// --model value (PRD 1115).
-
-test('resolvePrdPersonaForSpawn returns the persona body and its own model, overriding the fallback', async () => {
-  const result = await resolvePrdPersonaForSpawn({
-    cwd: '/irrelevant',
-    agentType: 'dev-lead',
-    deps: {
-      getPersonaBody: async ({ name }) => {
-        expect(name).toBe('dev-lead');
-        return { path: '/home/user/.claude/agents/dev-lead.md', text: '---\nmodel: opus\n---\nOperate methodically.' };
-      },
-    },
-  });
-  expect(result.model).toBe('opus');
-  expect(result.systemPrompt).toBe('Operate methodically.');
-  expect(result.personaPath).toBe('/home/user/.claude/agents/dev-lead.md');
-});
-
-test("resolvePrdPersonaForSpawn falls back to the fallback model when the persona's model is 'inherit'", async () => {
-  const result = await resolvePrdPersonaForSpawn({
-    cwd: '/irrelevant',
-    agentType: 'dev-lead',
-    deps: { getPersonaBody: async () => ({ path: '/x/dev-lead.md', text: '---\nmodel: inherit\n---\nBody text.' }) },
-  });
-  expect(result.model).toBe(FALLBACK_MODEL);
-});
-
-test('resolvePrdPersonaForSpawn falls back without throwing when agentType no longer resolves to a persona file, and logs it once', async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  const call = () => resolvePrdPersonaForSpawn({
-    cwd,
-    agentType: 'ghost-persona',
-    deps: { getPersonaBody: async () => null },
-  });
-  await expect(call()).resolves.toEqual({ model: FALLBACK_MODEL, systemPrompt: null, personaPath: null });
-  await call(); // second call must not log a second line (dedup)
-
-  const { todayFile } = require('../lib/opsErrorLog.cjs');
-  const lines = fs.readFileSync(todayFile(cwd), 'utf8').split('\n').filter(Boolean).map((l) => JSON.parse(l));
-  const matches = lines.filter((l) => l.message.includes('ghost-persona'));
-  expect(matches).toHaveLength(1);
-  expect(matches[0].level).toBe('warn');
-});
-
-test('resolvePrdPersonaForSpawn returns the fallback (no persona applied) when agentType is absent, without touching getPersonaBody', async () => {
-  const getPersonaBody = async () => { throw new Error('must not be called'); };
-  const result = await resolvePrdPersonaForSpawn({ cwd: '/irrelevant', agentType: null, deps: { getPersonaBody } });
-  expect(result).toEqual({ model: FALLBACK_MODEL, systemPrompt: null, personaPath: null });
-});
-
-// Overlay-aware resolution (unify-epic-model-resolution): resolveEpicModel
-// must use the SAME project-overlay-then-global precedence
-// resolvePrdPersonaForSpawn already uses — so a project's
-// `.claude/agents/<name>.md` wins for a launched Chat/Terminal session
-// exactly like it already does for a scheduled PRD.
-
-test('resolveEpicModel prefers a project-overlay persona over the global one with the same name', async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  const globalDir = await mkTmpDir('sm-agentmodel-agents-');
-  writeIndex(cwd, { 'epic-1': { id: 'epic-1', claudeSessionId: 'sess-overlay', agentType: 'shared-persona' } });
-  writePersona(globalDir, 'shared-persona', ['model: opus']);
-  const projectAgentsDir = path.join(cwd, '.claude', 'agents');
-  writePersona(projectAgentsDir, 'shared-persona', ['model: haiku']);
-
-  const model = resolveEpicModel({
-    cwd,
-    claudeSessionId: 'sess-overlay',
-    deps: { globalDir, validatePath: noopValidatePath },
-  });
-
-  expect(model).toBe('haiku');
-});
-
-test('resolveEpicModel falls through to the global persona when no project overlay exists', async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  const globalDir = await mkTmpDir('sm-agentmodel-agents-');
-  writeIndex(cwd, { 'epic-1': { id: 'epic-1', claudeSessionId: 'sess-global-only', agentType: 'global-only-persona' } });
-  writePersona(globalDir, 'global-only-persona', ['model: opus']);
-
-  const model = resolveEpicModel({
-    cwd,
-    claudeSessionId: 'sess-global-only',
-    deps: { globalDir, validatePath: noopValidatePath },
-  });
-
-  expect(model).toBe('opus');
-});
-
-test('resolveEpicModel falls back to FALLBACK_MODEL (never throws) for a dangling agentType with no persona file anywhere, and logs it once', async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  const globalDir = await mkTmpDir('sm-agentmodel-agents-'); // never written to
-  writeIndex(cwd, { 'epic-1': { id: 'epic-1', claudeSessionId: 'sess-dangling', agentType: 'ghost-persona' } });
-
-  const call = () => resolveEpicModel({
-    cwd,
-    claudeSessionId: 'sess-dangling',
-    deps: { globalDir, validatePath: noopValidatePath },
-  });
-
-  expect(call).not.toThrow();
-  expect(call()).toBe(FALLBACK_MODEL);
-  call(); // second call must not log a second line (dedup per (cwd, agentType))
-
-  const { todayFile } = require('../lib/opsErrorLog.cjs');
-  const lines = fs.readFileSync(todayFile(cwd), 'utf8').split('\n').filter(Boolean).map((l) => JSON.parse(l));
-  const matches = lines.filter((l) => l.message.includes('ghost-persona'));
-  expect(matches).toHaveLength(1);
-});
-
-// Chat (chatRunner.cjs, in-process) and Terminal (EpicTerminalPane.tsx, via
-// the agents:resolve-epic-model IPC added in this change) both call this
-// exact function with the same { cwd, claudeSessionId } shape — so "the same
-// Epic resolves identically in both views" is structural (one function, one
-// call signature), not a coincidence of two implementations agreeing. This
-// asserts the function is a pure, deterministic read of that Epic's overlay-
-// resolved persona model, which is what makes that guarantee hold.
-test('resolveEpicModel resolves identically for the same Epic across repeated calls (the guarantee Chat and Terminal both rely on)', async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  const globalDir = await mkTmpDir('sm-agentmodel-agents-');
-  writeIndex(cwd, { 'epic-1': { id: 'epic-1', claudeSessionId: 'sess-shared', agentType: 'shared-epic-persona' } });
-  writePersona(globalDir, 'shared-epic-persona', ['model: haiku']);
-
-  const callArgs = { cwd, claudeSessionId: 'sess-shared', deps: { globalDir, validatePath: noopValidatePath } };
-  const chatResult = resolveEpicModel(callArgs);
-  const terminalResult = resolveEpicModel(callArgs); // simulates the IPC-forwarded call Terminal makes
-
-  expect(chatResult).toBe('haiku');
-  expect(terminalResult).toBe(chatResult);
-});
-
-// --model must never be left unpinned (CLAUDE.md model-pinning rule) on any
-// of the three launch paths. resolvePrdPersonaForSpawn's own miss-path tests
-// above already cover the scheduler call site; this covers the shared
-// Chat/Terminal resolver.
-test('resolveEpicModel never returns an empty/falsy --model value, even on every miss path', async () => {
-  expect(resolveEpicModel({})).toBeTruthy();
-  expect(resolveEpicModel({ cwd: '/nonexistent-cwd-xyz', claudeSessionId: 'no-such-session' })).toBeTruthy();
-});
-
-test('resolvePrdPersonaForSpawn caps the persona body at 6000 characters with a truncation notice naming the persona path', async () => {
-  const longBody = 'x'.repeat(6500);
-  const result = await resolvePrdPersonaForSpawn({
-    cwd: '/irrelevant',
-    agentType: 'dev-lead',
-    deps: { getPersonaBody: async () => ({ path: '/home/user/.claude/agents/dev-lead.md', text: longBody }) },
-  });
-  expect(result.systemPrompt.startsWith('x'.repeat(6000))).toBe(true);
-  expect(result.systemPrompt.length).toBeLessThan(longBody.length);
-  expect(result.systemPrompt.toLowerCase()).toContain('truncat');
-  expect(result.systemPrompt).toContain('/home/user/.claude/agents/dev-lead.md');
-});
-
-// Epic-level override (New Session card) > persona frontmatter > fallback.
-test('an Epic-level model override beats the persona model; an Epic without the field resolves unchanged', async () => {
-  const cwd = await mkTmpDir('sm-model-ovr-cwd-');
-  const globalDir = await mkTmpDir('sm-model-ovr-agents-');
-  writeIndex(cwd, {
-    withOverride: { id: 'withOverride', claudeSessionId: 's-ovr', agentType: 'p', model: 'claude-opus-5' },
-    legacy: { id: 'legacy', claudeSessionId: 's-old', agentType: 'p' },
-    inheritOverride: { id: 'inheritOverride', claudeSessionId: 's-inh', agentType: 'p', model: 'inherit' },
-  });
-  writePersona(globalDir, 'p', ['model: haiku']);
-  const deps = { globalDir, validatePath: (p) => p };
-  expect(resolveEpicModel({ cwd, claudeSessionId: 's-ovr', deps })).toBe('claude-opus-5');
-  expect(resolveEpicModel({ cwd, claudeSessionId: 's-old', deps })).toBe('haiku');
-  expect(resolveEpicModel({ cwd, claudeSessionId: 's-inh', deps })).toBe('haiku');
-});

package/src/main/__tests__/agentOverlayWrite.test.cjs

@@ -1,95 +0,0 @@
-/**
- * agentOverlayWrite.test.cjs — Agent Library's per-project OVERRIDE write path
- * (savePersona with `projectName`): frontmatter-only overlay, removal on clear,
- * full-body refusal, and end-to-end resolution for a scheduled PRD.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/agentOverlayWrite.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const { savePersona, listPersonas, getPersonaBody } = require('../agentLibrary.cjs');
-const { resolvePrdPersonaForSpawn } = require('../lib/agentModelResolve.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) await fsp.rm(tmpDirs.pop(), { recursive: true, force: true });
-});
-
-function setup() {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-ov-cwd-'));
-  const globalDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-ov-global-'));
-  tmpDirs.push(cwd, globalDir);
-  const globalFile = path.join(globalDir, 'dev-lead.md');
-  fs.writeFileSync(globalFile, '---\nname: dev-lead\ndescription: d\nmodel: sonnet\n---\nGlobal body.\n');
-  const overlayFile = path.join(cwd, '.claude', 'agents', 'dev-lead.md');
-  const deps = { globalDir, loadSessions: async () => ({ tabs: [{ cwd }] }), validatePath: (p) => p,
-    writeTextAtomic: async (p, t) => { await fsp.mkdir(path.dirname(p), { recursive: true }); await fsp.writeFile(p, t); } };
-  const projectName = path.basename(cwd);
-  const save = (over) => savePersona({ name: 'dev-lead', projectName, description: '', tools: [], color: '', tags: [], body: '', ...over, ...deps });
-  return { cwd, globalFile, overlayFile, deps, save, projectName };
-}
-
-test('setting a model writes a frontmatter-only overlay with only that key; global untouched', async () => {
-  const { overlayFile, globalFile, save } = setup();
-  const before = fs.readFileSync(globalFile, 'utf8');
-  await save({ model: 'claude-opus-4-6', effort: 'inherit' });
-  expect(fs.readFileSync(overlayFile, 'utf8')).toBe('---\nmodel: claude-opus-4-6\n---\n');
-  expect(fs.readFileSync(globalFile, 'utf8')).toBe(before);
-});
-
-test('adding effort adds only that key', async () => {
-  const { overlayFile, save } = setup();
-  await save({ model: 'claude-opus-4-6' });
-  await save({ model: 'claude-opus-4-6', effort: 'high' });
-  expect(fs.readFileSync(overlayFile, 'utf8')).toBe('---\nmodel: claude-opus-4-6\neffort: high\n---\n');
-});
-
-test('clearing both removes the overlay file', async () => {
-  const { overlayFile, save } = setup();
-  await save({ model: 'claude-opus-4-6', effort: 'high' });
-  const r = await save({ model: 'inherit', effort: 'inherit' });
-  expect(r.removed).toBe(true);
-  expect(fs.existsSync(overlayFile)).toBe(false);
-});
-
-test('a full-body overlay is refused, not rewritten', async () => {
-  const { overlayFile, save } = setup();
-  fs.mkdirSync(path.dirname(overlayFile), { recursive: true });
-  const full = '---\nname: dev-lead\nmodel: haiku\n---\nProject body.\n';
-  fs.writeFileSync(overlayFile, full);
-  await expect(save({ model: 'opus' })).rejects.toThrow(/full-body/);
-  expect(fs.readFileSync(overlayFile, 'utf8')).toBe(full);
-});
-
-test('unknown project is rejected', async () => {
-  const { save } = setup();
-  await expect(save({ projectName: 'nope', model: 'opus' })).rejects.toThrow(/project not open/);
-});
-
-test('listPersonas counts a frontmatter-only overlay and reports global → project values', async () => {
-  const { save, deps, projectName } = setup();
-  await save({ model: 'claude-opus-4-6' });
-  const [p] = await listPersonas(deps);
-  expect(p.model).toBe('sonnet');
-  expect(p.overridingProjects).toEqual([projectName]);
-  expect(p.overrideDetails[0]).toMatchObject({ fields: ['model'], values: { model: 'claude-opus-4-6' }, bodyOverridden: false });
-});
-
-test('scheduled-PRD model resolution returns the overlay model; global persona stays sonnet', async () => {
-  const { cwd, save, deps } = setup();
-  await save({ model: 'claude-opus-4-6' });
-  const r = await resolvePrdPersonaForSpawn({
-    cwd, agentType: 'dev-lead', fallbackModel: 'fallback',
-    deps: { getPersonaBody: (a) => getPersonaBody({ ...a, ...deps }) },
-  });
-  expect(r.model).toBe('claude-opus-4-6');
-  expect(r.systemPrompt).toContain('Global body.');
-  const [g] = await listPersonas(deps);
-  expect(g.model).toBe('sonnet');
-});

package/src/main/__tests__/bilkoHost-deriveSlug.test.cjs

@@ -1,26 +0,0 @@
-// bilkoHost.cjs's deriveSlug — pure kebab-case transform used as the
-// default static-path slug when Stage A prepares a project's bundle.
-const assert = require('node:assert/strict');
-const { deriveSlug } = require('../bilkoHost.cjs');
-
-test('deriveSlug: kebab-cases a plain npm package name', () => {
-  assert.equal(deriveSlug('claude-code-session-manager'), 'claude-code-session-manager');
-});
-
-test('deriveSlug: lowercases and collapses non-alphanumeric runs', () => {
-  assert.equal(deriveSlug('My Cool App!! v2'), 'my-cool-app-v2');
-});
-
-test('deriveSlug: trims leading/trailing separators', () => {
-  assert.equal(deriveSlug('--Hello--'), 'hello');
-});
-
-test('deriveSlug: falls back to "project" for an empty/unusable name', () => {
-  assert.equal(deriveSlug('   '), 'project');
-  assert.equal(deriveSlug('!!!'), 'project');
-});
-
-test('deriveSlug: caps length at 64 characters', () => {
-  const long = 'a'.repeat(100);
-  assert.equal(deriveSlug(long).length, 64);
-});

package/src/main/__tests__/bilkoHost-integration.test.cjs

@@ -1,118 +0,0 @@
-// bilkoHost.cjs — integration test against a real temp project dir: adding
-// and removing documents, and that Prepare Bundle wholesale-rebuilds dist/
-// so a removed document can never linger on disk (the local half of the
-// "delete propagates on next Publish" guarantee — see bilkoHost-integration.md).
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const os = require('node:os');
-const config = require('../config.cjs');
-const bilkoHost = require('../bilkoHost.cjs');
-
-function makeProject() {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'bilko-host-'));
-  config.addAllowedRoot(root);
-  fs.mkdirSync(path.join(root, 'session-manager-operations', 'project-pages'), { recursive: true });
-  fs.writeFileSync(
-    path.join(root, 'session-manager-operations', 'project-pages', 'home.html'),
-    '<html><title>Demo</title>Home</html>',
-  );
-  fs.writeFileSync(path.join(root, 'feature.html'), '<html><title>Demo</title>Feature</html>');
-  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'demo-app', version: '1.2.3' }));
-  return root;
-}
-
-test('prepareBundle seeds a root document and writes dist/index.html + manifest.json', async () => {
-  const root = makeProject();
-  const result = await bilkoHost.prepareBundle({ cwd: root, slug: 'demo-app' });
-  assert.equal(fs.existsSync(path.join(result.distPath, 'index.html')), true);
-  assert.equal(fs.readFileSync(path.join(result.distPath, 'index.html'), 'utf8'), '<html><title>Demo</title>Home</html>');
-  assert.equal(result.manifest.slug, 'demo-app');
-  assert.equal(result.manifest.bundle.fileCount, 1);
-  fs.rmSync(root, { recursive: true, force: true });
-});
-
-test('addDocument then prepareBundle writes a sub-path document at the expected location', async () => {
-  const root = makeProject();
-  await bilkoHost.prepareBundle({ cwd: root, slug: 'demo-app' });
-  await bilkoHost.addDocument({
-    cwd: root,
-    subpath: 'special-doc/01',
-    title: 'Feature deep-dive',
-    source: { kind: 'file', path: 'feature.html' },
-  });
-  const result = await bilkoHost.prepareBundle({ cwd: root, slug: 'demo-app' });
-  assert.equal(
-    fs.readFileSync(path.join(result.distPath, 'special-doc', '01', 'index.html'), 'utf8'),
-    '<html><title>Demo</title>Feature</html>',
-  );
-  assert.equal(result.manifest.bundle.fileCount, 2);
-  fs.rmSync(root, { recursive: true, force: true });
-});
-
-test('a non-home project-page-lens document throws the retired-lens error (no output/ fallback)', async () => {
-  const root = makeProject();
-  await bilkoHost.prepareBundle({ cwd: root, slug: 'demo-app' });
-  await bilkoHost.addDocument({
-    cwd: root,
-    subpath: 'special-doc/01',
-    title: 'Feature deep-dive',
-    source: { kind: 'project-page-lens', lens: 'feature' },
-  });
-  await assert.rejects(
-    () => bilkoHost.prepareBundle({ cwd: root, slug: 'demo-app' }),
-    /retired "feature" Project Page lens; only the single home\.html page is generated now/,
-  );
-  fs.rmSync(root, { recursive: true, force: true });
-});
-
-test('removeDocument + prepareBundle wholesale-rebuilds dist/, leaving no trace of the removed file', async () => {
-  const root = makeProject();
-  await bilkoHost.prepareBundle({ cwd: root, slug: 'demo-app' });
-  const added = await bilkoHost.addDocument({
-    cwd: root,
-    subpath: 'special-doc/01',
-    title: 'Feature deep-dive',
-    source: { kind: 'file', path: 'feature.html' },
-  });
-  await bilkoHost.prepareBundle({ cwd: root, slug: 'demo-app' });
-  const docId = added.documents.find((d) => d.subpath === 'special-doc/01').id;
-
-  await bilkoHost.removeDocument({ cwd: root, id: docId });
-  // Not yet rebuilt — the stale file is still on disk (get() should flag this via bundleStale).
-  const distBefore = await bilkoHost.get({ cwd: root });
-  assert.equal(distBefore.bundleStale, true);
-
-  const result = await bilkoHost.prepareBundle({ cwd: root, slug: 'demo-app' });
-  assert.equal(fs.existsSync(path.join(result.distPath, 'special-doc')), false);
-  assert.equal(result.manifest.bundle.fileCount, 1);
-
-  const after = await bilkoHost.get({ cwd: root });
-  assert.equal(after.bundleStale, false);
-  fs.rmSync(root, { recursive: true, force: true });
-});
-
-test('removeDocument refuses to remove the root document', async () => {
-  const root = makeProject();
-  await bilkoHost.prepareBundle({ cwd: root, slug: 'demo-app' });
-  const before = await bilkoHost.get({ cwd: root });
-  const rootId = before.documents.find((d) => d.subpath === '').id;
-  await assert.rejects(() => bilkoHost.removeDocument({ cwd: root, id: rootId }), /cannot remove the root document/);
-  fs.rmSync(root, { recursive: true, force: true });
-});
-
-test('addDocument refuses a duplicate sub-path', async () => {
-  const root = makeProject();
-  await bilkoHost.prepareBundle({ cwd: root, slug: 'demo-app' });
-  await bilkoHost.addDocument({
-    cwd: root,
-    subpath: 'doc',
-    title: 'A',
-    source: { kind: 'file', path: 'feature.html' },
-  });
-  await assert.rejects(
-    () => bilkoHost.addDocument({ cwd: root, subpath: 'doc', title: 'B', source: { kind: 'file', path: 'feature.html' } }),
-    /already uses subpath/,
-  );
-  fs.rmSync(root, { recursive: true, force: true });
-});

package/src/main/__tests__/bilkoHostCore.test.cjs

@@ -1,72 +0,0 @@
-// bilkoHostCore.cjs — pure multi-document bundle logic for the "Host on
-// Bilko.run" tab (subpath validation, document-set invariants, path/URL math).
-const assert = require('node:assert/strict');
-const {
-  validateSubpath,
-  validateDocumentSet,
-  documentDistRelPath,
-  documentUrl,
-} = require('../bilkoHostCore.cjs');
-
-test('validateSubpath: "" (root) is always valid', () => {
-  assert.equal(validateSubpath('').ok, true);
-});
-
-test('validateSubpath: accepts lowercase kebab-case, single or multi-segment', () => {
-  assert.equal(validateSubpath('special-doc').ok, true);
-  assert.equal(validateSubpath('special-doc/01').ok, true);
-  assert.equal(validateSubpath('a/b/c').ok, true);
-});
-
-test('validateSubpath: rejects leading/trailing slash', () => {
-  assert.equal(validateSubpath('/foo').ok, false);
-  assert.equal(validateSubpath('foo/').ok, false);
-});
-
-test('validateSubpath: rejects uppercase, spaces, dot-segments', () => {
-  assert.equal(validateSubpath('Foo').ok, false);
-  assert.equal(validateSubpath('foo bar').ok, false);
-  assert.equal(validateSubpath('..').ok, false);
-  assert.equal(validateSubpath('foo/../bar').ok, false);
-});
-
-test('validateSubpath: rejects excessive depth or length', () => {
-  assert.equal(validateSubpath(Array(10).fill('a').join('/')).ok, false);
-  assert.equal(validateSubpath('a'.repeat(300)).ok, false);
-});
-
-test('validateDocumentSet: requires exactly one root document', () => {
-  assert.equal(validateDocumentSet([]).ok, false);
-  assert.equal(validateDocumentSet([{ id: '1', subpath: 'x' }]).ok, false);
-  assert.equal(validateDocumentSet([{ id: '1', subpath: '' }]).ok, true);
-  assert.equal(
-    validateDocumentSet([{ id: '1', subpath: '' }, { id: '2', subpath: '' }]).ok,
-    false,
-  );
-});
-
-test('validateDocumentSet: rejects duplicate subpaths', () => {
-  const res = validateDocumentSet([
-    { id: '1', subpath: '' },
-    { id: '2', subpath: 'doc' },
-    { id: '3', subpath: 'doc' },
-  ]);
-  assert.equal(res.ok, false);
-  assert.match(res.error, /duplicate subpath/);
-});
-
-test('validateDocumentSet: propagates a bad segment error with the document id', () => {
-  const res = validateDocumentSet([{ id: '1', subpath: '' }, { id: 'bad-doc', subpath: 'Not Ok' }]);
-  assert.equal(res.ok, false);
-  assert.match(res.error, /bad-doc/);
-});
-
-test('documentDistRelPath: root -> index.html, sub-path -> <subpath>/index.html', () => {
-  assert.equal(documentDistRelPath(''), 'index.html');
-  assert.equal(documentDistRelPath('special-doc/01'), 'special-doc/01/index.html');
-});
-
-test('documentUrl: root has no sub-path segment, sub-path is nested under the slug', () => {
-  assert.equal(documentUrl('my-app', ''), 'https://bilko.run/projects/my-app/');
-  assert.equal(documentUrl('my-app', 'special-doc/01'), 'https://bilko.run/projects/my-app/special-doc/01/');
-});