@lumenflow/cli 2.2.2 → 2.3.2

package/dist/__tests__/init.test.js

@@ -0,0 +1,298 @@
+/**
+ * @file init.test.ts
+ * Tests for lumenflow init command (WU-1171)
+ *
+ * Tests the new --merge mode, --client flag, AGENTS.md creation,
+ * and updated vendor overlay paths.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { scaffoldProject } from '../init.js';
+// Constants to avoid sonarjs/no-duplicate-string
+const LUMENFLOW_MD = 'LUMENFLOW.md';
+const VENDOR_RULES_FILE = 'lumenflow.md';
+describe('lumenflow init', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-init-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    describe('AGENTS.md creation', () => {
+        it('should create AGENTS.md by default', async () => {
+            const options = {
+                force: false,
+                full: false,
+            };
+            await scaffoldProject(tempDir, options);
+            const agentsPath = path.join(tempDir, 'AGENTS.md');
+            expect(fs.existsSync(agentsPath)).toBe(true);
+            const content = fs.readFileSync(agentsPath, 'utf-8');
+            expect(content).toContain(LUMENFLOW_MD);
+            expect(content).toContain('universal');
+        });
+        it('should link AGENTS.md to LUMENFLOW.md', async () => {
+            const options = {
+                force: false,
+                full: false,
+            };
+            await scaffoldProject(tempDir, options);
+            const agentsContent = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
+            expect(agentsContent).toContain(`[${LUMENFLOW_MD}]`);
+        });
+    });
+    describe('--client flag', () => {
+        it('should accept --client claude', async () => {
+            const options = {
+                force: false,
+                full: false,
+                client: 'claude',
+            };
+            const result = await scaffoldProject(tempDir, options);
+            expect(fs.existsSync(path.join(tempDir, 'CLAUDE.md'))).toBe(true);
+            expect(result.created).toContain('CLAUDE.md');
+        });
+        it('should accept --client cursor', async () => {
+            const options = {
+                force: false,
+                full: false,
+                client: 'cursor',
+            };
+            await scaffoldProject(tempDir, options);
+            // Cursor uses .cursor/rules/lumenflow.md (not .cursor/rules.md)
+            expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', VENDOR_RULES_FILE))).toBe(true);
+        });
+        it('should accept --client windsurf', async () => {
+            const options = {
+                force: false,
+                full: false,
+                client: 'windsurf',
+            };
+            await scaffoldProject(tempDir, options);
+            // Windsurf uses .windsurf/rules/lumenflow.md (not .windsurfrules)
+            expect(fs.existsSync(path.join(tempDir, '.windsurf', 'rules', VENDOR_RULES_FILE))).toBe(true);
+        });
+        it('should accept --client codex', async () => {
+            const options = {
+                force: false,
+                full: false,
+                client: 'codex',
+            };
+            await scaffoldProject(tempDir, options);
+            // Codex reads AGENTS.md directly, minimal extra config
+            expect(fs.existsSync(path.join(tempDir, 'AGENTS.md'))).toBe(true);
+        });
+        it('should accept --client all', async () => {
+            const options = {
+                force: false,
+                full: false,
+                client: 'all',
+            };
+            await scaffoldProject(tempDir, options);
+            // Should create all vendor files
+            expect(fs.existsSync(path.join(tempDir, 'AGENTS.md'))).toBe(true);
+            expect(fs.existsSync(path.join(tempDir, 'CLAUDE.md'))).toBe(true);
+            expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', VENDOR_RULES_FILE))).toBe(true);
+            expect(fs.existsSync(path.join(tempDir, '.windsurf', 'rules', VENDOR_RULES_FILE))).toBe(true);
+        });
+        it('should treat --vendor as alias for --client (backwards compatibility)', async () => {
+            const options = {
+                force: false,
+                full: false,
+                vendor: 'claude', // Using old --vendor flag
+            };
+            await scaffoldProject(tempDir, options);
+            expect(fs.existsSync(path.join(tempDir, 'CLAUDE.md'))).toBe(true);
+        });
+    });
+    describe('--merge mode', () => {
+        it('should insert LUMENFLOW block into existing file', async () => {
+            // Create existing AGENTS.md
+            const existingContent = '# My Project Agents\n\nCustom content here.\n';
+            fs.writeFileSync(path.join(tempDir, 'AGENTS.md'), existingContent);
+            const options = {
+                force: false,
+                full: false,
+                merge: true,
+            };
+            await scaffoldProject(tempDir, options);
+            const content = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
+            // Should preserve original content
+            expect(content).toContain('# My Project Agents');
+            expect(content).toContain('Custom content here.');
+            // Should add LumenFlow block
+            expect(content).toContain('<!-- LUMENFLOW:START -->');
+            expect(content).toContain('<!-- LUMENFLOW:END -->');
+            expect(content).toContain(LUMENFLOW_MD);
+        });
+        it('should be idempotent (running twice produces no diff)', async () => {
+            // Create existing file
+            fs.writeFileSync(path.join(tempDir, 'AGENTS.md'), '# My Project\n');
+            const options = {
+                force: false,
+                full: false,
+                merge: true,
+            };
+            // First run
+            await scaffoldProject(tempDir, options);
+            const firstContent = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
+            // Second run
+            await scaffoldProject(tempDir, options);
+            const secondContent = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
+            expect(firstContent).toBe(secondContent);
+        });
+        it('should preserve CRLF line endings', async () => {
+            // Create existing file with CRLF
+            const existingContent = '# My Project\r\n\r\nWindows style.\r\n';
+            fs.writeFileSync(path.join(tempDir, 'AGENTS.md'), existingContent);
+            const options = {
+                force: false,
+                full: false,
+                merge: true,
+            };
+            await scaffoldProject(tempDir, options);
+            const content = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
+            // Should preserve CRLF
+            expect(content).toContain('\r\n');
+            // Should not have mixed line endings (standalone LF without preceding CR)
+            const lfCount = (content.match(/(?<!\r)\n/g) || []).length;
+            expect(lfCount).toBe(0);
+        });
+        it('should warn on malformed markers and append fresh block', async () => {
+            // Create file with only START marker (malformed)
+            const malformedContent = '# My Project\n\n<!-- LUMENFLOW:START -->\nOrphan block\n';
+            fs.writeFileSync(path.join(tempDir, 'AGENTS.md'), malformedContent);
+            const options = {
+                force: false,
+                full: false,
+                merge: true,
+            };
+            const result = await scaffoldProject(tempDir, options);
+            // Should have warnings about malformed markers
+            expect(result.warnings).toBeDefined();
+            expect(result.warnings?.some((w) => w.includes('malformed'))).toBe(true);
+            const content = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
+            // Should have complete block
+            expect(content).toContain('<!-- LUMENFLOW:END -->');
+        });
+    });
+    describe('createFile mode option', () => {
+        it('should skip existing files in skip mode (default)', async () => {
+            const existingContent = 'Original content';
+            fs.writeFileSync(path.join(tempDir, 'AGENTS.md'), existingContent);
+            const options = {
+                force: false,
+                full: false,
+                // Default mode is 'skip'
+            };
+            const result = await scaffoldProject(tempDir, options);
+            expect(result.skipped).toContain('AGENTS.md');
+            const content = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
+            expect(content).toBe(existingContent);
+        });
+        it('should overwrite in force mode', async () => {
+            fs.writeFileSync(path.join(tempDir, 'AGENTS.md'), 'Original');
+            const options = {
+                force: true,
+                full: false,
+            };
+            const result = await scaffoldProject(tempDir, options);
+            expect(result.created).toContain('AGENTS.md');
+            const content = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
+            expect(content).not.toBe('Original');
+        });
+        it('should merge in merge mode', async () => {
+            fs.writeFileSync(path.join(tempDir, 'AGENTS.md'), '# Custom Header\n');
+            const options = {
+                force: false,
+                full: false,
+                merge: true,
+            };
+            const result = await scaffoldProject(tempDir, options);
+            expect(result.merged).toContain('AGENTS.md');
+            const content = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
+            expect(content).toContain('# Custom Header');
+            expect(content).toContain('<!-- LUMENFLOW:START -->');
+        });
+    });
+    describe('vendor overlay paths', () => {
+        it('should use .cursor/rules/lumenflow.md for Cursor', async () => {
+            const options = {
+                force: false,
+                full: false,
+                client: 'cursor',
+            };
+            await scaffoldProject(tempDir, options);
+            // Should NOT create old path
+            expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules.md'))).toBe(false);
+            // Should create new path
+            expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', VENDOR_RULES_FILE))).toBe(true);
+        });
+        it('should use .windsurf/rules/lumenflow.md for Windsurf', async () => {
+            const options = {
+                force: false,
+                full: false,
+                client: 'windsurf',
+            };
+            await scaffoldProject(tempDir, options);
+            // Should NOT create old path
+            expect(fs.existsSync(path.join(tempDir, '.windsurfrules'))).toBe(false);
+            // Should create new path
+            expect(fs.existsSync(path.join(tempDir, '.windsurf', 'rules', VENDOR_RULES_FILE))).toBe(true);
+        });
+    });
+    describe('CLAUDE.md location', () => {
+        it('should create single CLAUDE.md at root only', async () => {
+            const options = {
+                force: false,
+                full: false,
+                client: 'claude',
+            };
+            await scaffoldProject(tempDir, options);
+            // Should create root CLAUDE.md
+            expect(fs.existsSync(path.join(tempDir, 'CLAUDE.md'))).toBe(true);
+            // Should NOT create .claude/CLAUDE.md (no duplication)
+            expect(fs.existsSync(path.join(tempDir, '.claude', 'CLAUDE.md'))).toBe(false);
+        });
+    });
+    // WU-1286: --full is now the default
+    describe('--full default and --minimal flag', () => {
+        it('should scaffold agent onboarding docs by default (full=true)', async () => {
+            const options = {
+                force: false,
+                full: true, // This is now the default when parsed
+            };
+            await scaffoldProject(tempDir, options);
+            // Should create agent onboarding docs
+            const onboardingDir = path.join(tempDir, 'docs/04-operations/_frameworks/lumenflow/agent/onboarding');
+            expect(fs.existsSync(path.join(onboardingDir, 'quick-ref-commands.md'))).toBe(true);
+            expect(fs.existsSync(path.join(onboardingDir, 'first-wu-mistakes.md'))).toBe(true);
+            expect(fs.existsSync(path.join(onboardingDir, 'troubleshooting-wu-done.md'))).toBe(true);
+        });
+        it('should skip agent onboarding docs when full=false (minimal mode)', async () => {
+            const options = {
+                force: false,
+                full: false, // Explicitly minimal
+            };
+            await scaffoldProject(tempDir, options);
+            // Should NOT create agent onboarding docs
+            const onboardingDir = path.join(tempDir, 'docs/04-operations/_frameworks/lumenflow/agent/onboarding');
+            expect(fs.existsSync(path.join(onboardingDir, 'quick-ref-commands.md'))).toBe(false);
+        });
+        it('should still create core files in minimal mode', async () => {
+            const options = {
+                force: false,
+                full: false,
+            };
+            await scaffoldProject(tempDir, options);
+            // Core files should always be created
+            expect(fs.existsSync(path.join(tempDir, 'AGENTS.md'))).toBe(true);
+            expect(fs.existsSync(path.join(tempDir, 'LUMENFLOW.md'))).toBe(true);
+            expect(fs.existsSync(path.join(tempDir, '.lumenflow.config.yaml'))).toBe(true);
+            expect(fs.existsSync(path.join(tempDir, '.lumenflow', 'constraints.md'))).toBe(true);
+        });
+    });
+});

package/dist/__tests__/initiative-plan.test.js

@@ -0,0 +1,340 @@
+/**
+ * Tests for initiative:plan command (WU-1105, renamed in WU-1193)
+ *
+ * The initiative:plan command links plan files to initiatives by setting
+ * the `related_plan` field in the initiative YAML.
+ *
+ * TDD: These tests are written BEFORE the implementation.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach, beforeAll } from 'vitest';
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { parseYAML, stringifyYAML } from '@lumenflow/core/dist/wu-yaml.js';
+// Pre-import the module to ensure coverage tracking includes the module itself
+let initPlanModule;
+beforeAll(async () => {
+    initPlanModule = await import('../initiative-plan.js');
+});
+// Mock modules before importing the module under test
+const mockGit = {
+    branch: vi.fn().mockResolvedValue({ current: 'main' }),
+    status: vi.fn().mockResolvedValue({ isClean: () => true }),
+};
+vi.mock('@lumenflow/core/dist/git-adapter.js', () => ({
+    getGitForCwd: vi.fn(() => mockGit),
+}));
+vi.mock('@lumenflow/core/dist/wu-helpers.js', () => ({
+    ensureOnMain: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('@lumenflow/core/dist/micro-worktree.js', () => ({
+    withMicroWorktree: vi.fn(async ({ execute }) => {
+        // Simulate micro-worktree by executing in temp dir
+        const tempDir = join(tmpdir(), `init-plan-test-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        try {
+            await execute({ worktreePath: tempDir });
+        }
+        finally {
+            // Cleanup handled by test
+        }
+    }),
+}));
+describe('init:plan command', () => {
+    let tempDir;
+    let originalCwd;
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `init-plan-test-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        originalCwd = process.cwd();
+    });
+    afterEach(() => {
+        process.chdir(originalCwd);
+        if (existsSync(tempDir)) {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+        vi.clearAllMocks();
+    });
+    describe('validateInitIdFormat', () => {
+        it('should accept valid INIT-NNN format', async () => {
+            const { validateInitIdFormat } = await import('../initiative-plan.js');
+            // Should not throw
+            expect(() => validateInitIdFormat('INIT-001')).not.toThrow();
+            expect(() => validateInitIdFormat('INIT-123')).not.toThrow();
+        });
+        it('should accept valid INIT-NAME format', async () => {
+            const { validateInitIdFormat } = await import('../initiative-plan.js');
+            expect(() => validateInitIdFormat('INIT-TOOLING')).not.toThrow();
+            expect(() => validateInitIdFormat('INIT-A1')).not.toThrow();
+        });
+        it('should reject invalid formats', async () => {
+            const { validateInitIdFormat } = await import('../initiative-plan.js');
+            expect(() => validateInitIdFormat('init-001')).toThrow();
+            expect(() => validateInitIdFormat('INIT001')).toThrow();
+            expect(() => validateInitIdFormat('WU-001')).toThrow();
+            expect(() => validateInitIdFormat('')).toThrow();
+        });
+    });
+    describe('validatePlanPath', () => {
+        it('should accept existing markdown files', async () => {
+            const { validatePlanPath } = await import('../initiative-plan.js');
+            const planPath = join(tempDir, 'test-plan.md');
+            writeFileSync(planPath, '# Test Plan');
+            // Should not throw
+            expect(() => validatePlanPath(planPath)).not.toThrow();
+        });
+        it('should reject non-existent files when not creating', async () => {
+            const { validatePlanPath } = await import('../initiative-plan.js');
+            const planPath = join(tempDir, 'nonexistent.md');
+            expect(() => validatePlanPath(planPath)).toThrow();
+        });
+        it('should reject non-markdown files', async () => {
+            const { validatePlanPath } = await import('../initiative-plan.js');
+            const planPath = join(tempDir, 'test-plan.txt');
+            writeFileSync(planPath, 'Test Plan');
+            expect(() => validatePlanPath(planPath)).toThrow();
+        });
+    });
+    describe('formatPlanUri', () => {
+        it('should format plan path as lumenflow:// URI', async () => {
+            const { formatPlanUri } = await import('../initiative-plan.js');
+            expect(formatPlanUri('docs/04-operations/plans/my-plan.md')).toBe('lumenflow://plans/my-plan.md');
+        });
+        it('should handle nested paths', async () => {
+            const { formatPlanUri } = await import('../initiative-plan.js');
+            expect(formatPlanUri('docs/04-operations/plans/subdir/nested-plan.md')).toBe('lumenflow://plans/subdir/nested-plan.md');
+        });
+        it('should handle paths not in standard location', async () => {
+            const { formatPlanUri } = await import('../initiative-plan.js');
+            // Should still create a URI even for non-standard paths
+            expect(formatPlanUri('/absolute/path/custom-plan.md')).toBe('lumenflow://plans/custom-plan.md');
+        });
+    });
+    describe('checkInitiativeExists', () => {
+        it('should return initiative doc if found', async () => {
+            const { checkInitiativeExists } = await import('../initiative-plan.js');
+            // Create a mock initiative file
+            const initDir = join(tempDir, 'docs', '04-operations', 'tasks', 'initiatives');
+            mkdirSync(initDir, { recursive: true });
+            const initPath = join(initDir, 'INIT-001.yaml');
+            const initDoc = {
+                id: 'INIT-001',
+                slug: 'test-initiative',
+                title: 'Test Initiative',
+                status: 'open',
+                created: '2026-01-25',
+            };
+            writeFileSync(initPath, stringifyYAML(initDoc));
+            process.chdir(tempDir);
+            const result = checkInitiativeExists('INIT-001');
+            expect(result.id).toBe('INIT-001');
+        });
+        it('should throw if initiative not found', async () => {
+            const { checkInitiativeExists } = await import('../initiative-plan.js');
+            process.chdir(tempDir);
+            expect(() => checkInitiativeExists('INIT-999')).toThrow();
+        });
+    });
+    describe('updateInitiativeWithPlan', () => {
+        it('should add related_plan field to initiative', async () => {
+            const { updateInitiativeWithPlan } = await import('../initiative-plan.js');
+            // Setup mock initiative
+            const initDir = join(tempDir, 'docs', '04-operations', 'tasks', 'initiatives');
+            mkdirSync(initDir, { recursive: true });
+            const initPath = join(initDir, 'INIT-001.yaml');
+            const initDoc = {
+                id: 'INIT-001',
+                slug: 'test-initiative',
+                title: 'Test Initiative',
+                status: 'open',
+                created: '2026-01-25',
+            };
+            writeFileSync(initPath, stringifyYAML(initDoc));
+            // Update initiative
+            const changed = updateInitiativeWithPlan(tempDir, 'INIT-001', 'lumenflow://plans/test-plan.md');
+            expect(changed).toBe(true);
+            // Verify the file was updated
+            const updated = parseYAML(readFileSync(initPath, 'utf-8'));
+            expect(updated.related_plan).toBe('lumenflow://plans/test-plan.md');
+        });
+        it('should return false if plan already linked (idempotent)', async () => {
+            const { updateInitiativeWithPlan } = await import('../initiative-plan.js');
+            // Setup mock initiative with existing plan
+            const initDir = join(tempDir, 'docs', '04-operations', 'tasks', 'initiatives');
+            mkdirSync(initDir, { recursive: true });
+            const initPath = join(initDir, 'INIT-001.yaml');
+            const initDoc = {
+                id: 'INIT-001',
+                slug: 'test-initiative',
+                title: 'Test Initiative',
+                status: 'open',
+                created: '2026-01-25',
+                related_plan: 'lumenflow://plans/test-plan.md',
+            };
+            writeFileSync(initPath, stringifyYAML(initDoc));
+            // Update initiative with same plan
+            const changed = updateInitiativeWithPlan(tempDir, 'INIT-001', 'lumenflow://plans/test-plan.md');
+            expect(changed).toBe(false);
+        });
+        it('should warn but proceed if different plan already linked', async () => {
+            const { updateInitiativeWithPlan } = await import('../initiative-plan.js');
+            const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            // Setup mock initiative with different plan
+            const initDir = join(tempDir, 'docs', '04-operations', 'tasks', 'initiatives');
+            mkdirSync(initDir, { recursive: true });
+            const initPath = join(initDir, 'INIT-001.yaml');
+            const initDoc = {
+                id: 'INIT-001',
+                slug: 'test-initiative',
+                title: 'Test Initiative',
+                status: 'open',
+                created: '2026-01-25',
+                related_plan: 'lumenflow://plans/old-plan.md',
+            };
+            writeFileSync(initPath, stringifyYAML(initDoc));
+            // Update initiative with new plan
+            const changed = updateInitiativeWithPlan(tempDir, 'INIT-001', 'lumenflow://plans/new-plan.md');
+            expect(changed).toBe(true);
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Replacing existing related_plan'));
+            consoleSpy.mockRestore();
+        });
+    });
+    describe('createPlanTemplate', () => {
+        it('should create a plan template file', async () => {
+            const { createPlanTemplate } = await import('../initiative-plan.js');
+            const plansDir = join(tempDir, 'docs', '04-operations', 'plans');
+            mkdirSync(plansDir, { recursive: true });
+            const planPath = createPlanTemplate(tempDir, 'INIT-001', 'Test Initiative');
+            expect(existsSync(planPath)).toBe(true);
+            const content = readFileSync(planPath, 'utf-8');
+            expect(content).toContain('# INIT-001');
+            expect(content).toContain('Test Initiative');
+            expect(content).toContain('## Goal');
+            expect(content).toContain('## Scope');
+        });
+        it('should not overwrite existing plan file', async () => {
+            const { createPlanTemplate } = await import('../initiative-plan.js');
+            const plansDir = join(tempDir, 'docs', '04-operations', 'plans');
+            mkdirSync(plansDir, { recursive: true });
+            // Create existing file
+            const existingPath = join(plansDir, 'INIT-001-test-initiative.md');
+            writeFileSync(existingPath, '# Existing Content');
+            expect(() => createPlanTemplate(tempDir, 'INIT-001', 'Test Initiative')).toThrow();
+        });
+    });
+    describe('LOG_PREFIX', () => {
+        it('should use correct log prefix', async () => {
+            const { LOG_PREFIX } = await import('../initiative-plan.js');
+            expect(LOG_PREFIX).toBe('[initiative:plan]');
+        });
+    });
+    describe('getCommitMessage', () => {
+        it('should generate correct commit message', async () => {
+            const { getCommitMessage } = await import('../initiative-plan.js');
+            expect(getCommitMessage('INIT-001', 'lumenflow://plans/my-plan.md')).toBe('docs: link plan my-plan.md to init-001');
+        });
+        it('should handle nested plan paths', async () => {
+            const { getCommitMessage } = await import('../initiative-plan.js');
+            expect(getCommitMessage('INIT-TOOLING', 'lumenflow://plans/subdir/nested-plan.md')).toBe('docs: link plan subdir/nested-plan.md to init-tooling');
+        });
+    });
+    describe('updateInitiativeWithPlan ID mismatch', () => {
+        it('should throw if initiative ID does not match', async () => {
+            const { updateInitiativeWithPlan } = await import('../initiative-plan.js');
+            // Setup mock initiative with different ID
+            const initDir = join(tempDir, 'docs', '04-operations', 'tasks', 'initiatives');
+            mkdirSync(initDir, { recursive: true });
+            const initPath = join(initDir, 'INIT-001.yaml');
+            const initDoc = {
+                id: 'INIT-002', // Wrong ID
+                slug: 'test-initiative',
+                title: 'Test Initiative',
+                status: 'open',
+                created: '2026-01-25',
+            };
+            writeFileSync(initPath, stringifyYAML(initDoc));
+            expect(() => updateInitiativeWithPlan(tempDir, 'INIT-001', 'lumenflow://plans/test-plan.md')).toThrow();
+        });
+    });
+});
+describe('init:plan CLI integration', () => {
+    it('should require --initiative flag', async () => {
+        // This test verifies that the CLI requires the initiative flag
+        // The actual CLI integration is tested via subprocess
+        const { WU_OPTIONS } = await import('@lumenflow/core/dist/arg-parser.js');
+        expect(WU_OPTIONS.initiative).toBeDefined();
+        expect(WU_OPTIONS.initiative.flags).toContain('--initiative');
+    });
+    it('should export main function for CLI entry', async () => {
+        const initPlan = await import('../initiative-plan.js');
+        expect(typeof initPlan.main).toBe('function');
+    });
+    it('should export all required functions', async () => {
+        const initPlan = await import('../initiative-plan.js');
+        expect(typeof initPlan.validateInitIdFormat).toBe('function');
+        expect(typeof initPlan.validatePlanPath).toBe('function');
+        expect(typeof initPlan.formatPlanUri).toBe('function');
+        expect(typeof initPlan.checkInitiativeExists).toBe('function');
+        expect(typeof initPlan.updateInitiativeWithPlan).toBe('function');
+        expect(typeof initPlan.createPlanTemplate).toBe('function');
+        expect(typeof initPlan.getCommitMessage).toBe('function');
+        expect(typeof initPlan.LOG_PREFIX).toBe('string');
+    });
+});
+describe('createPlanTemplate edge cases', () => {
+    let tempDir;
+    let originalCwd;
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `init-plan-test-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        originalCwd = process.cwd();
+    });
+    afterEach(() => {
+        process.chdir(originalCwd);
+        if (existsSync(tempDir)) {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+        vi.clearAllMocks();
+    });
+    it('should create plans directory if it does not exist', async () => {
+        const { createPlanTemplate } = await import('../initiative-plan.js');
+        // Do NOT pre-create the plans directory
+        const planPath = createPlanTemplate(tempDir, 'INIT-001', 'Test Initiative');
+        expect(existsSync(planPath)).toBe(true);
+        expect(planPath).toContain('docs/04-operations/plans');
+    });
+    it('should truncate long titles in filename', async () => {
+        const { createPlanTemplate } = await import('../initiative-plan.js');
+        const longTitle = 'This is an extremely long initiative title that should be truncated in the filename';
+        const planPath = createPlanTemplate(tempDir, 'INIT-001', longTitle);
+        expect(existsSync(planPath)).toBe(true);
+        // Filename should be truncated
+        const filename = planPath.split('/').pop() || '';
+        // INIT-001- is 9 chars, .md is 3 chars, slug should be max 30 chars
+        expect(filename.length).toBeLessThanOrEqual(9 + 30 + 3);
+    });
+    it('should handle special characters in title', async () => {
+        const { createPlanTemplate } = await import('../initiative-plan.js');
+        const specialTitle = "Test's Initiative: (Special) Chars! @#$%";
+        const planPath = createPlanTemplate(tempDir, 'INIT-001', specialTitle);
+        expect(existsSync(planPath)).toBe(true);
+        // Filename should only have kebab-case characters
+        expect(planPath).toMatch(/INIT-001-[a-z0-9-]+\.md$/);
+    });
+});
+/**
+ * Note on main() function testing:
+ *
+ * The main() function is intentionally not unit-tested because:
+ * 1. It calls die() which invokes process.exit() - difficult to mock without complex test infrastructure
+ * 2. It involves micro-worktree operations with git
+ * 3. All business logic functions it calls ARE thoroughly tested above
+ *
+ * The main() function is integration/orchestration code that composes the tested helper functions.
+ * Integration testing via subprocess (pnpm init:plan) is the appropriate testing strategy for main().
+ *
+ * Coverage statistics:
+ * - All exported helper functions: ~100% coverage
+ * - main() function: Not unit tested (orchestration code)
+ * - Overall file coverage: ~50% (acceptable for CLI commands)
+ */

package/dist/__tests__/mem-cleanup-execution.test.js

@@ -0,0 +1,19 @@
+import { exec } from 'node:child_process';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { describe, it, expect } from 'vitest';
+const execAsync = promisify(exec);
+const CLI_DIST_PATH = path.resolve(__dirname, '../../dist/mem-cleanup.js');
+describe('mem:cleanup CLI execution', () => {
+    it('should run --help without crashing', async () => {
+        try {
+            // We run the actual built JS file to catch ESM/CJS compatibility issues
+            const { stdout } = await execAsync(`node ${CLI_DIST_PATH} --help`);
+            expect(stdout).toContain('Usage: mem-cleanup');
+        }
+        catch (error) {
+            // If it fails, we want to see why (expecting ReferenceError: require is not defined)
+            throw new Error(`Command failed: ${error.message}\nStderr: ${error.stderr}`);
+        }
+    });
+});