@lumenflow/cli 1.3.0 → 1.3.2

package/dist/__tests__/cli-entry-point.test.js

@@ -0,0 +1,50 @@
+/**
+ * Tests for CLI entry point error handling
+ *
+ * Verifies that runCLI wrapper properly:
+ * - Catches async errors from main()
+ * - Logs error messages to stderr
+ * - Exits with EXIT_CODES.ERROR on failure
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { runCLI } from '../cli-entry-point.js';
+import { EXIT_CODES } from '@lumenflow/core/dist/wu-constants.js';
+describe('runCLI', () => {
+    let mockExit;
+    let mockConsoleError;
+    beforeEach(() => {
+        mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+        mockConsoleError = vi.spyOn(console, 'error').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        mockExit.mockRestore();
+        mockConsoleError.mockRestore();
+    });
+    it('should call main() and do nothing on success', async () => {
+        const main = vi.fn().mockResolvedValue(undefined);
+        await runCLI(main);
+        expect(main).toHaveBeenCalledOnce();
+        expect(mockExit).not.toHaveBeenCalled();
+        expect(mockConsoleError).not.toHaveBeenCalled();
+    });
+    it('should catch errors and exit with ERROR code', async () => {
+        const error = new Error('Test error message');
+        const main = vi.fn().mockRejectedValue(error);
+        await runCLI(main);
+        expect(main).toHaveBeenCalledOnce();
+        expect(mockConsoleError).toHaveBeenCalledWith('Test error message');
+        expect(mockExit).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+    });
+    it('should handle errors without message property', async () => {
+        const main = vi.fn().mockRejectedValue('string error');
+        await runCLI(main);
+        expect(mockConsoleError).toHaveBeenCalledWith('string error');
+        expect(mockExit).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+    });
+    it('should handle null/undefined errors', async () => {
+        const main = vi.fn().mockRejectedValue(null);
+        await runCLI(main);
+        expect(mockConsoleError).toHaveBeenCalledWith('Unknown error');
+        expect(mockExit).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+    });
+});

package/dist/__tests__/cli-subprocess.test.js

@@ -0,0 +1,64 @@
+/**
+ * Integration tests for CLI subprocess execution
+ *
+ * Tests that CLI commands properly:
+ * - Exit with non-zero code on errors
+ * - Output error messages to stderr
+ * - Don't silently fail
+ *
+ * These tests run CLI commands as subprocesses to verify
+ * the entry point error handling works end-to-end.
+ */
+import { describe, it, expect } from 'vitest';
+import { spawnSync } from 'node:child_process';
+import { resolve } from 'node:path';
+const CLI_DIR = resolve(__dirname, '../../dist');
+/**
+ * Helper to run a CLI command as subprocess
+ */
+function runCLI(command, args = []) {
+    const result = spawnSync('node', [resolve(CLI_DIR, `${command}.js`), ...args], {
+        encoding: 'utf-8',
+        timeout: 10000,
+    });
+    return {
+        code: result.status ?? -1,
+        stdout: result.stdout ?? '',
+        stderr: result.stderr ?? '',
+    };
+}
+describe('CLI subprocess error handling', () => {
+    describe('wu-claim', () => {
+        it('should exit with non-zero code when required options are missing', () => {
+            const result = runCLI('wu-claim', ['--id', 'WU-TEST']);
+            // Should NOT exit 0 (silent failure)
+            expect(result.code).not.toBe(0);
+            // Should have some error output
+            expect(result.stderr.length + result.stdout.length).toBeGreaterThan(0);
+        });
+        it('should output help when --help is passed', () => {
+            const result = runCLI('wu-claim', ['--help']);
+            // Help should work
+            expect(result.code).toBe(0);
+            expect(result.stdout).toContain('Usage');
+        });
+    });
+    describe('wu-done', () => {
+        it('should exit with non-zero code for non-existent WU', () => {
+            const result = runCLI('wu-done', ['--id', 'WU-NONEXISTENT-99999']);
+            // Should NOT exit 0 (silent failure)
+            expect(result.code).not.toBe(0);
+            // Should have some error output
+            expect(result.stderr.length + result.stdout.length).toBeGreaterThan(0);
+        });
+    });
+    describe('wu-create', () => {
+        it('should exit with non-zero code when validation fails', () => {
+            const result = runCLI('wu-create', ['--id', 'WU-TEST', '--lane', 'Invalid Lane']);
+            // Should NOT exit 0 (silent failure)
+            expect(result.code).not.toBe(0);
+            // Should have some error output
+            expect(result.stderr.length + result.stdout.length).toBeGreaterThan(0);
+        });
+    });
+});

