@lumenflow/cli 2.3.2 → 2.5.0

package/dist/wu-unblock.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+/* eslint-disable no-console -- CLI tool requires console output */
 /**
  * WU Unblock Helper
  *
@@ -16,12 +17,15 @@
 import { existsSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { assertTransition } from '@lumenflow/core/dist/state-machine.js';
-import { checkLaneFree } from '@lumenflow/core/dist/lane-checker.js';
+import { checkLaneFree, getLockPolicyForLane } from '@lumenflow/core/dist/lane-checker.js';
+// WU-1325: Import lane lock functions for policy-based lock acquisition on unblock
+import { acquireLaneLock } from '@lumenflow/core/dist/lane-lock.js';
 import { getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
 import { die } from '@lumenflow/core/dist/error-handler.js';
 import { todayISO } from '@lumenflow/core/dist/date-utils.js';
 import { createWUParser, WU_OPTIONS } from '@lumenflow/core/dist/arg-parser.js';
 import { WU_PATHS, defaultWorktreeFrom } from '@lumenflow/core/dist/wu-paths.js';
+import { getConfig } from '@lumenflow/core/dist/lumenflow-config.js';
 import { readWU, writeWU, appendNote } from '@lumenflow/core/dist/wu-yaml.js';
 import { STATUS_SECTIONS, PATTERNS, LOG_PREFIX, WU_STATUS, REMOTES, BRANCHES, GIT_REFS, FILE_SYSTEM, EXIT_CODES, MICRO_WORKTREE_OPERATIONS, } from '@lumenflow/core/dist/wu-constants.js';
 import { defaultBranchFrom } from '@lumenflow/core/dist/wu-done-validators.js';
@@ -88,7 +92,8 @@ function handleLaneOccupancy(laneCheck, lane, id, force) {
         `  1. Wait for ${laneCheck.occupiedBy} to complete or block\n` +
         `  2. Move ${id} to a different lane\n` +
         `  3. Use --force to override (P0 emergencies only)\n\n` +
-        `To check lane status: grep "${STATUS_SECTIONS.IN_PROGRESS}" docs/04-operations/tasks/status.md`);
+        // WU-1311: Use config-based status path
+        `To check lane status: grep "${STATUS_SECTIONS.IN_PROGRESS}" ${getConfig().directories.statusPath}`);
 }
 /**
  * Handle optional worktree creation after unblock
@@ -221,6 +226,33 @@ async function main() {
         getGitForCwd().run(`git push ${REMOTES.ORIGIN} ${BRANCHES.MAIN}`);
     }
     handleWorktreeCreation(args, doc);
+    // WU-1325: Re-acquire lane lock when WU is unblocked (only for lock_policy=active)
+    // For policy=all, lock was retained through the block cycle
+    // For policy=none, no lock exists to acquire
+    try {
+        if (lane && lane !== 'Unknown') {
+            const lockPolicy = getLockPolicyForLane(lane);
+            if (lockPolicy === 'active') {
+                const lockResult = acquireLaneLock(lane, id);
+                if (lockResult.acquired && !lockResult.skipped) {
+                    console.log(`${PREFIX} Lane lock re-acquired for "${lane}" (lock_policy=active)`);
+                }
+                else if (!lockResult.acquired) {
+                    // Lock acquisition failed - another WU claimed the lane while we were blocked
+                    console.warn(`${PREFIX} Warning: Could not re-acquire lane lock: ${lockResult.error}`);
+                    console.warn(`${PREFIX} Another WU may have claimed lane "${lane}" while this WU was blocked.`);
+                }
+            }
+            else if (lockPolicy === 'all') {
+                console.log(`${PREFIX} Lane lock retained for "${lane}" (lock_policy=all)`);
+            }
+            // For policy=none, no lock exists - nothing to do
+        }
+    }
+    catch (err) {
+        // Non-blocking: lock acquisition failure should not block the unblocking operation
+        console.warn(`${PREFIX} Warning: Could not acquire lane lock: ${err.message}`);
+    }
     console.log(`\n${PREFIX} Marked in progress and pushed.`);
     console.log(`- WU: ${id} — ${title}`);
     if (args.reason)

package/dist/wu-validate.js

@@ -3,13 +3,15 @@
  * WU Validation Tool
  *
  * Validates WU YAML files against schema and checks for quality warnings.
- * Returns exit code 0 if valid (warnings are advisory, not blocking).
- * Returns exit code 1 only for schema errors.
+ *
+ * WU-1329: Strict mode is now the DEFAULT behavior.
+ * - Warnings are treated as errors by default
+ * - Use --no-strict to restore legacy advisory-only warnings behavior
  *
  * Usage:
- *   pnpm wu:validate --id WU-123         # Validate specific WU
- *   pnpm wu:validate --all               # Validate all WUs
- *   pnpm wu:validate --all --strict      # Fail on warnings too
+ *   pnpm wu:validate --id WU-123         # Validate with strict mode (default)
+ *   pnpm wu:validate --all               # Validate all WUs with strict mode
+ *   pnpm wu:validate --all --no-strict   # Warnings are advisory (legacy behavior)
  *
  * @see {@link packages/@lumenflow/cli/src/lib/wu-schema.ts} - Schema definitions
  */
