@lumenflow/cli 2.1.0 → 2.1.2

package/dist/__tests__/guard-main-branch.test.js

@@ -0,0 +1,79 @@
+/**
+ * @file guard-main-branch.test.ts
+ * @description Tests for guard-main-branch worktree context detection (WU-1130)
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { guardMainBranch } from '../guard-main-branch.js';
+// Mock the core module
+vi.mock('@lumenflow/core', () => ({
+    createGitForPath: vi.fn(),
+    getGitForCwd: vi.fn(),
+    isAgentBranch: vi.fn().mockResolvedValue(false),
+    getConfig: vi.fn().mockReturnValue({
+        git: {
+            mainBranch: 'main',
+            laneBranchPrefix: 'lane/',
+        },
+    }),
+}));
+// Mock the worktree-guard module
+vi.mock('@lumenflow/core/dist/core/worktree-guard.js', () => ({
+    isInWorktree: vi.fn(),
+}));
+import { getGitForCwd, createGitForPath } from '@lumenflow/core';
+import { isInWorktree } from '@lumenflow/core/dist/core/worktree-guard.js';
+describe('guard-main-branch (WU-1130)', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('lane branch worktree detection', () => {
+        it('should allow operations when on lane branch AND in worktree', async () => {
+            // Setup: On lane branch, in worktree
+            const mockGit = {
+                getCurrentBranch: vi.fn().mockResolvedValue('lane/framework-cli/wu-1130'),
+            };
+            vi.mocked(getGitForCwd).mockReturnValue(mockGit);
+            vi.mocked(isInWorktree).mockReturnValue(true);
+            const result = await guardMainBranch({});
+            expect(result.success).toBe(true);
+            expect(result.isProtected).toBe(false);
+            expect(result.currentBranch).toBe('lane/framework-cli/wu-1130');
+        });
+        it('should block operations when on lane branch but NOT in worktree', async () => {
+            // Setup: On lane branch, but not in worktree (e.g., checked out directly)
+            const mockGit = {
+                getCurrentBranch: vi.fn().mockResolvedValue('lane/framework-cli/wu-1130'),
+            };
+            vi.mocked(getGitForCwd).mockReturnValue(mockGit);
+            vi.mocked(isInWorktree).mockReturnValue(false);
+            const result = await guardMainBranch({});
+            expect(result.success).toBe(true);
+            expect(result.isProtected).toBe(true);
+            expect(result.reason).toContain('requires worktree');
+        });
+        it('should use baseDir for worktree detection when provided', async () => {
+            const mockGit = {
+                getCurrentBranch: vi.fn().mockResolvedValue('lane/ops-tooling/wu-2725'),
+            };
+            vi.mocked(createGitForPath).mockReturnValue(mockGit);
+            vi.mocked(isInWorktree).mockReturnValue(true);
+            const result = await guardMainBranch({ baseDir: '/path/to/worktrees/ops-tooling-wu-2725' });
+            expect(isInWorktree).toHaveBeenCalledWith({ cwd: '/path/to/worktrees/ops-tooling-wu-2725' });
+            expect(result.isProtected).toBe(false);
+        });
+    });
+    describe('main branch protection', () => {
+        it('should block operations on main branch', async () => {
+            const mockGit = {
+                getCurrentBranch: vi.fn().mockResolvedValue('main'),
+            };
+            vi.mocked(getGitForCwd).mockReturnValue(mockGit);
+            const result = await guardMainBranch({});
+            expect(result.isProtected).toBe(true);
+            expect(result.reason).toContain("'main' is protected");
+        });
+    });
+});

package/dist/__tests__/lumenflow-upgrade.test.js

@@ -3,18 +3,50 @@
  * Tests for lumenflow-upgrade CLI command
  *
  * WU-1112: INIT-003 Phase 6 - Migrate remaining Tier 1 tools
+ * WU-1127: Add micro-worktree isolation pattern
  *
  * lumenflow-upgrade updates all @lumenflow/* packages to latest versions.
  * Key requirements:
- * - Uses worktree pattern (runs pnpm install in worktree, not main)
+ * - Uses micro-worktree pattern (atomic changes to main without requiring user worktree)
  * - Checks all 7 @lumenflow/* packages
+ * - Supports --dry-run and --latest flags
  */
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// Import functions under test
-import { parseUpgradeArgs, LUMENFLOW_PACKAGES, buildUpgradeCommands, } from '../lumenflow-upgrade.js';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { execSync } from 'node:child_process';
+// Mock modules with inline factories (no external references)
+vi.mock('@lumenflow/core/dist/micro-worktree.js', () => ({
+    withMicroWorktree: vi.fn(),
+}));
+vi.mock('@lumenflow/core/dist/git-adapter.js', () => ({
+    getGitForCwd: vi.fn(),
+}));
+vi.mock('node:child_process', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        execSync: vi.fn(),
+    };
+});
+// Import mocked modules to access mock functions
+import { withMicroWorktree } from '@lumenflow/core/dist/micro-worktree.js';
+import { getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
+// Import functions under test after mocks are set up
+import { parseUpgradeArgs, LUMENFLOW_PACKAGES, buildUpgradeCommands, executeUpgradeInMicroWorktree, validateMainCheckout, } from '../lumenflow-upgrade.js';
+// Cast mocks for TypeScript
+const mockWithMicroWorktree = withMicroWorktree;
+const mockGetGitForCwd = getGitForCwd;
+const mockExecSync = execSync;
 describe('lumenflow-upgrade', () => {
     beforeEach(() => {
         vi.clearAllMocks();
+        // Default mock behavior for git adapter
+        mockGetGitForCwd.mockReturnValue({
+            raw: vi.fn().mockResolvedValue('main'),
+            getStatus: vi.fn().mockResolvedValue(''),
+        });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
     });
     describe('LUMENFLOW_PACKAGES constant', () => {
         it('should include all 7 @lumenflow/* packages', () => {
@@ -94,14 +126,135 @@ describe('lumenflow-upgrade', () => {
             expect(packageCount).toBe(7);
         });
     });
-    describe('worktree pattern enforcement', () => {
-        it('should include note about worktree usage in commands', () => {
-            const args = { version: '1.5.0' };
-            const commands = buildUpgradeCommands(args);
-            // The command should be designed to run in worktree
-            // Actual execution is tested in integration tests
-            expect(commands.addCommand).toBeDefined();
-            expect(commands.addCommand.length).toBeGreaterThan(0);
+    // WU-1127: Tests for micro-worktree isolation pattern
+    describe('validateMainCheckout', () => {
+        let originalCwd;
+        beforeEach(() => {
+            originalCwd = process.cwd;
+        });
+        afterEach(() => {
+            process.cwd = originalCwd;
+        });
+        it('should return valid when on main branch and not in worktree', async () => {
+            // Mock process.cwd to be on main checkout (not worktree)
+            process.cwd = vi.fn().mockReturnValue('/path/to/repo');
+            mockGetGitForCwd.mockReturnValue({
+                raw: vi.fn().mockResolvedValue('main'),
+                getStatus: vi.fn().mockResolvedValue(''),
+            });
+            const result = await validateMainCheckout();
+            expect(result.valid).toBe(true);
+        });
+        it('should return invalid when not on main branch', async () => {
+            // Mock process.cwd to be on main checkout (not worktree)
+            process.cwd = vi.fn().mockReturnValue('/path/to/repo');
+            mockGetGitForCwd.mockReturnValue({
+                raw: vi.fn().mockResolvedValue('lane/framework-cli/wu-123'),
+                getStatus: vi.fn().mockResolvedValue(''),
+            });
+            const result = await validateMainCheckout();
+            expect(result.valid).toBe(false);
+            expect(result.error).toContain('must be run from main checkout');
+        });
+        it('should return invalid when in a worktree directory', async () => {
+            // Mock process.cwd() to be in a worktree
+            process.cwd = vi
+                .fn()
+                .mockReturnValue('/path/to/repo/worktrees/some-wu');
+            mockGetGitForCwd.mockReturnValue({
+                raw: vi.fn().mockResolvedValue('main'),
+                getStatus: vi.fn().mockResolvedValue(''),
+            });
+            const result = await validateMainCheckout();
+            expect(result.valid).toBe(false);
+            expect(result.error).toContain('worktree');
+        });
+    });
+    describe('executeUpgradeInMicroWorktree', () => {
+        it('should call withMicroWorktree with correct operation name', async () => {
+            mockWithMicroWorktree.mockResolvedValue({});
+            mockExecSync.mockReturnValue('');
+            const args = { version: '2.1.0' };
+            await executeUpgradeInMicroWorktree(args);
+            expect(mockWithMicroWorktree).toHaveBeenCalledTimes(1);
+            expect(mockWithMicroWorktree).toHaveBeenCalledWith(expect.objectContaining({
+                operation: 'lumenflow-upgrade',
+            }));
+        });
+        it('should use a unique ID for micro-worktree based on timestamp', async () => {
+            mockWithMicroWorktree.mockResolvedValue({});
+            mockExecSync.mockReturnValue('');
+            const args = { latest: true };
+            await executeUpgradeInMicroWorktree(args);
+            // ID should be a timestamp-like string
+            expect(mockWithMicroWorktree).toHaveBeenCalledWith(expect.objectContaining({
+                id: expect.stringMatching(/^upgrade-\d+$/),
+            }));
+        });
+        it('should execute pnpm add in the micro-worktree', async () => {
+            mockWithMicroWorktree.mockImplementation(async (options) => {
+                // Simulate calling the execute function with a worktree path
+                return options.execute({ worktreePath: '/tmp/test-worktree' });
+            });
+            const args = { version: '2.1.0' };
+            await executeUpgradeInMicroWorktree(args);
+            // Verify pnpm add was executed with correct cwd
+            expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('pnpm add'), expect.objectContaining({
+                cwd: '/tmp/test-worktree',
+            }));
+        });
+        it('should include all 7 packages in the pnpm add command', async () => {
+            mockWithMicroWorktree.mockImplementation(async (options) => {
+                return options.execute({ worktreePath: '/tmp/test-worktree' });
+            });
+            const args = { version: '2.1.0' };
+            await executeUpgradeInMicroWorktree(args);
+            // Get the command that was executed
+            const execCall = mockExecSync.mock.calls[0][0];
+            expect(typeof execCall).toBe('string');
+            // Verify all 7 packages are included
+            for (const pkg of LUMENFLOW_PACKAGES) {
+                expect(execCall).toContain(`${pkg}@2.1.0`);
+            }
+        });
+        it('should return appropriate commit message and files', async () => {
+            let executeResult;
+            mockWithMicroWorktree.mockImplementation(async (options) => {
+                executeResult = await options.execute({ worktreePath: '/tmp/test-worktree' });
+                return executeResult;
+            });
+            const args = { version: '2.1.0' };
+            await executeUpgradeInMicroWorktree(args);
+            expect(executeResult).toBeDefined();
+            expect(executeResult.commitMessage).toContain('upgrade @lumenflow packages');
+            expect(executeResult.files).toContain('package.json');
+            expect(executeResult.files).toContain('pnpm-lock.yaml');
+        });
+        it('should use --latest version specifier when latest flag is set', async () => {
+            mockWithMicroWorktree.mockImplementation(async (options) => {
+                return options.execute({ worktreePath: '/tmp/test-worktree' });
+            });
+            const args = { latest: true };
+            await executeUpgradeInMicroWorktree(args);
+            const execCall = mockExecSync.mock.calls[0][0];
+            expect(execCall).toContain('@lumenflow/core@latest');
+        });
+    });
+    describe('dry-run mode', () => {
+        it('should not call withMicroWorktree when dryRun is true', async () => {
+            const args = { version: '2.1.0', dryRun: true };
+            // In dry-run mode, executeUpgradeInMicroWorktree should not be called
+            // This is handled by the main() function checking dryRun before calling execute
+            // We just verify the function exists and can be called
+            expect(typeof executeUpgradeInMicroWorktree).toBe('function');
+        });
+    });
+    describe('legacy worktree validation removal', () => {
+        it('should not require user to be in a worktree', () => {
+            // The old implementation required users to be inside a worktree
+            // The new implementation uses micro-worktree and runs from main checkout
+            // This test verifies the old validateWorktreeContext is no longer used
+            expect(typeof validateMainCheckout).toBe('function');
         });
     });
 });

package/dist/guard-main-branch.js

@@ -13,6 +13,7 @@
  * WU-1109: INIT-003 Phase 4b - Migrate git operations
  */
 import { createGitForPath, getGitForCwd, isAgentBranch, getConfig } from '@lumenflow/core';
+import { isInWorktree } from '@lumenflow/core/dist/core/worktree-guard.js';
 /**
  * Parse command line arguments for guard-main-branch
  */
@@ -90,6 +91,16 @@ export async function guardMainBranch(args) {
         }
         // Check if on a lane branch (requires worktree discipline)
         if (isLaneBranch(currentBranch)) {
+            // If we're actually in a worktree, allow the operation (WU-1130)
+            const cwd = args.baseDir ?? process.cwd();
+            if (isInWorktree({ cwd })) {
+                return {
+                    success: true,
+                    isProtected: false,
+                    currentBranch,
+                };
+            }
+            // On lane branch but not in worktree - block
             return {
                 success: true,
                 isProtected: true,

package/dist/lumenflow-upgrade.js

@@ -3,13 +3,16 @@
  * LumenFlow Upgrade CLI Command
  *
  * Updates all @lumenflow/* packages to a specified version or latest.
- * Uses worktree pattern to ensure pnpm install runs in worktree, not main.
+ * Uses micro-worktree pattern for atomic changes to main without requiring
+ * users to be in a worktree.
  *
  * WU-1112: INIT-003 Phase 6 - Migrate remaining Tier 1 tools
+ * WU-1127: Use micro-worktree isolation pattern (fixes user blocking issue)
  *
- * Key requirements (from WU acceptance criteria):
- * - Uses worktree pattern (install runs in worktree, not main)
- * - Checks all 7 @lumenflow/* packages (not just 4)
+ * Key requirements:
+ * - Uses micro-worktree pattern (atomic changes, no user worktree needed)
+ * - Runs from main checkout (not inside a worktree)
+ * - Checks all 7 @lumenflow/* packages
  *
  * Usage:
  *   pnpm lumenflow:upgrade --version 1.5.0
@@ -17,11 +20,14 @@
  *   pnpm lumenflow:upgrade --latest --dry-run
  */
 import { execSync } from 'node:child_process';
-import { STDIO_MODES, EXIT_CODES, PKG_MANAGER, } from '@lumenflow/core/dist/wu-constants.js';
+import { STDIO_MODES, EXIT_CODES, PKG_MANAGER, DEFAULTS, BRANCHES, } from '@lumenflow/core/dist/wu-constants.js';
+import { getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
+import { withMicroWorktree } from '@lumenflow/core/dist/micro-worktree.js';
 import { runCLI } from './cli-entry-point.js';
-import { validateWorktreeContext } from './deps-add.js';
 /** Log prefix for console output */
 const LOG_PREFIX = '[lumenflow:upgrade]';
+/** Operation name for micro-worktree */
+const OPERATION_NAME = 'lumenflow-upgrade';
 /**
  * All @lumenflow/* packages that should be upgraded together
  *
@@ -85,6 +91,98 @@ export function buildUpgradeCommands(args) {
         versionSpec,
     };
 }
+/**
+ * WU-1127: Validate that the command is run from main checkout
+ *
+ * The micro-worktree pattern requires the command to be run from the main
+ * checkout (not inside a worktree). This is the inverse of the old behavior
+ * which required users to be IN a worktree.
+ *
+ * @returns Validation result with error and fix command if invalid
+ */
+export async function validateMainCheckout() {
+    const cwd = process.cwd();
+    const worktreesDir = `/${DEFAULTS.WORKTREES_DIR}/`;
+    // Check if we're inside a worktree directory
+    if (cwd.includes(worktreesDir)) {
+        return {
+            valid: false,
+            error: `Cannot run lumenflow:upgrade from inside a worktree.\n\n` +
+                `This command must be run from main checkout because it uses\n` +
+                `micro-worktree isolation to atomically update package.json and lockfile.`,
+            fixCommand: `cd to main checkout and re-run:\n  cd <main-checkout>\n  pnpm lumenflow:upgrade --latest`,
+        };
+    }
+    // Check if we're on main branch
+    try {
+        const git = getGitForCwd();
+        const currentBranch = await git.raw(['rev-parse', '--abbrev-ref', 'HEAD']);
+        const branchName = currentBranch.trim();
+        if (branchName !== BRANCHES.MAIN) {
+            return {
+                valid: false,
+                error: `lumenflow:upgrade must be run from main checkout (on main branch).\n\n` +
+                    `Current branch: ${branchName}\n` +
+                    `Expected branch: main`,
+                fixCommand: `Switch to main branch:\n  git checkout main\n  pnpm lumenflow:upgrade --latest`,
+            };
+        }
+    }
+    catch (error) {
+        // If git fails, assume we're not in a valid git repo
+        return {
+            valid: false,
+            error: `Failed to detect git branch. Ensure you're in a git repository.`,
+        };
+    }
+    return { valid: true };
+}
+/**
+ * WU-1127: Execute the upgrade in a micro-worktree
+ *
+ * Uses the shared micro-worktree pattern (like wu:create, wu:edit) to:
+ * 1. Create a temporary worktree without switching main checkout
+ * 2. Run pnpm add in the temporary worktree
+ * 3. Commit the changes
+ * 4. FF-only merge to main
+ * 5. Push to origin
+ * 6. Cleanup
+ *
+ * @param args - Parsed upgrade arguments
+ * @returns Promise resolving when upgrade is complete
+ */
+export async function executeUpgradeInMicroWorktree(args) {
+    const { addCommand, versionSpec } = buildUpgradeCommands(args);
+    // Generate unique ID for this upgrade operation using timestamp
+    const upgradeId = `upgrade-${Date.now()}`;
+    console.log(`${LOG_PREFIX} Using micro-worktree isolation (WU-1127)`);
+    console.log(`${LOG_PREFIX} Upgrading @lumenflow/* packages to ${versionSpec}`);
+    console.log(`${LOG_PREFIX} Packages: ${LUMENFLOW_PACKAGES.length} packages`);
+    await withMicroWorktree({
+        operation: OPERATION_NAME,
+        id: upgradeId,
+        logPrefix: LOG_PREFIX,
+        execute: async ({ worktreePath }) => {
+            console.log(`${LOG_PREFIX} Running: ${addCommand}`);
+            // Execute pnpm add in the micro-worktree
+            execSync(addCommand, {
+                stdio: STDIO_MODES.INHERIT,
+                cwd: worktreePath,
+            });
+            console.log(`${LOG_PREFIX} Package installation complete`);
+            // Return files to stage and commit message
+            return {
+                commitMessage: `chore: upgrade @lumenflow packages to ${versionSpec}`,
+                files: ['package.json', 'pnpm-lock.yaml'],
+            };
+        },
+    });
+    console.log(`\n${LOG_PREFIX} Upgrade complete!`);
+    console.log(`${LOG_PREFIX} Upgraded to ${versionSpec}`);
+    console.log(`\n${LOG_PREFIX} Next steps:`);
+    console.log(`  1. Run 'pnpm build' to rebuild with new versions`);
+    console.log(`  2. Run 'pnpm gates' to verify everything works`);
+}
 /**
  * Print help message for lumenflow-upgrade
  */
@@ -94,7 +192,7 @@ function printHelp() {
 Usage: lumenflow-upgrade [options]
 
 Upgrade all @lumenflow/* packages to a specified version.
-Must be run from inside a worktree to enforce worktree discipline.
+Uses micro-worktree isolation to atomically update packages from main checkout.
 
 Options:
   -v, --version <ver>   Upgrade to specific version (e.g., 1.5.0)
@@ -110,13 +208,13 @@ Examples:
   lumenflow:upgrade --latest           # Upgrade to latest
   lumenflow:upgrade --latest --dry-run # Preview upgrade commands
 
-Worktree Discipline:
-  This command only works inside a worktree to prevent lockfile
-  conflicts on main checkout. Claim a WU first:
+Micro-Worktree Pattern (WU-1127):
+  This command uses micro-worktree isolation to atomically update
+  package.json and pnpm-lock.yaml without requiring you to claim a WU.
 
-    pnpm wu:claim --id WU-XXXX --lane "Your Lane"
-    cd worktrees/<lane>-wu-<id>/
-    lumenflow:upgrade --latest
+  Run from your main checkout (NOT from inside a worktree):
+    cd /path/to/main
+    pnpm lumenflow:upgrade --latest
 `);
 }
 /**
@@ -135,40 +233,32 @@ async function main() {
         printHelp();
         process.exit(EXIT_CODES.ERROR);
     }
-    // Validate worktree context (WU-1112 requirement: must run in worktree)
-    const validation = validateWorktreeContext(process.cwd());
+    // WU-1127: Validate we're on main checkout (not in a worktree)
+    const validation = await validateMainCheckout();
     if (!validation.valid) {
         console.error(`${LOG_PREFIX} ${validation.error}`);
-        console.error(`\nTo fix:\n${validation.fixCommand}`);
+        if (validation.fixCommand) {
+            console.error(`\nTo fix:\n${validation.fixCommand}`);
+        }
         process.exit(EXIT_CODES.ERROR);
     }
-    // Build upgrade commands
+    // Build upgrade commands for dry-run display
     const { addCommand, versionSpec } = buildUpgradeCommands(args);
-    console.log(`${LOG_PREFIX} Upgrading @lumenflow/* packages to ${versionSpec}`);
-    console.log(`${LOG_PREFIX} Packages: ${LUMENFLOW_PACKAGES.length} packages`);
     if (args.dryRun) {
-        console.log(`\n${LOG_PREFIX} DRY RUN - Commands that would be executed:`);
+        console.log(`${LOG_PREFIX} DRY RUN - Commands that would be executed:`);
         console.log(`  ${addCommand}`);
+        console.log(`\n${LOG_PREFIX} Packages: ${LUMENFLOW_PACKAGES.length}`);
+        console.log(`${LOG_PREFIX} Version: ${versionSpec}`);
         console.log(`\n${LOG_PREFIX} No changes made.`);
         process.exit(EXIT_CODES.SUCCESS);
     }
-    // Execute upgrade
-    console.log(`${LOG_PREFIX} Running: ${addCommand}`);
+    // Execute upgrade using micro-worktree
     try {
-        execSync(addCommand, {
-            stdio: STDIO_MODES.INHERIT,
-            cwd: process.cwd(),
-        });
-        console.log(`\n${LOG_PREFIX} ✅ Upgrade complete!`);
-        console.log(`${LOG_PREFIX} Upgraded to ${versionSpec}`);
-        console.log(`\n${LOG_PREFIX} Next steps:`);
-        console.log(`  1. Run 'pnpm build' to rebuild with new versions`);
-        console.log(`  2. Run 'pnpm gates' to verify everything works`);
-        console.log(`  3. Commit the changes`);
+        await executeUpgradeInMicroWorktree(args);
     }
     catch (error) {
-        console.error(`\n${LOG_PREFIX} ❌ Upgrade failed`);
-        console.error(`${LOG_PREFIX} Check the error above and try again.`);
+        console.error(`\n${LOG_PREFIX} Upgrade failed`);
+        console.error(`${LOG_PREFIX} ${error instanceof Error ? error.message : String(error)}`);
         process.exit(EXIT_CODES.ERROR);
     }
 }

package/package.json

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