@lumenflow/cli 2.4.0 → 2.5.1

package/dist/__tests__/initiative-add-wu.test.js

@@ -0,0 +1,420 @@
+/**
+ * Tests for initiative:add-wu command validation (WU-1330)
+ *
+ * The initiative:add-wu command now validates WU specs before linking.
+ * This ensures only valid, complete WUs can be linked to initiatives.
+ *
+ * TDD: These tests are written BEFORE the implementation.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach, beforeAll } from 'vitest';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { stringifyYAML } from '@lumenflow/core/dist/wu-yaml.js';
+// Test constants to avoid lint warnings about duplicate strings
+const TEST_WU_ID = 'WU-123';
+const TEST_INIT_ID = 'INIT-001';
+const TEST_LANE = 'Framework: CLI';
+const WU_REL_PATH = 'docs/04-operations/tasks/wu';
+const INIT_REL_PATH = 'docs/04-operations/tasks/initiatives';
+const TEST_INIT_SLUG = 'test-initiative';
+const TEST_INIT_TITLE = 'Test Initiative';
+const TEST_INIT_STATUS = 'open';
+const TEST_DATE = '2026-01-25';
+const MIN_DESCRIPTION_LENGTH = 50;
+// Valid WU document template
+const createValidWUDoc = (overrides = {}) => ({
+    id: TEST_WU_ID,
+    title: 'Test Work Unit Title',
+    lane: TEST_LANE,
+    status: 'ready',
+    type: 'feature',
+    priority: 'P2',
+    created: TEST_DATE,
+    description: 'Context: Testing WU validation. Problem: No validation on add-wu. Solution: Add strict validation before linking.',
+    acceptance: ['WU validates schema', 'Invalid WUs rejected', 'Valid WUs linked bidirectionally'],
+    code_paths: ['packages/@lumenflow/cli/src/initiative-add-wu.ts'],
+    tests: { unit: ['packages/@lumenflow/cli/src/__tests__/initiative-add-wu.test.ts'] },
+    exposure: 'backend-only',
+    ...overrides,
+});
+// Valid initiative document template
+const createValidInitDoc = (overrides = {}) => ({
+    id: TEST_INIT_ID,
+    slug: TEST_INIT_SLUG,
+    title: TEST_INIT_TITLE,
+    status: TEST_INIT_STATUS,
+    created: TEST_DATE,
+    wus: [],
+    ...overrides,
+});
+// Pre-import the module to ensure coverage tracking includes the module itself
+beforeAll(async () => {
+    await import('../initiative-add-wu.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', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        withMicroWorktree: vi.fn(async ({ execute }) => {
+            // Simulate micro-worktree by executing in temp dir
+            const tempDir = join(tmpdir(), `init-add-wu-test-${Date.now()}`);
+            mkdirSync(tempDir, { recursive: true });
+            try {
+                await execute({ worktreePath: tempDir });
+            }
+            finally {
+                // Cleanup handled by test
+            }
+        }),
+    };
+});
+describe('initiative:add-wu WU validation (WU-1330)', () => {
+    let tempDir;
+    let originalCwd;
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `init-add-wu-validation-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('validateWUForLinking', () => {
+        it('should return valid for a well-formed WU', async () => {
+            const { validateWUForLinking } = await import('../initiative-add-wu.js');
+            // Create a valid WU file
+            const wuDir = join(tempDir, WU_REL_PATH);
+            mkdirSync(wuDir, { recursive: true });
+            const wuPath = join(wuDir, `${TEST_WU_ID}.yaml`);
+            writeFileSync(wuPath, stringifyYAML(createValidWUDoc()));
+            process.chdir(tempDir);
+            const result = validateWUForLinking(TEST_WU_ID);
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should reject WU with missing required fields', async () => {
+            const { validateWUForLinking } = await import('../initiative-add-wu.js');
+            // Create a WU missing required fields (no description)
+            const wuDir = join(tempDir, WU_REL_PATH);
+            mkdirSync(wuDir, { recursive: true });
+            const wuPath = join(wuDir, `${TEST_WU_ID}.yaml`);
+            writeFileSync(wuPath, stringifyYAML({
+                id: TEST_WU_ID,
+                title: 'Test',
+                lane: TEST_LANE,
+                status: 'ready',
+                created: TEST_DATE,
+                // Missing: description, acceptance, code_paths
+            }));
+            process.chdir(tempDir);
+            const result = validateWUForLinking(TEST_WU_ID);
+            expect(result.valid).toBe(false);
+            expect(result.errors.length).toBeGreaterThan(0);
+            expect(result.errors.some((e) => e.toLowerCase().includes('description'))).toBe(true);
+        });
+        it('should reject WU with invalid schema', async () => {
+            const { validateWUForLinking } = await import('../initiative-add-wu.js');
+            // Create a WU with invalid status
+            const wuDir = join(tempDir, WU_REL_PATH);
+            mkdirSync(wuDir, { recursive: true });
+            const wuPath = join(wuDir, `${TEST_WU_ID}.yaml`);
+            writeFileSync(wuPath, stringifyYAML({
+                ...createValidWUDoc(),
+                status: 'invalid_status', // Invalid status value
+            }));
+            process.chdir(tempDir);
+            const result = validateWUForLinking(TEST_WU_ID);
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.toLowerCase().includes('status'))).toBe(true);
+        });
+        it('should reject WU with description containing placeholder marker', async () => {
+            const { validateWUForLinking } = await import('../initiative-add-wu.js');
+            // Create a WU with placeholder in description
+            const wuDir = join(tempDir, WU_REL_PATH);
+            mkdirSync(wuDir, { recursive: true });
+            const wuPath = join(wuDir, `${TEST_WU_ID}.yaml`);
+            writeFileSync(wuPath, stringifyYAML({
+                ...createValidWUDoc(),
+                description: '[PLACEHOLDER] This is a placeholder description that is long enough.',
+            }));
+            process.chdir(tempDir);
+            const result = validateWUForLinking(TEST_WU_ID);
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes('PLACEHOLDER'))).toBe(true);
+        });
+        it('should reject WU with too short description', async () => {
+            const { validateWUForLinking } = await import('../initiative-add-wu.js');
+            // Create a WU with short description
+            const wuDir = join(tempDir, WU_REL_PATH);
+            mkdirSync(wuDir, { recursive: true });
+            const wuPath = join(wuDir, `${TEST_WU_ID}.yaml`);
+            writeFileSync(wuPath, stringifyYAML({
+                ...createValidWUDoc(),
+                description: 'Too short', // Less than MIN_DESCRIPTION_LENGTH
+            }));
+            process.chdir(tempDir);
+            const result = validateWUForLinking(TEST_WU_ID);
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes(`${MIN_DESCRIPTION_LENGTH}`))).toBe(true);
+        });
+        it('should reject WU with invalid ID format', async () => {
+            const { validateWUForLinking } = await import('../initiative-add-wu.js');
+            // Create a WU with invalid ID
+            const invalidId = 'INVALID-123';
+            const wuDir = join(tempDir, WU_REL_PATH);
+            mkdirSync(wuDir, { recursive: true });
+            const wuPath = join(wuDir, `${invalidId}.yaml`);
+            writeFileSync(wuPath, stringifyYAML({
+                ...createValidWUDoc(),
+                id: invalidId,
+            }));
+            process.chdir(tempDir);
+            const result = validateWUForLinking(invalidId);
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.toLowerCase().includes('id'))).toBe(true);
+        });
+        it('should reject WU that does not exist', async () => {
+            const { validateWUForLinking } = await import('../initiative-add-wu.js');
+            process.chdir(tempDir);
+            const result = validateWUForLinking('WU-999');
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.toLowerCase().includes('not found'))).toBe(true);
+        });
+        it('should reject WU with empty acceptance criteria', async () => {
+            const { validateWUForLinking } = await import('../initiative-add-wu.js');
+            // Create a WU with empty acceptance
+            const wuDir = join(tempDir, WU_REL_PATH);
+            mkdirSync(wuDir, { recursive: true });
+            const wuPath = join(wuDir, `${TEST_WU_ID}.yaml`);
+            writeFileSync(wuPath, stringifyYAML({
+                ...createValidWUDoc(),
+                acceptance: [], // Empty array
+            }));
+            process.chdir(tempDir);
+            const result = validateWUForLinking(TEST_WU_ID);
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.toLowerCase().includes('acceptance'))).toBe(true);
+        });
+        it('should aggregate multiple errors', async () => {
+            const { validateWUForLinking } = await import('../initiative-add-wu.js');
+            // Create a WU with multiple issues
+            const wuDir = join(tempDir, WU_REL_PATH);
+            mkdirSync(wuDir, { recursive: true });
+            const wuPath = join(wuDir, `${TEST_WU_ID}.yaml`);
+            writeFileSync(wuPath, stringifyYAML({
+                id: TEST_WU_ID,
+                title: '', // Empty title
+                lane: TEST_LANE,
+                status: 'invalid_status', // Invalid status
+                created: TEST_DATE,
+                description: 'short', // Too short
+                acceptance: [], // Empty
+            }));
+            process.chdir(tempDir);
+            const result = validateWUForLinking(TEST_WU_ID);
+            expect(result.valid).toBe(false);
+            // Should have multiple errors aggregated
+            expect(result.errors.length).toBeGreaterThanOrEqual(2);
+        });
+        it('should include warnings but still be valid', async () => {
+            const { validateWUForLinking } = await import('../initiative-add-wu.js');
+            // Create a valid WU that might have warnings (missing optional recommended fields)
+            const wuDir = join(tempDir, WU_REL_PATH);
+            mkdirSync(wuDir, { recursive: true });
+            const wuPath = join(wuDir, `${TEST_WU_ID}.yaml`);
+            writeFileSync(wuPath, stringifyYAML({
+                ...createValidWUDoc(),
+                notes: '', // Empty notes - should produce warning
+                spec_refs: [], // Empty spec_refs for feature - should produce warning
+            }));
+            process.chdir(tempDir);
+            const result = validateWUForLinking(TEST_WU_ID);
+            // Should be valid (warnings don't block)
+            expect(result.valid).toBe(true);
+            // But should have warnings
+            expect(result.warnings.length).toBeGreaterThan(0);
+        });
+    });
+    describe('checkWUExists with validation', () => {
+        it('should throw for invalid WU when strict validation enabled', async () => {
+            const { checkWUExistsAndValidate } = await import('../initiative-add-wu.js');
+            // Create an invalid WU file
+            const wuDir = join(tempDir, WU_REL_PATH);
+            mkdirSync(wuDir, { recursive: true });
+            const wuPath = join(wuDir, `${TEST_WU_ID}.yaml`);
+            writeFileSync(wuPath, stringifyYAML({
+                id: TEST_WU_ID,
+                title: 'Test',
+                lane: TEST_LANE,
+                status: 'ready',
+                created: TEST_DATE,
+                description: 'short', // Too short
+            }));
+            process.chdir(tempDir);
+            // Should throw with aggregated validation errors
+            expect(() => checkWUExistsAndValidate(TEST_WU_ID)).toThrow();
+        });
+        it('should return WU doc when validation passes', async () => {
+            const { checkWUExistsAndValidate } = await import('../initiative-add-wu.js');
+            // Create a valid WU file
+            const wuDir = join(tempDir, WU_REL_PATH);
+            mkdirSync(wuDir, { recursive: true });
+            const wuPath = join(wuDir, `${TEST_WU_ID}.yaml`);
+            writeFileSync(wuPath, stringifyYAML(createValidWUDoc()));
+            process.chdir(tempDir);
+            const result = checkWUExistsAndValidate(TEST_WU_ID);
+            expect(result.id).toBe(TEST_WU_ID);
+        });
+    });
+    describe('initiative:add-wu integration', () => {
+        it('should reject linking invalid WU with clear error message', async () => {
+            // This is an integration test scenario - main() calls validation before linking
+            // The main() function should call validateWUForLinking and die() with aggregated errors
+            const { validateWUForLinking } = await import('../initiative-add-wu.js');
+            // Setup invalid WU
+            const wuDir = join(tempDir, WU_REL_PATH);
+            mkdirSync(wuDir, { recursive: true });
+            const wuPath = join(wuDir, `${TEST_WU_ID}.yaml`);
+            writeFileSync(wuPath, stringifyYAML({
+                id: TEST_WU_ID,
+                title: 'Test',
+                lane: TEST_LANE,
+                status: 'ready',
+                created: TEST_DATE,
+                description: 'Too short',
+            }));
+            process.chdir(tempDir);
+            const result = validateWUForLinking(TEST_WU_ID);
+            // The error message should be suitable for display to user
+            expect(result.valid).toBe(false);
+            expect(result.errors.join('\n')).toContain('50'); // Should mention minimum length
+        });
+        it('should successfully link valid WU bidirectionally', async () => {
+            // This test verifies that after validation passes, bidirectional linking works
+            // The existing functionality should still work for valid WUs
+            const { validateWUForLinking } = await import('../initiative-add-wu.js');
+            // Setup valid WU and initiative
+            const wuDir = join(tempDir, WU_REL_PATH);
+            const initDir = join(tempDir, INIT_REL_PATH);
+            mkdirSync(wuDir, { recursive: true });
+            mkdirSync(initDir, { recursive: true });
+            const wuPath = join(wuDir, `${TEST_WU_ID}.yaml`);
+            const initPath = join(initDir, `${TEST_INIT_ID}.yaml`);
+            writeFileSync(wuPath, stringifyYAML(createValidWUDoc()));
+            writeFileSync(initPath, stringifyYAML(createValidInitDoc()));
+            process.chdir(tempDir);
+            // Validation should pass
+            const result = validateWUForLinking(TEST_WU_ID);
+            expect(result.valid).toBe(true);
+        });
+    });
+    describe('error formatting', () => {
+        it('should format errors in human-readable format', async () => {
+            const { formatValidationErrors } = await import('../initiative-add-wu.js');
+            const errors = ['description: Description is required', 'acceptance: At least one criterion'];
+            const wuId = TEST_WU_ID;
+            const formatted = formatValidationErrors(wuId, errors);
+            expect(formatted).toContain(wuId);
+            expect(formatted).toContain('description');
+            expect(formatted).toContain('acceptance');
+        });
+    });
+    describe('exports', () => {
+        it('should export validateWUForLinking function', async () => {
+            const mod = await import('../initiative-add-wu.js');
+            expect(typeof mod.validateWUForLinking).toBe('function');
+        });
+        it('should export checkWUExistsAndValidate function', async () => {
+            const mod = await import('../initiative-add-wu.js');
+            expect(typeof mod.checkWUExistsAndValidate).toBe('function');
+        });
+        it('should export formatValidationErrors function', async () => {
+            const mod = await import('../initiative-add-wu.js');
+            expect(typeof mod.formatValidationErrors).toBe('function');
+        });
+        it('should export isRetryExhaustionError function (WU-1333)', async () => {
+            const mod = await import('../initiative-add-wu.js');
+            expect(typeof mod.isRetryExhaustionError).toBe('function');
+        });
+        it('should export formatRetryExhaustionError function (WU-1333)', async () => {
+            const mod = await import('../initiative-add-wu.js');
+            expect(typeof mod.formatRetryExhaustionError).toBe('function');
+        });
+    });
+});
+/**
+ * WU-1333: Retry handling tests for initiative:add-wu
+ *
+ * When origin/main moves during operation, the micro-worktree layer handles retry.
+ * When retries are exhausted, the error message should include actionable next steps.
+ */
+describe('initiative:add-wu retry handling (WU-1333)', () => {
+    describe('isRetryExhaustionError', () => {
+        it('should detect retry exhaustion from error message', async () => {
+            const { isRetryExhaustionError } = await import('../initiative-add-wu.js');
+            // Should detect retry exhaustion error
+            const retryError = new Error('Push failed after 3 attempts. Origin main may have significant traffic.');
+            expect(isRetryExhaustionError(retryError)).toBe(true);
+        });
+        it('should detect retry exhaustion with any attempt count', async () => {
+            const { isRetryExhaustionError } = await import('../initiative-add-wu.js');
+            // Different attempt counts should still match
+            const error5 = new Error('Push failed after 5 attempts. Something.');
+            expect(isRetryExhaustionError(error5)).toBe(true);
+            const error1 = new Error('Push failed after 1 attempts. Something.');
+            expect(isRetryExhaustionError(error1)).toBe(true);
+        });
+        it('should not match other errors', async () => {
+            const { isRetryExhaustionError } = await import('../initiative-add-wu.js');
+            const otherError = new Error('Some other error');
+            expect(isRetryExhaustionError(otherError)).toBe(false);
+            const networkError = new Error('Network unreachable');
+            expect(isRetryExhaustionError(networkError)).toBe(false);
+        });
+    });
+    describe('formatRetryExhaustionError', () => {
+        it('should include actionable next steps', async () => {
+            const { formatRetryExhaustionError } = await import('../initiative-add-wu.js');
+            const retryError = new Error('Push failed after 3 attempts. Origin main may have significant traffic.');
+            const formatted = formatRetryExhaustionError(retryError, TEST_WU_ID, TEST_INIT_ID);
+            // Should include the original error
+            expect(formatted).toContain('Push failed after 3 attempts');
+            // Should include next steps heading
+            expect(formatted).toContain('Next steps:');
+            // Should include actionable suggestions
+            expect(formatted).toContain('Wait a few seconds and retry');
+            expect(formatted).toContain('initiative:add-wu');
+        });
+        it('should include the retry command', async () => {
+            const { formatRetryExhaustionError } = await import('../initiative-add-wu.js');
+            const retryError = new Error('Push failed after 3 attempts.');
+            const formatted = formatRetryExhaustionError(retryError, TEST_WU_ID, TEST_INIT_ID);
+            // Should include command to retry
+            expect(formatted).toContain(`--wu ${TEST_WU_ID}`);
+            expect(formatted).toContain(`--initiative ${TEST_INIT_ID}`);
+        });
+        it('should suggest checking for concurrent agents', async () => {
+            const { formatRetryExhaustionError } = await import('../initiative-add-wu.js');
+            const retryError = new Error('Push failed after 3 attempts.');
+            const formatted = formatRetryExhaustionError(retryError, TEST_WU_ID, TEST_INIT_ID);
+            // Should mention concurrent agents as possible cause
+            expect(formatted).toMatch(/concurrent|agent|traffic/i);
+        });
+    });
+});

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

