@lumenflow/mcp 2.21.0 → 3.0.0

package/dist/tools/parity-tools.js

@@ -6,9 +6,12 @@
  * WU-1482: Wave-1 public parity tools
  * WU-1483: Wave-2 public parity tools (file, git, plan, signal, wu:proto)
  */
+import path from 'node:path';
 import { z } from 'zod';
 import { gatesSchema, lumenflowInitSchema, initiativePlanSchema } from '@lumenflow/core';
-import { ErrorCodes, ErrorMessages, CliArgs, SharedErrorMessages, SuccessMessages, success, error, buildGatesArgs, runCliCommand, } from '../tools-shared.js';
+import { ErrorCodes, ErrorMessages, CliArgs, SharedErrorMessages, SuccessMessages, success, error, buildGatesArgs, executeViaPack, } from '../tools-shared.js';
+import { CliCommands, MetadataKeys } from '../mcp-constants.js';
+import { checkWorktreeEnforcement } from '../worktree-enforcement.js';
 // WU-1482: Schemas for wave-1 parity commands not yet modeled in @lumenflow/core
 const backlogPruneSchema = z.object({
     execute: z.boolean().optional(),
@@ -34,6 +37,32 @@ const laneSuggestSchema = z.object({
     no_llm: z.boolean().optional(),
     include_git: z.boolean().optional(),
 });
+/**
+ * WU-1802: Fallback messages for lane tools migrated to executeViaPack.
+ */
+const LaneMessages = {
+    HEALTH_PASSED: 'Lane health check complete',
+    HEALTH_FAILED: 'lane:health failed',
+    SUGGEST_GENERATED: 'Lane suggestions generated',
+    SUGGEST_FAILED: 'lane:suggest failed',
+};
+const LaneFlags = {
+    NO_COVERAGE: '--no-coverage',
+    DRY_RUN: '--dry-run',
+    INTERACTIVE: '--interactive',
+    OUTPUT: '--output',
+    NO_LLM: '--no-llm',
+    INCLUDE_GIT: '--include-git',
+};
+const GatesRuntimeMessages = {
+    GATES_FAILED: 'gates failed',
+    GATES_DOCS_PASSED: 'Docs-only gates passed',
+    GATES_DOCS_FAILED: 'gates:docs failed',
+    LUMENFLOW_GATES_FAILED: 'lumenflow-gates failed',
+};
+const GatesRuntimeConstants = {
+    FALLBACK_TIMEOUT_MS: 600000,
+};
 const stateBootstrapSchema = z.object({
     execute: z.boolean().optional(),
     dry_run: z.boolean().optional(),
@@ -146,6 +175,14 @@ const signalCleanupSchema = z.object({
     quiet: z.boolean().optional(),
     base_dir: z.string().optional(),
 });
+// WU-1902: Schemas for config:set and config:get commands
+const configSetSchema = z.object({
+    key: z.string().optional(),
+    value: z.string().optional(),
+});
+const configGetSchema = z.object({
+    key: z.string().optional(),
+});
 const wuProtoSchema = z.object({
     lane: z.string().optional(),
     title: z.string().optional(),
@@ -154,6 +191,48 @@ const wuProtoSchema = z.object({
     labels: z.array(z.string()).optional(),
     assigned_to: z.string().optional(),
 });
+const GIT_RUNTIME_TOOL_NAME = CliCommands.GIT_STATUS;
+const GIT_BINARY = 'git';
+const RUNTIME_PROJECT_ROOT_KEY = MetadataKeys.PROJECT_ROOT;
+const GIT_COMMAND_RESULT_STDOUT_KEY = 'stdout';
+const GIT_COMMAND_RESULTS_KEY = 'command_results';
+const GIT_OUTPUT_KEY = 'output';
+function unwrapExecuteViaPackData(data) {
+    if (!data || typeof data !== 'object') {
+        return data;
+    }
+    if (!('success' in data)) {
+        return data;
+    }
+    const output = data;
+    if (!output.success) {
+        return data;
+    }
+    return output.data ?? {};
+}
+function resolveRuntimeProjectRoot(baseDir, projectRoot) {
+    if (typeof baseDir !== 'string' || baseDir.trim().length === 0) {
+        return projectRoot ?? process.cwd();
+    }
+    return path.resolve(projectRoot ?? process.cwd(), baseDir);
+}
+function extractGitOutput(data) {
+    if (!data || typeof data !== 'object') {
+        return '';
+    }
+    const runtimeData = data;
+    if (typeof runtimeData[GIT_OUTPUT_KEY] === 'string') {
+        return runtimeData[GIT_OUTPUT_KEY];
+    }
+    const commandResults = runtimeData[GIT_COMMAND_RESULTS_KEY];
+    if (!Array.isArray(commandResults) || commandResults.length === 0) {
+        return '';
+    }
+    const lastCommandResult = commandResults[commandResults.length - 1];
+    return typeof lastCommandResult[GIT_COMMAND_RESULT_STDOUT_KEY] === 'string'
+        ? lastCommandResult[GIT_COMMAND_RESULT_STDOUT_KEY]
+        : '';
+}
 // ============================================================================
 // Wave-1 Public Parity Operations (WU-1482)
 // ============================================================================
@@ -167,7 +246,7 @@ export const backlogPruneTool = {
     async execute(input, options) {
         const args = [];
         if (input.execute)
-            args.push('--execute');
+            args.push(CliArgs.EXECUTE);
         if (input.dry_run)
             args.push('--dry-run');
         if (input.stale_days_in_progress !== undefined) {
@@ -179,12 +258,29 @@ export const backlogPruneTool = {
         if (input.archive_days !== undefined) {
             args.push('--archive-days', String(input.archive_days));
         }
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('backlog:prune', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'Backlog prune complete' });
+        const execution = await executeViaPack(CliCommands.BACKLOG_PRUNE, {
+            execute: input.execute,
+            dry_run: input.dry_run,
+            stale_days_in_progress: input.stale_days_in_progress,
+            stale_days_ready: input.stale_days_ready,
+            archive_days: input.archive_days,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.BACKLOG_PRUNE,
+                args,
+                errorCode: ErrorCodes.BACKLOG_PRUNE_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'backlog:prune failed', ErrorCodes.BACKLOG_PRUNE_ERROR);
+        return success(unwrapExecuteViaPackData(execution.data));
     },
 };
 /**
@@ -199,13 +295,27 @@ export const docsSyncTool = {
         if (input.vendor)
             args.push('--vendor', input.vendor);
         if (input.force)
-            args.push('--force');
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('docs:sync', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'Docs sync complete' });
+            args.push(CliArgs.FORCE);
+        const execution = await executeViaPack(CliCommands.DOCS_SYNC, {
+            vendor: input.vendor,
+            force: input.force,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.DOCS_SYNC,
+                args,
+                errorCode: ErrorCodes.DOCS_SYNC_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'docs:sync failed', ErrorCodes.DOCS_SYNC_ERROR);
+        return success(unwrapExecuteViaPackData(execution.data));
     },
 };
 /**
@@ -217,15 +327,25 @@ export const gatesTool = {
     inputSchema: gatesSchema,
     async execute(input, options) {
         const args = buildGatesArgs(input);
-        const cliOptions = {
+        const result = await executeViaPack(CliCommands.GATES, input, {
             projectRoot: options?.projectRoot,
-            timeout: 600000,
-        };
-        const result = await runCliCommand('gates', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || SuccessMessages.ALL_GATES_PASSED });
-        }
-        return error(result.stderr || result.error?.message || 'gates failed', ErrorCodes.GATES_ALIAS_ERROR);
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.GATES,
+                args,
+                errorCode: ErrorCodes.GATES_ALIAS_ERROR,
+            },
+            fallbackCliOptions: {
+                timeout: GatesRuntimeConstants.FALLBACK_TIMEOUT_MS,
+            },
+        });
+        return result.success
+            ? success(result.data ?? { message: SuccessMessages.ALL_GATES_PASSED })
+            : error(result.error?.message ?? GatesRuntimeMessages.GATES_FAILED, ErrorCodes.GATES_ALIAS_ERROR);
     },
 };
 /**
@@ -237,19 +357,30 @@ export const gatesDocsTool = {
     inputSchema: gatesSchema,
     async execute(input, options) {
         const args = buildGatesArgs(input, { forceDocsOnly: true });
-        const cliOptions = {
+        const result = await executeViaPack(CliCommands.GATES, input, {
             projectRoot: options?.projectRoot,
-            timeout: 600000,
-        };
-        const result = await runCliCommand('gates', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'Docs-only gates passed' });
-        }
-        return error(result.stderr || result.error?.message || 'gates:docs failed', ErrorCodes.GATES_ALIAS_ERROR);
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.GATES,
+                args,
+                errorCode: ErrorCodes.GATES_ALIAS_ERROR,
+            },
+            fallbackCliOptions: {
+                timeout: GatesRuntimeConstants.FALLBACK_TIMEOUT_MS,
+            },
+        });
+        return result.success
+            ? success(result.data ?? { message: GatesRuntimeMessages.GATES_DOCS_PASSED })
+            : error(result.error?.message ?? GatesRuntimeMessages.GATES_DOCS_FAILED, ErrorCodes.GATES_ALIAS_ERROR);
     },
 };
 /**
  * lane_health - Diagnose lane configuration issues
+ * WU-1802: Migrated from CLI shell-out to executeViaPack (runtime-first)
  */
 export const laneHealthTool = {
     name: 'lane_health',
@@ -258,27 +389,27 @@ export const laneHealthTool = {
     async execute(input, options) {
         const args = [];
         if (input.json)
-            args.push('--json');
+            args.push(CliArgs.JSON);
         if (input.verbose)
-            args.push('--verbose');
+            args.push(CliArgs.VERBOSE);
         if (input.no_coverage)
-            args.push('--no-coverage');
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('lane:health', args, cliOptions);
-        if (result.success) {
-            try {
-                const data = JSON.parse(result.stdout);
-                return success(data);
-            }
-            catch {
-                return success({ message: result.stdout || 'Lane health check complete' });
-            }
-        }
-        return error(result.stderr || result.error?.message || 'lane:health failed', ErrorCodes.LANE_HEALTH_ERROR);
+            args.push(LaneFlags.NO_COVERAGE);
+        const result = await executeViaPack(CliCommands.LANE_HEALTH, input, {
+            projectRoot: options?.projectRoot,
+            fallback: {
+                command: CliCommands.LANE_HEALTH,
+                args,
+                errorCode: ErrorCodes.LANE_HEALTH_ERROR,
+            },
+        });
+        return result.success
+            ? success(result.data ?? { message: LaneMessages.HEALTH_PASSED })
+            : error(result.error?.message ?? LaneMessages.HEALTH_FAILED, ErrorCodes.LANE_HEALTH_ERROR);
     },
 };
 /**
  * lane_suggest - Suggest lane definitions from project context
+ * WU-1802: Migrated from CLI shell-out to executeViaPack (runtime-first)
  */
 export const laneSuggestTool = {
     name: 'lane_suggest',
@@ -287,29 +418,28 @@ export const laneSuggestTool = {
     async execute(input, options) {
         const args = [];
         if (input.dry_run)
-            args.push('--dry-run');
+            args.push(LaneFlags.DRY_RUN);
         if (input.interactive)
-            args.push('--interactive');
+            args.push(LaneFlags.INTERACTIVE);
         if (input.output)
-            args.push('--output', input.output);
+            args.push(LaneFlags.OUTPUT, input.output);
         if (input.json)
-            args.push('--json');
+            args.push(CliArgs.JSON);
         if (input.no_llm)
-            args.push('--no-llm');
+            args.push(LaneFlags.NO_LLM);
         if (input.include_git)
-            args.push('--include-git');
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('lane:suggest', args, cliOptions);
-        if (result.success) {
-            try {
-                const data = JSON.parse(result.stdout);
-                return success(data);
-            }
-            catch {
-                return success({ message: result.stdout || 'Lane suggestions generated' });
-            }
-        }
-        return error(result.stderr || result.error?.message || 'lane:suggest failed', ErrorCodes.LANE_SUGGEST_ERROR);
+            args.push(LaneFlags.INCLUDE_GIT);
+        const result = await executeViaPack(CliCommands.LANE_SUGGEST, input, {
+            projectRoot: options?.projectRoot,
+            fallback: {
+                command: CliCommands.LANE_SUGGEST,
+                args,
+                errorCode: ErrorCodes.LANE_SUGGEST_ERROR,
+            },
+        });
+        return result.success
+            ? success(result.data ?? { message: LaneMessages.SUGGEST_GENERATED })
+            : error(result.error?.message ?? LaneMessages.SUGGEST_FAILED, ErrorCodes.LANE_SUGGEST_ERROR);
     },
 };
 /**
@@ -331,12 +461,29 @@ export const lumenflowTool = {
             args.push('--minimal');
         if (input.framework)
             args.push('--framework', input.framework);
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('lumenflow', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'LumenFlow initialized' });
+        const execution = await executeViaPack(CliCommands.LUMENFLOW, {
+            client: input.client,
+            merge: input.merge,
+            full: input.full,
+            minimal: input.minimal,
+            framework: input.framework,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.LUMENFLOW,
+                args,
+                errorCode: ErrorCodes.LUMENFLOW_ALIAS_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'lumenflow failed', ErrorCodes.LUMENFLOW_ALIAS_ERROR);
+        return success(unwrapExecuteViaPackData(execution.data));
     },
 };
 /**
@@ -348,15 +495,25 @@ export const lumenflowGatesTool = {
     inputSchema: gatesSchema,
     async execute(input, options) {
         const args = buildGatesArgs(input);
-        const cliOptions = {
+        const result = await executeViaPack(CliCommands.GATES, input, {
             projectRoot: options?.projectRoot,
-            timeout: 600000,
-        };
-        const result = await runCliCommand('gates', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || SuccessMessages.ALL_GATES_PASSED });
-        }
-        return error(result.stderr || result.error?.message || 'lumenflow-gates failed', ErrorCodes.LUMENFLOW_GATES_ERROR);
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.GATES,
+                args,
+                errorCode: ErrorCodes.LUMENFLOW_GATES_ERROR,
+            },
+            fallbackCliOptions: {
+                timeout: GatesRuntimeConstants.FALLBACK_TIMEOUT_MS,
+            },
+        });
+        return result.success
+            ? success(result.data ?? { message: SuccessMessages.ALL_GATES_PASSED })
+            : error(result.error?.message ?? GatesRuntimeMessages.LUMENFLOW_GATES_FAILED, ErrorCodes.LUMENFLOW_GATES_ERROR);
     },
 };
 /**
@@ -369,21 +526,38 @@ export const stateBootstrapTool = {
     async execute(input, options) {
         const args = [];
         if (input.execute)
-            args.push('--execute');
+            args.push(CliArgs.EXECUTE);
         if (input.dry_run)
             args.push('--dry-run');
         if (input.force)
-            args.push('--force');
+            args.push(CliArgs.FORCE);
         if (input.wu_dir)
             args.push('--wu-dir', input.wu_dir);
         if (input.state_dir)
             args.push('--state-dir', input.state_dir);
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('state:bootstrap', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'State bootstrap complete' });
+        const execution = await executeViaPack(CliCommands.STATE_BOOTSTRAP, {
+            execute: input.execute,
+            dry_run: input.dry_run,
+            force: input.force,
+            wu_dir: input.wu_dir,
+            state_dir: input.state_dir,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.STATE_BOOTSTRAP,
+                args,
+                errorCode: ErrorCodes.STATE_BOOTSTRAP_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'state:bootstrap failed', ErrorCodes.STATE_BOOTSTRAP_ERROR);
+        return success(unwrapExecuteViaPackData(execution.data));
     },
 };
 /**
@@ -404,17 +578,36 @@ export const stateCleanupTool = {
         if (input.events_only)
             args.push('--events-only');
         if (input.json)
-            args.push('--json');
+            args.push(CliArgs.JSON);
         if (input.quiet)
-            args.push('--quiet');
+            args.push(CliArgs.QUIET);
         if (input.base_dir)
             args.push(CliArgs.BASE_DIR, input.base_dir);
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('state:cleanup', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'State cleanup complete' });
+        const execution = await executeViaPack(CliCommands.STATE_CLEANUP, {
+            dry_run: input.dry_run,
+            signals_only: input.signals_only,
+            memory_only: input.memory_only,
+            events_only: input.events_only,
+            json: input.json,
+            quiet: input.quiet,
+            base_dir: input.base_dir,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.STATE_CLEANUP,
+                args,
+                errorCode: ErrorCodes.STATE_CLEANUP_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'state:cleanup failed', ErrorCodes.STATE_CLEANUP_ERROR);
+        return success(unwrapExecuteViaPackData(execution.data));
     },
 };
 /**
@@ -431,17 +624,34 @@ export const stateDoctorTool = {
         if (input.dry_run)
             args.push('--dry-run');
         if (input.json)
-            args.push('--json');
+            args.push(CliArgs.JSON);
         if (input.quiet)
-            args.push('--quiet');
+            args.push(CliArgs.QUIET);
         if (input.base_dir)
             args.push(CliArgs.BASE_DIR, input.base_dir);
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('state:doctor', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'State doctor complete' });
+        const execution = await executeViaPack(CliCommands.STATE_DOCTOR, {
+            fix: input.fix,
+            dry_run: input.dry_run,
+            json: input.json,
+            quiet: input.quiet,
+            base_dir: input.base_dir,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.STATE_DOCTOR,
+                args,
+                errorCode: ErrorCodes.STATE_DOCTOR_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'state:doctor failed', ErrorCodes.STATE_DOCTOR_ERROR);
+        return success(unwrapExecuteViaPackData(execution.data));
     },
 };
 /**
@@ -456,15 +666,30 @@ export const syncTemplatesTool = {
         if (input.dry_run)
             args.push('--dry-run');
         if (input.verbose)
-            args.push('--verbose');
+            args.push(CliArgs.VERBOSE);
         if (input.check_drift)
             args.push('--check-drift');
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('sync:templates', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'Template sync complete' });
+        const execution = await executeViaPack(CliCommands.SYNC_TEMPLATES, {
+            dry_run: input.dry_run,
+            verbose: input.verbose,
+            check_drift: input.check_drift,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.SYNC_TEMPLATES,
+                args,
+                errorCode: ErrorCodes.SYNC_TEMPLATES_ALIAS_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'sync:templates failed', ErrorCodes.SYNC_TEMPLATES_ALIAS_ERROR);
+        return success(unwrapExecuteViaPackData(execution.data));
     },
 };
 // ============================================================================
@@ -481,7 +706,7 @@ export const fileReadTool = {
         if (!input.path) {
             return error(ErrorMessages.PATH_REQUIRED, ErrorCodes.MISSING_PARAMETER);
         }
-        const args = ['--path', input.path];
+        const args = [CliArgs.PATH, input.path];
         if (input.encoding)
             args.push(CliArgs.ENCODING, input.encoding);
         if (input.start_line !== undefined)
@@ -490,12 +715,29 @@ export const fileReadTool = {
             args.push('--end-line', String(input.end_line));
         if (input.max_size !== undefined)
             args.push('--max-size', String(input.max_size));
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('file:read', args, cliOptions);
-        if (result.success) {
-            return success({ content: result.stdout });
+        const execution = await executeViaPack(CliCommands.FILE_READ, {
+            path: input.path,
+            encoding: input.encoding,
+            start_line: input.start_line,
+            end_line: input.end_line,
+            max_size: input.max_size,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.FILE_READ,
+                args,
+                errorCode: ErrorCodes.FILE_READ_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'file:read failed', ErrorCodes.FILE_READ_ERROR);
+        return success(unwrapExecuteViaPackData(execution.data));
     },
 };
 /**
@@ -512,17 +754,46 @@ export const fileWriteTool = {
         if (input.content === undefined) {
             return error(ErrorMessages.CONTENT_REQUIRED, ErrorCodes.MISSING_PARAMETER);
         }
-        const args = ['--path', input.path, '--content', input.content];
+        // WU-1853: Check worktree enforcement before writing
+        const enforcement = checkWorktreeEnforcement({
+            filePath: input.path,
+            projectRoot: options?.projectRoot,
+        });
+        if (!enforcement.allowed) {
+            return error(enforcement.reason ?? 'Write blocked by worktree enforcement', enforcement.errorCode ?? ErrorCodes.WORKTREE_ENFORCEMENT_BLOCKED);
+        }
+        const args = [
+            CliArgs.PATH,
+            input.path,
+            '--content',
+            input.content,
+        ];
         if (input.encoding)
             args.push(CliArgs.ENCODING, input.encoding);
         if (input.no_create_dirs)
             args.push('--no-create-dirs');
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('file:write', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'File written' });
+        const execution = await executeViaPack(CliCommands.FILE_WRITE, {
+            path: input.path,
+            content: input.content,
+            encoding: input.encoding,
+            no_create_dirs: input.no_create_dirs,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.FILE_WRITE,
+                args,
+                errorCode: ErrorCodes.FILE_WRITE_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'file:write failed', ErrorCodes.FILE_WRITE_ERROR);
+        return success(unwrapExecuteViaPackData(execution.data));
     },
 };
 /**
@@ -542,8 +813,16 @@ export const fileEditTool = {
         if (input.new_string === undefined) {
             return error(ErrorMessages.NEW_STRING_REQUIRED, ErrorCodes.MISSING_PARAMETER);
         }
+        // WU-1853: Check worktree enforcement before editing
+        const enforcement = checkWorktreeEnforcement({
+            filePath: input.path,
+            projectRoot: options?.projectRoot,
+        });
+        if (!enforcement.allowed) {
+            return error(enforcement.reason ?? 'Edit blocked by worktree enforcement', enforcement.errorCode ?? ErrorCodes.WORKTREE_ENFORCEMENT_BLOCKED);
+        }
         const args = [
-            '--path',
+            CliArgs.PATH,
             input.path,
             '--old-string',
             input.old_string,
@@ -554,12 +833,29 @@ export const fileEditTool = {
             args.push(CliArgs.ENCODING, input.encoding);
         if (input.replace_all)
             args.push('--replace-all');
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('file:edit', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'File edited' });
+        const execution = await executeViaPack(CliCommands.FILE_EDIT, {
+            path: input.path,
+            old_string: input.old_string,
+            new_string: input.new_string,
+            encoding: input.encoding,
+            replace_all: input.replace_all,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.FILE_EDIT,
+                args,
+                errorCode: ErrorCodes.FILE_EDIT_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'file:edit failed', ErrorCodes.FILE_EDIT_ERROR);
+        return success(unwrapExecuteViaPackData(execution.data));
     },
 };
 /**
@@ -573,17 +869,32 @@ export const fileDeleteTool = {
         if (!input.path) {
             return error(ErrorMessages.PATH_REQUIRED, ErrorCodes.MISSING_PARAMETER);
         }
-        const args = ['--path', input.path];
+        const args = [CliArgs.PATH, input.path];
         if (input.recursive)
             args.push('--recursive');
         if (input.force)
-            args.push('--force');
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('file:delete', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'Delete complete' });
+            args.push(CliArgs.FORCE);
+        const execution = await executeViaPack(CliCommands.FILE_DELETE, {
+            path: input.path,
+            recursive: input.recursive,
+            force: input.force,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.FILE_DELETE,
+                args,
+                errorCode: ErrorCodes.FILE_DELETE_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'file:delete failed', ErrorCodes.FILE_DELETE_ERROR);
+        return success(unwrapExecuteViaPackData(execution.data));
     },
 };
 /**
@@ -594,6 +905,7 @@ export const gitStatusTool = {
     description: 'Show git status with optional porcelain/short modes',
     inputSchema: gitStatusSchema,
     async execute(input, options) {
+        const runtimeProjectRoot = resolveRuntimeProjectRoot(input.base_dir, options?.projectRoot);
         const args = [];
         if (input.base_dir)
             args.push(CliArgs.BASE_DIR, input.base_dir);
@@ -603,12 +915,33 @@ export const gitStatusTool = {
             args.push('--short');
         if (input.path)
             args.push(input.path);
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('git:status', args, cliOptions);
-        if (result.success) {
-            return success({ output: result.stdout });
+        const gitCommandArgs = ['status'];
+        if (input.porcelain)
+            gitCommandArgs.push('--porcelain');
+        if (input.short)
+            gitCommandArgs.push('--short');
+        if (input.path)
+            gitCommandArgs.push(input.path);
+        const execution = await executeViaPack(GIT_RUNTIME_TOOL_NAME, {
+            commands: [[GIT_BINARY, ...gitCommandArgs]],
+        }, {
+            projectRoot: runtimeProjectRoot,
+            contextInput: {
+                metadata: {
+                    [RUNTIME_PROJECT_ROOT_KEY]: runtimeProjectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.GIT_STATUS,
+                args,
+                errorCode: ErrorCodes.GIT_STATUS_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'git:status failed', ErrorCodes.GIT_STATUS_ERROR);
+        const runtimeData = unwrapExecuteViaPackData(execution.data);
+        return success({ output: extractGitOutput(runtimeData) });
     },
 };
 /**
@@ -619,6 +952,7 @@ export const gitDiffTool = {
     description: 'Show git diff with staged/name-only/stat modes',
     inputSchema: gitDiffSchema,
     async execute(input, options) {
+        const runtimeProjectRoot = resolveRuntimeProjectRoot(input.base_dir, options?.projectRoot);
         const args = [];
         if (input.base_dir)
             args.push(CliArgs.BASE_DIR, input.base_dir);
@@ -632,12 +966,37 @@ export const gitDiffTool = {
             args.push(input.ref);
         if (input.path)
             args.push('--', input.path);
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('git:diff', args, cliOptions);
-        if (result.success) {
-            return success({ output: result.stdout });
+        const gitCommandArgs = ['diff'];
+        if (input.staged)
+            gitCommandArgs.push('--staged');
+        if (input.name_only)
+            gitCommandArgs.push('--name-only');
+        if (input.stat)
+            gitCommandArgs.push('--stat');
+        if (input.ref)
+            gitCommandArgs.push(input.ref);
+        if (input.path)
+            gitCommandArgs.push('--', input.path);
+        const execution = await executeViaPack(GIT_RUNTIME_TOOL_NAME, {
+            commands: [[GIT_BINARY, ...gitCommandArgs]],
+        }, {
+            projectRoot: runtimeProjectRoot,
+            contextInput: {
+                metadata: {
+                    [RUNTIME_PROJECT_ROOT_KEY]: runtimeProjectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.GIT_DIFF,
+                args,
+                errorCode: ErrorCodes.GIT_DIFF_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'git:diff failed', ErrorCodes.GIT_DIFF_ERROR);
+        const runtimeData = unwrapExecuteViaPackData(execution.data);
+        return success({ output: extractGitOutput(runtimeData) });
     },
 };
 /**
@@ -648,6 +1007,7 @@ export const gitLogTool = {
     description: 'Show git commit log with filters',
     inputSchema: gitLogSchema,
     async execute(input, options) {
+        const runtimeProjectRoot = resolveRuntimeProjectRoot(input.base_dir, options?.projectRoot);
         const args = [];
         if (input.base_dir)
             args.push(CliArgs.BASE_DIR, input.base_dir);
@@ -656,19 +1016,46 @@ export const gitLogTool = {
         if (input.max_count !== undefined)
             args.push('-n', String(input.max_count));
         if (input.format)
-            args.push('--format', input.format);
+            args.push(CliArgs.FORMAT, input.format);
         if (input.since)
-            args.push('--since', input.since);
+            args.push(CliArgs.SINCE, input.since);
         if (input.author)
             args.push('--author', input.author);
         if (input.ref)
             args.push(input.ref);
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('git:log', args, cliOptions);
-        if (result.success) {
-            return success({ output: result.stdout });
+        const gitCommandArgs = ['log'];
+        if (input.oneline)
+            gitCommandArgs.push('--oneline');
+        if (input.max_count !== undefined)
+            gitCommandArgs.push('-n', String(input.max_count));
+        if (input.format)
+            gitCommandArgs.push(CliArgs.FORMAT, input.format);
+        if (input.since)
+            gitCommandArgs.push(CliArgs.SINCE, input.since);
+        if (input.author)
+            gitCommandArgs.push('--author', input.author);
+        if (input.ref)
+            gitCommandArgs.push(input.ref);
+        const execution = await executeViaPack(GIT_RUNTIME_TOOL_NAME, {
+            commands: [[GIT_BINARY, ...gitCommandArgs]],
+        }, {
+            projectRoot: runtimeProjectRoot,
+            contextInput: {
+                metadata: {
+                    [RUNTIME_PROJECT_ROOT_KEY]: runtimeProjectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.GIT_LOG,
+                args,
+                errorCode: ErrorCodes.GIT_LOG_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'git:log failed', ErrorCodes.GIT_LOG_ERROR);
+        const runtimeData = unwrapExecuteViaPackData(execution.data);
+        return success({ output: extractGitOutput(runtimeData) });
     },
 };
 /**
@@ -679,6 +1066,7 @@ export const gitBranchTool = {
     description: 'Show git branch listing and current branch',
     inputSchema: gitBranchSchema,
     async execute(input, options) {
+        const runtimeProjectRoot = resolveRuntimeProjectRoot(input.base_dir, options?.projectRoot);
         const args = [];
         if (input.base_dir)
             args.push(CliArgs.BASE_DIR, input.base_dir);
@@ -692,12 +1080,37 @@ export const gitBranchTool = {
             args.push('--show-current');
         if (input.contains)
             args.push('--contains', input.contains);
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('git:branch', args, cliOptions);
-        if (result.success) {
-            return success({ output: result.stdout });
+        const gitCommandArgs = ['branch'];
+        if (input.list)
+            gitCommandArgs.push('--list');
+        if (input.all)
+            gitCommandArgs.push('--all');
+        if (input.remotes)
+            gitCommandArgs.push('--remotes');
+        if (input.show_current)
+            gitCommandArgs.push('--show-current');
+        if (input.contains)
+            gitCommandArgs.push('--contains', input.contains);
+        const execution = await executeViaPack(GIT_RUNTIME_TOOL_NAME, {
+            commands: [[GIT_BINARY, ...gitCommandArgs]],
+        }, {
+            projectRoot: runtimeProjectRoot,
+            contextInput: {
+                metadata: {
+                    [RUNTIME_PROJECT_ROOT_KEY]: runtimeProjectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.GIT_BRANCH,
+                args,
+                errorCode: ErrorCodes.GIT_BRANCH_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'git:branch failed', ErrorCodes.GIT_BRANCH_ERROR);
+        const runtimeData = unwrapExecuteViaPackData(execution.data);
+        return success({ output: extractGitOutput(runtimeData) });
     },
 };
 /**
@@ -719,12 +1132,22 @@ export const initPlanTool = {
             args.push('--plan', input.plan);
         if (input.create)
             args.push('--create');
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('init:plan', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'Plan linked' });
-        }
-        return error(result.stderr || result.error?.message || 'init:plan failed', ErrorCodes.INIT_PLAN_ERROR);
+        const execution = await executeViaPack(CliCommands.INIT_PLAN, input, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.INIT_PLAN,
+                args,
+                errorCode: ErrorCodes.INIT_PLAN_ERROR,
+            },
+        });
+        return execution.success
+            ? success(unwrapExecuteViaPackData(execution.data))
+            : error(execution.error?.message ?? 'init:plan failed', ErrorCodes.INIT_PLAN_ERROR);
     },
 };
 /**
@@ -741,13 +1164,27 @@ export const planCreateTool = {
         if (!input.title) {
             return error(ErrorMessages.TITLE_REQUIRED, ErrorCodes.MISSING_PARAMETER);
         }
-        const args = ['--id', input.id, '--title', input.title];
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('plan:create', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'Plan created' });
+        const args = [CliArgs.ID, input.id, '--title', input.title];
+        const execution = await executeViaPack(CliCommands.PLAN_CREATE, {
+            id: input.id,
+            title: input.title,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.PLAN_CREATE,
+                args,
+                errorCode: ErrorCodes.PLAN_CREATE_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'plan:create failed', ErrorCodes.PLAN_CREATE_ERROR);
+        return success(unwrapExecuteViaPackData(execution.data));
     },
 };
 /**
@@ -767,17 +1204,33 @@ export const planEditTool = {
         if (!input.content && !input.append) {
             return error(ErrorMessages.CONTENT_REQUIRED, ErrorCodes.MISSING_PARAMETER);
         }
-        const args = ['--id', input.id, '--section', input.section];
+        const args = [CliArgs.ID, input.id, '--section', input.section];
         if (input.content)
             args.push('--content', input.content);
         if (input.append)
             args.push('--append', input.append);
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('plan:edit', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'Plan edited' });
+        const execution = await executeViaPack(CliCommands.PLAN_EDIT, {
+            id: input.id,
+            section: input.section,
+            content: input.content,
+            append: input.append,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.PLAN_EDIT,
+                args,
+                errorCode: ErrorCodes.PLAN_EDIT_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'plan:edit failed', ErrorCodes.PLAN_EDIT_ERROR);
+        return success(unwrapExecuteViaPackData(execution.data));
     },
 };
 /**
@@ -794,13 +1247,27 @@ export const planLinkTool = {
         if (!input.plan) {
             return error(ErrorMessages.PLAN_REQUIRED, ErrorCodes.MISSING_PARAMETER);
         }
-        const args = ['--id', input.id, '--plan', input.plan];
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('plan:link', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'Plan linked' });
+        const args = [CliArgs.ID, input.id, '--plan', input.plan];
+        const execution = await executeViaPack(CliCommands.PLAN_LINK, {
+            id: input.id,
+            plan: input.plan,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.PLAN_LINK,
+                args,
+                errorCode: ErrorCodes.PLAN_LINK_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'plan:link failed', ErrorCodes.PLAN_LINK_ERROR);
+        return success(unwrapExecuteViaPackData(execution.data));
     },
 };
 /**
@@ -814,15 +1281,29 @@ export const planPromoteTool = {
         if (!input.id) {
             return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
         }
-        const args = ['--id', input.id];
+        const args = [CliArgs.ID, input.id];
         if (input.force)
-            args.push('--force');
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('plan:promote', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'Plan promoted' });
+            args.push(CliArgs.FORCE);
+        const execution = await executeViaPack(CliCommands.PLAN_PROMOTE, {
+            id: input.id,
+            force: input.force,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.PLAN_PROMOTE,
+                args,
+                errorCode: ErrorCodes.PLAN_PROMOTE_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
         }
-        return error(result.stderr || result.error?.message || 'plan:promote failed', ErrorCodes.PLAN_PROMOTE_ERROR);
+        return success(unwrapExecuteViaPackData(execution.data));
     },
 };
 /**
@@ -843,17 +1324,108 @@ export const signalCleanupTool = {
         if (input.max_entries !== undefined)
             args.push('--max-entries', String(input.max_entries));
         if (input.json)
-            args.push('--json');
+            args.push(CliArgs.JSON);
         if (input.quiet)
-            args.push('--quiet');
+            args.push(CliArgs.QUIET);
         if (input.base_dir)
             args.push(CliArgs.BASE_DIR, input.base_dir);
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('signal:cleanup', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'Signal cleanup complete' });
+        const execution = await executeViaPack(CliCommands.SIGNAL_CLEANUP, {
+            dry_run: input.dry_run,
+            ttl: input.ttl,
+            unread_ttl: input.unread_ttl,
+            max_entries: input.max_entries,
+            json: input.json,
+            quiet: input.quiet,
+            base_dir: input.base_dir,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.SIGNAL_CLEANUP,
+                args,
+                errorCode: ErrorCodes.SIGNAL_CLEANUP_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
+        }
+        return success(unwrapExecuteViaPackData(execution.data));
+    },
+};
+/**
+ * config_set - Safely update .lumenflow.config.yaml via micro-worktree
+ * WU-1902: config:set MCP parity tool
+ */
+export const configSetTool = {
+    name: 'config_set',
+    description: 'Safely update .lumenflow.config.yaml via micro-worktree',
+    inputSchema: configSetSchema,
+    async execute(input, options) {
+        if (!input.key) {
+            return error(ErrorMessages.KEY_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        if (input.value === undefined) {
+            return error(ErrorMessages.VALUE_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = ['--key', input.key, '--value', input.value];
+        const execution = await executeViaPack(CliCommands.CONFIG_SET, {
+            key: input.key,
+            value: input.value,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.CONFIG_SET,
+                args,
+                errorCode: ErrorCodes.CONFIG_SET_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
+        }
+        return success(unwrapExecuteViaPackData(execution.data));
+    },
+};
+/**
+ * config_get - Read and display a value from .lumenflow.config.yaml
+ * WU-1902: config:get MCP parity tool
+ */
+export const configGetTool = {
+    name: 'config_get',
+    description: 'Read and display a value from .lumenflow.config.yaml',
+    inputSchema: configGetSchema,
+    async execute(input, options) {
+        if (!input.key) {
+            return error(ErrorMessages.KEY_REQUIRED, ErrorCodes.MISSING_PARAMETER);
         }
-        return error(result.stderr || result.error?.message || 'signal:cleanup failed', ErrorCodes.SIGNAL_CLEANUP_ERROR);
+        const args = ['--key', input.key];
+        const execution = await executeViaPack(CliCommands.CONFIG_GET, {
+            key: input.key,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.CONFIG_GET,
+                args,
+                errorCode: ErrorCodes.CONFIG_GET_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
+        }
+        return success(unwrapExecuteViaPackData(execution.data));
     },
 };
 /**
@@ -870,7 +1442,7 @@ export const wuProtoTool = {
         if (!input.title) {
             return error(ErrorMessages.TITLE_REQUIRED, ErrorCodes.MISSING_PARAMETER);
         }
-        const args = ['--lane', input.lane, '--title', input.title];
+        const args = [CliArgs.LANE, input.lane, '--title', input.title];
         if (input.description)
             args.push(CliArgs.DESCRIPTION, input.description);
         if (Array.isArray(input.code_paths)) {
@@ -883,12 +1455,23 @@ export const wuProtoTool = {
         }
         if (input.assigned_to)
             args.push('--assigned-to', input.assigned_to);
-        const cliOptions = { projectRoot: options?.projectRoot };
-        const result = await runCliCommand('wu:proto', args, cliOptions);
-        if (result.success) {
-            return success({ message: result.stdout || 'Prototype WU created' });
+        const execution = await executeViaPack(CliCommands.WU_PROTO, input, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.WU_PROTO,
+                args,
+                errorCode: ErrorCodes.WU_PROTO_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return error(execution.error?.message ?? 'wu:proto failed', ErrorCodes.WU_PROTO_ERROR);
         }
-        return error(result.stderr || result.error?.message || 'wu:proto failed', ErrorCodes.WU_PROTO_ERROR);
+        return success(execution.data ?? { message: 'Prototype WU created' });
     },
 };
 //# sourceMappingURL=parity-tools.js.map