package/dist/cli-entry-point.js

@@ -0,0 +1,46 @@
+/**
+ * Shared CLI entry point wrapper
+ *
+ * Provides consistent error handling for all CLI commands.
+ * Catches async errors, logs them, and exits with proper code.
+ *
+ * @example
+ * ```typescript
+ * // At the bottom of each CLI file:
+ * import { runCLI } from './cli-entry-point.js';
+ * import { fileURLToPath } from 'node:url';
+ *
+ * if (process.argv[1] === fileURLToPath(import.meta.url)) {
+ *   runCLI(main);
+ * }
+ * ```
+ */
+import { EXIT_CODES } from '@lumenflow/core/dist/wu-constants.js';
+/**
+ * Wraps an async main function with proper error handling.
+ *
+ * @param main - The async main function to execute
+ * @returns Promise that resolves when main completes (or after error handling)
+ */
+export async function runCLI(main) {
+    try {
+        await main();
+    }
+    catch (err) {
+        const message = getErrorMessage(err);
+        console.error(message);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+/**
+ * Extracts error message from unknown error type.
+ */
+function getErrorMessage(err) {
+    if (err === null || err === undefined) {
+        return 'Unknown error';
+    }
+    if (err instanceof Error) {
+        return err.message;
+    }
+    return String(err);
+}

package/dist/initiative-add-wu.js

@@ -229,6 +229,7 @@ async function main() {
 }
 // Guard main() for testability
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/dist/initiative-create.js

@@ -163,6 +163,7 @@ async function main() {
 }
 // Guard main() for testability
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/dist/initiative-list.js

@@ -96,6 +96,7 @@ async function main() {
 }
 // Guard main() for testability (WU-1366)
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/dist/initiative-status.js

@@ -216,6 +216,7 @@ async function main() {
 }
 // Guard main() for testability (WU-1366)
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/dist/wu-claim.js

@@ -1298,6 +1298,7 @@ async function main() {
 }
 // Guard main() for testability (WU-1366)
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/dist/wu-cleanup.js

@@ -5,7 +5,7 @@
  * Cleans up worktree and branch after PR merge (PR-based completion workflow).
  *
  * Sequence:
- * 1) Verify PR is merged (via gh API or git merge-base fallback)
+ * 1) Verify PR is merged (via gh API; no merge-base fallback)
  * 2) Remove worktree (if exists)
  * 3) Delete lane branch (local + remote)
  *
@@ -16,7 +16,7 @@
  *   pnpm wu:cleanup --artifacts
  */
 import { execSync } from 'node:child_process';