@@ -27,12 +29,14 @@ const LOG_PREFIX = '[wu:validate]';
 /**
  * Validate a single WU file
  *
+ * WU-1329: strict defaults to true (warnings treated as errors)
+ *
  * @param {string} wuPath - Path to WU YAML file
  * @param {object} options - Validation options
- * @param {boolean} options.strict - Treat warnings as errors
+ * @param {boolean} options.strict - Treat warnings as errors (default: true)
  * @returns {{valid: boolean, warnings: string[], errors: string[]}}
  */
-function validateSingleWU(wuPath, { strict = false } = {}) {
+function validateSingleWU(wuPath, { strict = true } = {}) {
     const errors = [];
     const warnings = [];
     // Read and parse YAML
@@ -74,11 +78,13 @@ function validateSingleWU(wuPath, { strict = false } = {}) {
 /**
  * Validate all WU files
  *
+ * WU-1329: strict defaults to true (warnings treated as errors)
+ *
  * @param {object} options - Validation options
- * @param {boolean} options.strict - Treat warnings as errors
+ * @param {boolean} options.strict - Treat warnings as errors (default: true)
  * @returns {{totalValid: number, totalInvalid: number, totalWarnings: number, results: object[]}}
  */
-function validateAllWUs({ strict = false } = {}) {
+function validateAllWUs({ strict = true } = {}) {
     const wuDir = WU_PATHS.WU_DIR();
     if (!existsSync(wuDir)) {
         die(`WU directory not found: ${wuDir}`);
@@ -110,7 +116,7 @@ function validateAllWUs({ strict = false } = {}) {
 async function main() {
     const args = createWUParser({
         name: 'wu-validate',
-        description: 'Validate WU YAML files against schema',
+        description: 'Validate WU YAML files against schema (strict mode by default, WU-1329)',
         options: [
             WU_OPTIONS.id,
             {
@@ -119,17 +125,19 @@ async function main() {
                 type: 'boolean',
                 description: 'Validate all WUs',
             },
-            {
-                name: 'strict',
-                flags: '-s, --strict',
-                type: 'boolean',
-                description: 'Treat warnings as errors',
-            },
+            // WU-1329: Change from --strict to --no-strict (strict is now default)
+            WU_OPTIONS.noStrict,
         ],
         required: [],
         allowPositionalId: true,
     });
-    const { id, all, strict } = args;
+    const { id, all, noStrict } = args;
+    // WU-1329: Strict mode is the default, --no-strict opts out
+    const strict = !noStrict;
+    // WU-1329: Log when strict validation is bypassed
+    if (noStrict) {
+        console.warn(`${LOG_PREFIX} WARNING: strict validation bypassed (--no-strict). Warnings will be advisory only.`);
+    }
     if (!id && !all) {
         die('Must specify --id WU-XXX or --all');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumenflow/cli",
-  "version": "2.3.2",
+  "version": "2.5.0",
   "description": "Command-line interface for LumenFlow workflow framework",
   "keywords": [
     "lumenflow",
@@ -61,6 +61,7 @@
     "mem-export": "./dist/mem-export.js",
     "mem-signal": "./dist/mem-signal.js",
     "mem-cleanup": "./dist/mem-cleanup.js",
+    "mem-context": "./dist/mem-context.js",
     "signal-cleanup": "./dist/signal-cleanup.js",
     "mem-create": "./dist/mem-create.js",
     "mem-inbox": "./dist/mem-inbox.js",
@@ -72,7 +73,12 @@
     "initiative-list": "./dist/initiative-list.js",
     "initiative-status": "./dist/initiative-status.js",
     "initiative-add-wu": "./dist/initiative-add-wu.js",
+    "initiative-plan": "./dist/initiative-plan.js",
     "init-plan": "./dist/init-plan.js",
+    "plan-create": "./dist/plan-create.js",
+    "plan-link": "./dist/plan-link.js",
+    "plan-edit": "./dist/plan-edit.js",
+    "plan-promote": "./dist/plan-promote.js",
     "agent-session": "./dist/agent-session.js",
     "agent-session-end": "./dist/agent-session-end.js",
     "agent-log-issue": "./dist/agent-log-issue.js",
@@ -142,11 +148,11 @@
     "pretty-ms": "^9.2.0",
     "simple-git": "^3.30.0",
     "yaml": "^2.8.2",
-    "@lumenflow/core": "2.3.2",
-    "@lumenflow/memory": "2.3.2",
-    "@lumenflow/initiatives": "2.3.2",
-    "@lumenflow/agent": "2.3.2",
-    "@lumenflow/metrics": "2.3.2"
+    "@lumenflow/core": "2.5.0",
+    "@lumenflow/initiatives": "2.5.0",
+    "@lumenflow/memory": "2.5.0",
+    "@lumenflow/agent": "2.5.0",
+    "@lumenflow/metrics": "2.5.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.17",

package/templates/core/AGENTS.md.template

@@ -17,11 +17,11 @@ cd worktrees/<lane>-wu-xxxx
 pnpm gates
 
 # 3. Complete (ALWAYS run this!)
-cd {{PROJECT_ROOT}}
+cd <project-root>
 pnpm wu:done --id WU-XXXX
 ```
 
-> **Complete CLI reference:** See [quick-ref-commands.md](ai/onboarding/quick-ref-commands.md)
+> **Complete CLI reference:** See [quick-ref-commands.md]({{QUICK_REF_LINK}})
 
 ---
 

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

@@ -1,340 +0,0 @@
-/**
- * Tests for init:plan command (WU-1105)
- *
- * The init: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('../init-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('../init-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('../init-plan.js');
-            expect(() => validateInitIdFormat('INIT-TOOLING')).not.toThrow();
-            expect(() => validateInitIdFormat('INIT-A1')).not.toThrow();
-        });
-        it('should reject invalid formats', async () => {
-            const { validateInitIdFormat } = await import('../init-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('../init-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('../init-plan.js');
-            const planPath = join(tempDir, 'nonexistent.md');
-            expect(() => validatePlanPath(planPath)).toThrow();
-        });
-        it('should reject non-markdown files', async () => {
-            const { validatePlanPath } = await import('../init-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('../init-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('../init-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('../init-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('../init-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('../init-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('../init-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('../init-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('../init-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('../init-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('../init-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('../init-plan.js');
-            expect(LOG_PREFIX).toBe('[init:plan]');
-        });
-    });
-    describe('getCommitMessage', () => {
-        it('should generate correct commit message', async () => {
-            const { getCommitMessage } = await import('../init-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('../init-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('../init-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('../init-plan.js');
-        expect(typeof initPlan.main).toBe('function');
-    });
-    it('should export all required functions', async () => {
-        const initPlan = await import('../init-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('../init-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('../init-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('../init-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/agent-issues-query.d.ts

@@ -1,16 +0,0 @@
-#!/usr/bin/env node
-/**
- * Agent Issues Query CLI (WU-1018)
- *
- * Query and display logged agent incidents/issues.
- *
- * Usage:
- *   pnpm agent:issues-query summary                 # Summary of last 7 days
- *   pnpm agent:issues-query summary --since 30     # Summary of last 30 days
- *   pnpm agent:issues-query summary --category tooling
- *   pnpm agent:issues-query summary --severity blocker
- *
- * @module agent-issues-query
- * @see {@link @lumenflow/agent}
- */
-export {};

package/dist/agent-log-issue.d.ts

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-/**
- * Agent Log Issue CLI
- *
- * Logs a workflow issue or incident during agent execution.
- *
- * Usage:
- *   pnpm agent:log-issue --category workflow --severity minor --title "..." --description "..."
- */
-export {};

package/dist/agent-session-end.d.ts

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-/**
- * Agent Session End CLI
- *
- * Ends the current agent session and returns summary.
- *
- * Usage:
- *   pnpm agent:session:end
- */
-export {};

package/dist/agent-session.d.ts

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-/**
- * Agent Session Start CLI
- *
- * Starts an agent session for tracking WU execution.
- *
- * Usage:
- *   pnpm agent:session --wu WU-1234 --tier 2
- */
-export {};