@@ -0,0 +1,162 @@
+/**
+ * Tests for initiative:plan replacement by plan:link (WU-1313)
+ *
+ * Validates that the existing initiative:plan functionality is preserved
+ * when replaced by plan:link --target INIT-XXX.
+ *
+ * TDD: These tests are written BEFORE the implementation.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } 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';
+/** Test constants - avoid sonarjs/no-duplicate-string */
+const TEST_INIT_DIR = 'docs/04-operations/tasks/initiatives';
+const TEST_INIT_ID = 'INIT-001';
+const TEST_INIT_PLAN_URI = `lumenflow://plans/${TEST_INIT_ID}-plan.md`;
+const TEST_PLANS_DIR = 'docs/04-operations/plans';
+// eslint-disable-next-line sonarjs/publicly-writable-directories -- test constant for bad path detection
+const TEST_LUMENFLOW_HOME_BAD = '/tmp/lumenflow-home-should-not-be-used';
+const TEST_INIT_SLUG = 'test-initiative';
+const TEST_INIT_TITLE = 'Test Initiative';
+const TEST_STATUS_OPEN = 'open';
+const TEST_DATE = '2026-01-25';
+// Mock modules before importing
+vi.mock('@lumenflow/core/dist/git-adapter.js', () => ({
+    getGitForCwd: vi.fn(() => ({
+        branch: vi.fn().mockResolvedValue({ current: 'main' }),
+        status: vi.fn().mockResolvedValue({ isClean: () => true }),
+    })),
+}));
+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 }) => {
+        const tempDir = join(tmpdir(), `init-plan-replace-test-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        return execute({ worktreePath: tempDir });
+    }),
+}));
+describe('initiative:plan replaced by plan:link', () => {
+    let tempDir;
+    let originalCwd;
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `init-plan-replace-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('plan:link for initiatives (backwards compatibility)', () => {
+        it('should link plan to initiative via related_plan field', async () => {
+            const { linkPlanToInitiative } = await import('../plan-link.js');
+            // Setup mock initiative file
+            const initDir = join(tempDir, ...TEST_INIT_DIR.split('/'));
+            mkdirSync(initDir, { recursive: true });
+            const initPath = join(initDir, `${TEST_INIT_ID}.yaml`);
+            const initDoc = {
+                id: TEST_INIT_ID,
+                slug: TEST_INIT_SLUG,
+                title: TEST_INIT_TITLE,
+                status: TEST_STATUS_OPEN,
+                created: TEST_DATE,
+            };
+            writeFileSync(initPath, stringifyYAML(initDoc));
+            // Link plan (same operation as initiative:plan --initiative --plan)
+            const changed = linkPlanToInitiative(tempDir, TEST_INIT_ID, TEST_INIT_PLAN_URI);
+            expect(changed).toBe(true);
+            // Verify the file was updated
+            const updated = parseYAML(readFileSync(initPath, 'utf-8'));
+            expect(updated.related_plan).toBe(TEST_INIT_PLAN_URI);
+        });
+        it('should create plan and link in single operation', async () => {
+            const { createPlan } = await import('../plan-create.js');
+            const { linkPlanToInitiative } = await import('../plan-link.js');
+            // Setup mock initiative file
+            const initDir = join(tempDir, ...TEST_INIT_DIR.split('/'));
+            mkdirSync(initDir, { recursive: true });
+            const initPath = join(initDir, `${TEST_INIT_ID}.yaml`);
+            const initDoc = {
+                id: TEST_INIT_ID,
+                slug: TEST_INIT_SLUG,
+                title: TEST_INIT_TITLE,
+                status: TEST_STATUS_OPEN,
+                created: TEST_DATE,
+            };
+            writeFileSync(initPath, stringifyYAML(initDoc));
+            // Create plan (like initiative:plan --create)
+            const planPath = createPlan(tempDir, TEST_INIT_ID, TEST_INIT_TITLE);
+            expect(existsSync(planPath)).toBe(true);
+            // Link plan
+            const changed = linkPlanToInitiative(tempDir, TEST_INIT_ID, TEST_INIT_PLAN_URI);
+            expect(changed).toBe(true);
+            // Verify both plan file and initiative were updated
+            const updated = parseYAML(readFileSync(initPath, 'utf-8'));
+            expect(updated.related_plan).toBe(TEST_INIT_PLAN_URI);
+        });
+    });
+    describe('initiative:plan deprecation', () => {
+        it('should warn when using deprecated initiative:plan command', async () => {
+            // The initiative:plan command should still work but warn about deprecation
+            // and suggest using plan:link instead
+            const initPlan = await import('../initiative-plan.js');
+            expect(typeof initPlan.main).toBe('function');
+            // The deprecation warning will be in the main function
+        });
+    });
+    describe('plan:link auto-detection', () => {
+        it('should auto-detect INIT target and call linkPlanToInitiative', async () => {
+            const { resolveTargetType } = await import('../plan-link.js');
+            expect(resolveTargetType(TEST_INIT_ID)).toBe('initiative');
+            expect(resolveTargetType('INIT-TOOLING')).toBe('initiative');
+        });
+        it('should auto-detect WU target and call linkPlanToWU', async () => {
+            const { resolveTargetType } = await import('../plan-link.js');
+            expect(resolveTargetType('WU-1313')).toBe('wu');
+            expect(resolveTargetType('WU-001')).toBe('wu');
+        });
+    });
+});
+describe('plan storage defaults to repo plansDir', () => {
+    let tempDir;
+    let originalCwd;
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `plan-storage-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 in repo directories.plansDir, not LUMENFLOW_HOME', async () => {
+        const { createPlan } = await import('../plan-create.js');
+        // Set LUMENFLOW_HOME to a different location (should be ignored)
+        const oldLfHome = process.env.LUMENFLOW_HOME;
+        process.env.LUMENFLOW_HOME = TEST_LUMENFLOW_HOME_BAD;
+        try {
+            const planPath = createPlan(tempDir, 'WU-1313', 'Test Plan');
+            // Plan should be in repo plansDir, not LUMENFLOW_HOME
+            expect(planPath).toContain(TEST_PLANS_DIR);
+            expect(planPath).not.toContain(TEST_LUMENFLOW_HOME_BAD);
+        }
+        finally {
+            if (oldLfHome === undefined) {
+                delete process.env.LUMENFLOW_HOME;
+            }
+            else {
+                process.env.LUMENFLOW_HOME = oldLfHome;
+            }
+        }
+    });
+});