-import { getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
+import { createGitForPath, getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { createWUParser, WU_OPTIONS } from '@lumenflow/core/dist/arg-parser.js';
@@ -25,16 +25,11 @@ import { cleanupWorktreeBuildArtifacts } from '@lumenflow/core/dist/rebase-artif
 import { detectCurrentWorktree } from '@lumenflow/core/dist/wu-done-validators.js';
 import { WU_PATHS } from '@lumenflow/core/dist/wu-paths.js';
 import { readWU } from '@lumenflow/core/dist/wu-yaml.js';
-import { BRANCHES, EXIT_CODES, FILE_SYSTEM, LOG_PREFIX, REMOTES, GIT_REFS, } from '@lumenflow/core/dist/wu-constants.js';
+import { isGhCliAvailable } from '@lumenflow/core/dist/wu-done-pr.js';
+import { BOX, CLEANUP_GUARD, EXIT_CODES, FILE_SYSTEM, LOG_PREFIX, REMOTES, STRING_LITERALS, WU_STATUS, } from '@lumenflow/core/dist/wu-constants.js';
 // WU-2278: Import ownership validation for cross-agent protection
 import { validateWorktreeOwnership } from '@lumenflow/core/dist/worktree-ownership.js';
 /* eslint-disable security/detect-non-literal-fs-filename */
-// Box drawing characters for consistent output
-const BOX = {
-    TOP: '╔═══════════════════════════════════════════════════════════════════╗',
-    MID: '╠═══════════════════════════════════════════════════════════════════╣',
-    BOT: '╚═══════════════════════════════════════════════════════════════════╝',
-};
 const CLEANUP_OPTIONS = {
     artifacts: {
         name: 'artifacts',
@@ -42,15 +37,36 @@ const CLEANUP_OPTIONS = {
         description: 'Remove build artifacts (dist, tsbuildinfo) in current worktree',
     },
 };
+export const CLEANUP_GUARD_REASONS = CLEANUP_GUARD.REASONS;
+export function evaluateCleanupGuards({ hasUncommittedChanges, hasUnpushedCommits, hasStamp, yamlStatus, ghAvailable, prMerged, }) {
+    if (hasUncommittedChanges) {
+        return { allowed: false, reason: CLEANUP_GUARD_REASONS.UNCOMMITTED_CHANGES };
+    }
+    if (hasUnpushedCommits) {
+        return { allowed: false, reason: CLEANUP_GUARD_REASONS.UNPUSHED_COMMITS };
+    }
+    if (yamlStatus !== WU_STATUS.DONE) {
+        return { allowed: false, reason: CLEANUP_GUARD_REASONS.STATUS_NOT_DONE };
+    }
+    if (!hasStamp) {
+        return { allowed: false, reason: CLEANUP_GUARD_REASONS.MISSING_STAMP };
+    }
+    if (ghAvailable && prMerged !== true) {
+        return { allowed: false, reason: CLEANUP_GUARD_REASONS.PR_NOT_MERGED };
+    }
+    return { allowed: true, reason: null };
+}
 // Help text is now auto-generated by commander via createWUParser
 async function verifyPRMerged(laneBranch) {
-    // Try gh API first (most reliable)
+    if (!isGhCliAvailable()) {
+        return { merged: null, method: 'gh_unavailable' };
+    }
     let ghResult;
     try {
         ghResult = execSync(`gh api repos/:owner/:repo/pulls -q '.[] | select(.head.ref == "${laneBranch}") | .merged'`, { encoding: FILE_SYSTEM.UTF8 }).trim();
     }
     catch {
-        ghResult = '';
+        ghResult = STRING_LITERALS.EMPTY;
     }
     if (ghResult === 'true') {
         return { merged: true, method: 'gh_api' };
@@ -58,37 +74,7 @@ async function verifyPRMerged(laneBranch) {
     if (ghResult === 'false') {
         return { merged: false, method: 'gh_api' };
     }
-    // Fallback: git merge-base --is-ancestor
-    // Always fetch origin/main first for accurate merge-base check
-    await getGitForCwd().fetch(REMOTES.ORIGIN, BRANCHES.MAIN);
-    const localBranchExists = await getGitForCwd().branchExists(laneBranch);
-    if (!localBranchExists) {
-        // Branch doesn't exist locally - check if it exists remotely
-        const remoteBranchExists = await getGitForCwd().raw([
-            'ls-remote',
-            '--heads',
-            REMOTES.ORIGIN,
-            laneBranch,
-        ]);
-        if (!remoteBranchExists) {
-            // Branch is gone both locally and remotely - assume merged
-            return { merged: true, method: 'branch_deleted' };
-        }
-        // Branch exists remotely but not locally - need to fetch
-        await getGitForCwd().fetch(REMOTES.ORIGIN, laneBranch);
-    }
-    let isAncestor;
-    try {
-        await getGitForCwd().raw(['merge-base', '--is-ancestor', laneBranch, GIT_REFS.ORIGIN_MAIN]);
-        isAncestor = true;
-    }
-    catch {
-        isAncestor = false;
-    }
-    if (isAncestor) {
-        return { merged: true, method: 'git_merge_base' };
-    }
-    return { merged: false, method: 'git_merge_base' };
+    return { merged: null, method: 'gh_api' };
 }
 async function removeWorktree(worktreePath) {
     if (!existsSync(worktreePath)) {
@@ -154,6 +140,31 @@ async function cleanupArtifactsInWorktree() {
     }
     console.log(`${LOG_PREFIX.CLEANUP} ✓ Build artifact cleanup complete`);
 }
+async function hasUncommittedChanges(worktreePath) {
+    if (!existsSync(worktreePath)) {
+        return false;
+    }
+    const git = createGitForPath(worktreePath);
+    const status = await git.getStatus();
+    return status.length > 0;
+}
+async function hasUnpushedCommits(worktreePath) {
+    if (!existsSync(worktreePath)) {
+        return false;
+    }
+    const git = createGitForPath(worktreePath);
+    try {
+        const unpushed = await git.getUnpushedCommits();
+        return unpushed.length > 0;
+    }
+    catch {
+        return true;
+    }
+}
+function hasStampFile(wuId) {
+    const stampPath = path.join(process.cwd(), WU_PATHS.STAMP(wuId));
+    return existsSync(stampPath);
+}
 async function main() {
     const args = createWUParser({
         name: 'wu-cleanup',
@@ -181,6 +192,7 @@ async function main() {
     const idK = args.id.toLowerCase();
     const laneBranch = `lane/${laneK}/${idK}`;
     const worktreePath = path.join('worktrees', `${laneK}-${idK}`);
+    const absoluteWorktreePath = path.resolve(worktreePath);
     console.log(`[wu-cleanup] Cleaning up ${args.id} (${wu.title})`);
     console.log(`[wu-cleanup] Lane: ${wu.lane}`);
     console.log(`[wu-cleanup] Branch: ${laneBranch}`);
@@ -200,25 +212,38 @@ async function main() {
         console.error(BOX.BOT);
         process.exit(EXIT_CODES.ERROR);
     }
-    // 1. Verify PR is merged
-    console.log('[wu-cleanup] Verifying PR merge status...');
-    const { merged, method } = await verifyPRMerged(laneBranch);
-    if (!merged) {
+    const cleanupCheck = {
+        hasUncommittedChanges: await hasUncommittedChanges(absoluteWorktreePath),
+        hasUnpushedCommits: await hasUnpushedCommits(absoluteWorktreePath),
+        hasStamp: hasStampFile(id),
+        yamlStatus: wu.status,
+        ghAvailable: isGhCliAvailable(),
+        prMerged: null,
+    };
+    if (cleanupCheck.ghAvailable) {
+        console.log(`${LOG_PREFIX.CLEANUP} ${CLEANUP_GUARD.PR_CHECK.START}`);
+        const { merged, method } = await verifyPRMerged(laneBranch);
+        cleanupCheck.prMerged = merged;
+        console.log(`${LOG_PREFIX.CLEANUP} ${CLEANUP_GUARD.PR_CHECK.RESULT} ${method}`);
+        console.log();
+    }
+    const guardResult = evaluateCleanupGuards(cleanupCheck);
+    if (!guardResult.allowed) {
         console.error();
         console.error(BOX.TOP);
-        console.error('║  PR NOT MERGED');
+        console.error(`${BOX.SIDE}  ${CLEANUP_GUARD.TITLES.BLOCKED}`);
         console.error(BOX.MID);
-        console.error(`║  Branch ${laneBranch} has not been merged to main yet.`);
-        console.error('║');
-        console.error('║  Next steps:');
-        console.error('║  1. Review the PR in GitHub UI');
-        console.error('║  2. Merge the PR');
-        console.error(`║  3. Re-run: pnpm wu:cleanup --id ${args.id}`);
+        console.error(`${BOX.SIDE}  ${CLEANUP_GUARD.MESSAGES[guardResult.reason]}`);
+        console.error(`${BOX.SIDE}`);
+        console.error(`${BOX.SIDE}  ${CLEANUP_GUARD.TITLES.NEXT_STEPS}`);
+        const steps = CLEANUP_GUARD.NEXT_STEPS[guardResult.reason] || CLEANUP_GUARD.NEXT_STEPS.DEFAULT;
+        for (const step of steps) {
+            const line = step.appendId ? `${step.text} ${args.id}` : step.text;
+            console.error(`${BOX.SIDE}  ${line}`);
+        }
         console.error(BOX.BOT);
         process.exit(EXIT_CODES.ERROR);
     }
-    console.log(`[wu-cleanup] ✓ PR merged (verified via ${method})`);
-    console.log();
     // 2. Remove worktree
     await removeWorktree(worktreePath);
     console.log();
@@ -235,6 +260,7 @@ async function main() {
 }
 // Guard main() for testability (WU-1366)
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/dist/wu-create.js

@@ -589,6 +589,7 @@ async function main() {
 }
 // Guard main() for testability (WU-1366)
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/dist/wu-deps.js

@@ -114,6 +114,7 @@ function renderGraphJSON(graph, rootId, depth, direction) {
 }
 // Guard main() for testability (WU-1366)
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/dist/wu-done.js

@@ -2214,6 +2214,7 @@ async function detectChangedDocPaths(worktreePath, baseBranch) {
 // Guard main() execution for testability (WU-1366)
 // When imported as a module for testing, main() should not auto-run
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/dist/wu-infer-lane.js

@@ -93,7 +93,7 @@ function loadWuYaml(id) {
             `  2. Fix YAML errors manually and retry`);
     }
 }
-function main() {
+async function main() {
     const args = parseArgs(process.argv);
     let codePaths = [];
     let description = '';
@@ -130,6 +130,7 @@ function main() {
 }
 // Guard main() for testability (WU-1366)
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/dist/wu-preflight.js

@@ -160,8 +160,9 @@ async function main() {
     process.exit(EXIT_CODES.SUCCESS);
 }
 // Guard main() for testability
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }
 // Export for testing
 export { parseArgs, detectWorktreePath };

package/dist/wu-prune.js

@@ -19,8 +19,8 @@ import { readWUYaml, validateBranchName, extractWUFromBranch, } from '@lumenflow
 import { WU_PATHS } from '@lumenflow/core/dist/wu-paths.js';
 import { die } from '@lumenflow/core/dist/error-handler.js';
 import { getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
-import { detectOrphanWorktrees, removeOrphanDirectory, } from '@lumenflow/core/dist/orphan-detector.js';
-import { BRANCHES, WU_STATUS, CLI_FLAGS, EXIT_CODES, STRING_LITERALS, EMOJI, LOG_PREFIX, } from '@lumenflow/core/dist/wu-constants.js';
+import { detectOrphanWorktrees, detectMissingTrackedWorktrees, removeOrphanDirectory, } from '@lumenflow/core/dist/orphan-detector.js';
+import { BRANCHES, WU_STATUS, CLI_FLAGS, EXIT_CODES, STRING_LITERALS, EMOJI, LOG_PREFIX, WORKTREE_WARNINGS, } from '@lumenflow/core/dist/wu-constants.js';
 function parseArgs(argv) {
     const args = { dryRun: true }; // Default to dry-run for safety
     for (let i = 2; i < argv.length; i++) {
@@ -145,6 +145,14 @@ This tool:
     }
     console.log(`${PREFIX} Worktree Hygiene Check`);
     console.log(`${PREFIX} =====================\n`);
+    const missingTracked = await detectMissingTrackedWorktrees(process.cwd());
+    if (missingTracked.length > 0) {
+        console.warn(`${PREFIX} ${EMOJI.WARNING} ${WORKTREE_WARNINGS.MISSING_TRACKED_HEADER}`);
+        for (const missingPath of missingTracked) {
+            console.warn(`${PREFIX} ${WORKTREE_WARNINGS.MISSING_TRACKED_LINE(missingPath)}`);
+        }
+        console.warn('');
+    }
     if (args.dryRun) {
         console.log(`${PREFIX} ${EMOJI.INFO} DRY-RUN MODE (use --execute to apply changes)\n`);
     }
@@ -254,6 +262,7 @@ This tool:
 }
 // Guard main() for testability (WU-1366)
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/dist/wu-repair.js

@@ -219,8 +219,9 @@ async function main() {
 }
 // Guard main() for testability (WU-1366)
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }
 // Export for testing
 export { normaliseWUId, isValidWUId };

package/dist/wu-spawn.js

@@ -1241,6 +1241,7 @@ async function main() {
 }
 // Guard main() for testability
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/dist/wu-unlock-lane.js

@@ -155,4 +155,9 @@ async function main() {
     console.log(`${PREFIX} Previous owner: ${result.previousLock?.wuId || 'unknown'}`);
     console.log(`${PREFIX} Reason: ${result.reason}`);
 }
-main();
+// Guard main() for testability (WU-1064)
+import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    runCLI(main);
+}

package/dist/wu-validate.js

@@ -188,6 +188,7 @@ async function main() {
 }
 // Guard main() for testability
 import { fileURLToPath } from 'node:url';
+import { runCLI } from './cli-entry-point.js';
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main();
+    runCLI(main);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumenflow/cli",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Command-line interface for LumenFlow workflow framework",
   "keywords": [
     "lumenflow",
@@ -85,11 +85,11 @@
     "pretty-ms": "^9.2.0",
     "simple-git": "^3.30.0",
     "yaml": "^2.8.2",
-    "@lumenflow/memory": "1.3.0",
-    "@lumenflow/agent": "1.3.0",
-    "@lumenflow/initiatives": "1.3.0",
-    "@lumenflow/metrics": "1.3.0",
-    "@lumenflow/core": "1.3.0"
+    "@lumenflow/core": "1.3.2",
+    "@lumenflow/metrics": "1.3.2",
+    "@lumenflow/memory": "1.3.2",
+    "@lumenflow/initiatives": "1.3.2",
+    "@lumenflow/agent": "1.3.2"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.17",

package/dist/gates.d.ts

@@ -1,41 +0,0 @@
-#!/usr/bin/env node
-/**
- * Quality Gates Runner
- *
- * Runs quality gates with support for docs-only mode and incremental linting.
- *
- * WU-1304: Optimise ESLint gates performance
- * - Uses incremental linting (only files changed since branching from main)
- * - Full lint coverage maintained via CI workflow
- *
- * WU-1433: Coverage gate with mode flag
- * - Checks coverage thresholds for hex core files (≥90% for application layer)
- * - Mode: block (default) fails the gate, warn logs warnings only
- * WU-2334: Changed default from warn to block for TDD enforcement
- *
- * WU-1610: Supabase docs linter
- * - Verifies every table in migrations is documented in schema.md
- * - Fails if any table is missing documentation
- *
- * For type:documentation WUs:
- * - ✅ Run: format:check, spec:linter, prompts:lint, backlog-sync
- * - ❌ Skip: lint, typecheck, supabase-docs:linter, tests, coverage (no code changed)
- *
- * WU-1920: Incremental test execution
- * - Uses Vitest's --changed flag to run only tests for changed files
- * - Full test suite maintained via CI workflow and --full-tests flag
- *
- * WU-2062: Tiered test execution for faster wu:done
- * - Safety-critical tests (PHI, escalation, red-flag) ALWAYS run
- * - Docs-only WUs: lint/typecheck only (auto-detected or --docs-only flag)
- * - High-risk WUs (auth, PHI, RLS, migrations): run integration tests
- * - Standard WUs: changed tests + safety-critical tests
- *
- * Usage:
- *   node tools/gates.mjs                        # Tiered gates (default)
- *   node tools/gates.mjs --docs-only            # Docs-only gates
- *   node tools/gates.mjs --full-lint            # Full lint (bypass incremental)
- *   node tools/gates.mjs --full-tests           # Full tests (bypass incremental)
- *   node tools/gates.mjs --coverage-mode=block  # Coverage gate in block mode
- */
-export {};

package/dist/gates.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gates.d.ts","sourceRoot":"","sources":["../src/gates.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG"}