@lumenflow/mcp 3.1.2 → 3.1.3

package/dist/tools/parity-tools.js

@@ -1,1479 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: AGPL-3.0-only
-/**
- * @file parity-tools.ts
- * @description Wave-1 and Wave-2 public parity tool implementations
- *
- * WU-1642: Extracted from tools.ts during domain decomposition.
- * 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, 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(),
-    dry_run: z.boolean().optional(),
-    stale_days_in_progress: z.number().optional(),
-    stale_days_ready: z.number().optional(),
-    archive_days: z.number().optional(),
-});
-const docsSyncMcpSchema = z.object({
-    vendor: z.enum(['claude', 'cursor', 'aider', 'all', 'none']).optional(),
-    force: z.boolean().optional(),
-});
-const laneHealthSchema = z.object({
-    json: z.boolean().optional(),
-    verbose: z.boolean().optional(),
-    no_coverage: z.boolean().optional(),
-});
-const laneSuggestSchema = z.object({
-    dry_run: z.boolean().optional(),
-    interactive: z.boolean().optional(),
-    output: z.string().optional(),
-    json: z.boolean().optional(),
-    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(),
-    force: z.boolean().optional(),
-    wu_dir: z.string().optional(),
-    state_dir: z.string().optional(),
-});
-const stateCleanupSchema = z.object({
-    dry_run: z.boolean().optional(),
-    signals_only: z.boolean().optional(),
-    memory_only: z.boolean().optional(),
-    events_only: z.boolean().optional(),
-    json: z.boolean().optional(),
-    quiet: z.boolean().optional(),
-    base_dir: z.string().optional(),
-});
-const stateDoctorSchema = z.object({
-    fix: z.boolean().optional(),
-    dry_run: z.boolean().optional(),
-    json: z.boolean().optional(),
-    quiet: z.boolean().optional(),
-    base_dir: z.string().optional(),
-});
-const syncTemplatesMcpSchema = z.object({
-    dry_run: z.boolean().optional(),
-    verbose: z.boolean().optional(),
-    check_drift: z.boolean().optional(),
-});
-// WU-1483: Schemas for wave-2 parity commands not yet modeled in @lumenflow/core
-const fileReadSchema = z.object({
-    path: z.string().optional(),
-    encoding: z.string().optional(),
-    start_line: z.number().optional(),
-    end_line: z.number().optional(),
-    max_size: z.number().optional(),
-});
-const fileWriteSchema = z.object({
-    path: z.string().optional(),
-    content: z.string().optional(),
-    encoding: z.string().optional(),
-    no_create_dirs: z.boolean().optional(),
-});
-const fileEditSchema = z.object({
-    path: z.string().optional(),
-    old_string: z.string().optional(),
-    new_string: z.string().optional(),
-    encoding: z.string().optional(),
-    replace_all: z.boolean().optional(),
-});
-const fileDeleteSchema = z.object({
-    path: z.string().optional(),
-    recursive: z.boolean().optional(),
-    force: z.boolean().optional(),
-});
-const gitStatusSchema = z.object({
-    base_dir: z.string().optional(),
-    path: z.string().optional(),
-    porcelain: z.boolean().optional(),
-    short: z.boolean().optional(),
-});
-const gitDiffSchema = z.object({
-    base_dir: z.string().optional(),
-    ref: z.string().optional(),
-    staged: z.boolean().optional(),
-    name_only: z.boolean().optional(),
-    stat: z.boolean().optional(),
-    path: z.string().optional(),
-});
-const gitLogSchema = z.object({
-    base_dir: z.string().optional(),
-    ref: z.string().optional(),
-    oneline: z.boolean().optional(),
-    max_count: z.number().optional(),
-    format: z.string().optional(),
-    since: z.string().optional(),
-    author: z.string().optional(),
-});
-const gitBranchSchema = z.object({
-    base_dir: z.string().optional(),
-    list: z.boolean().optional(),
-    all: z.boolean().optional(),
-    remotes: z.boolean().optional(),
-    show_current: z.boolean().optional(),
-    contains: z.string().optional(),
-});
-const planCreateSchema = z.object({
-    id: z.string().optional(),
-    title: z.string().optional(),
-});
-const planEditSchema = z.object({
-    id: z.string().optional(),
-    section: z.string().optional(),
-    content: z.string().optional(),
-    append: z.string().optional(),
-});
-const planLinkSchema = z.object({
-    id: z.string().optional(),
-    plan: z.string().optional(),
-});
-const planPromoteSchema = z.object({
-    id: z.string().optional(),
-    force: z.boolean().optional(),
-});
-const signalCleanupSchema = z.object({
-    dry_run: z.boolean().optional(),
-    ttl: z.string().optional(),
-    unread_ttl: z.string().optional(),
-    max_entries: z.number().optional(),
-    json: z.boolean().optional(),
-    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(),
-    description: z.string().optional(),
-    code_paths: z.array(z.string()).optional(),
-    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)
-// ============================================================================
-/**
- * backlog_prune - Clean stale backlog entries
- */
-export const backlogPruneTool = {
-    name: 'backlog_prune',
-    description: 'Clean stale backlog entries and archive old completed WUs',
-    inputSchema: backlogPruneSchema,
-    async execute(input, options) {
-        const args = [];
-        if (input.execute)
-            args.push(CliArgs.EXECUTE);
-        if (input.dry_run)
-            args.push('--dry-run');
-        if (input.stale_days_in_progress !== undefined) {
-            args.push('--stale-days-in-progress', String(input.stale_days_in_progress));
-        }
-        if (input.stale_days_ready !== undefined) {
-            args.push('--stale-days-ready', String(input.stale_days_ready));
-        }
-        if (input.archive_days !== undefined) {
-            args.push('--archive-days', String(input.archive_days));
-        }
-        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 success(unwrapExecuteViaPackData(execution.data));
-    },
-};
-/**
- * docs_sync - Sync agent docs to existing project
- */
-export const docsSyncTool = {
-    name: 'docs_sync',
-    description: 'Sync agent onboarding docs and skills to existing projects',
-    inputSchema: docsSyncMcpSchema,
-    async execute(input, options) {
-        const args = [];
-        if (input.vendor)
-            args.push('--vendor', input.vendor);
-        if (input.force)
-            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 success(unwrapExecuteViaPackData(execution.data));
-    },
-};
-/**
- * gates - Public gates command
- */
-export const gatesTool = {
-    name: 'gates',
-    description: 'Run LumenFlow quality gates',
-    inputSchema: gatesSchema,
-    async execute(input, options) {
-        const args = buildGatesArgs(input);
-        const result = await executeViaPack(CliCommands.GATES, input, {
-            projectRoot: options?.projectRoot,
-            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);
-    },
-};
-/**
- * gates_docs - Public docs-only gates alias
- */
-export const gatesDocsTool = {
-    name: 'gates_docs',
-    description: 'Run docs-only quality gates',
-    inputSchema: gatesSchema,
-    async execute(input, options) {
-        const args = buildGatesArgs(input, { forceDocsOnly: true });
-        const result = await executeViaPack(CliCommands.GATES, input, {
-            projectRoot: options?.projectRoot,
-            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',
-    description: 'Check lane configuration health (overlaps and coverage gaps)',
-    inputSchema: laneHealthSchema,
-    async execute(input, options) {
-        const args = [];
-        if (input.json)
-            args.push(CliArgs.JSON);
-        if (input.verbose)
-            args.push(CliArgs.VERBOSE);
-        if (input.no_coverage)
-            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',
-    description: 'Generate lane suggestions from codebase context',
-    inputSchema: laneSuggestSchema,
-    async execute(input, options) {
-        const args = [];
-        if (input.dry_run)
-            args.push(LaneFlags.DRY_RUN);
-        if (input.interactive)
-            args.push(LaneFlags.INTERACTIVE);
-        if (input.output)
-            args.push(LaneFlags.OUTPUT, input.output);
-        if (input.json)
-            args.push(CliArgs.JSON);
-        if (input.no_llm)
-            args.push(LaneFlags.NO_LLM);
-        if (input.include_git)
-            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);
-    },
-};
-/**
- * lumenflow - Public initializer command
- */
-export const lumenflowTool = {
-    name: 'lumenflow',
-    description: 'Initialize LumenFlow in a project',
-    inputSchema: lumenflowInitSchema,
-    async execute(input, options) {
-        const args = [];
-        if (input.client)
-            args.push('--client', input.client);
-        if (input.merge)
-            args.push('--merge');
-        if (input.full)
-            args.push('--full');
-        if (input.minimal)
-            args.push('--minimal');
-        if (input.framework)
-            args.push('--framework', input.framework);
-        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 success(unwrapExecuteViaPackData(execution.data));
-    },
-};
-/**
- * lumenflow_gates - Public gates alias
- */
-export const lumenflowGatesTool = {
-    name: 'lumenflow_gates',
-    description: 'Run quality gates (lumenflow-gates alias)',
-    inputSchema: gatesSchema,
-    async execute(input, options) {
-        const args = buildGatesArgs(input);
-        const result = await executeViaPack(CliCommands.GATES, input, {
-            projectRoot: options?.projectRoot,
-            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);
-    },
-};
-/**
- * state_bootstrap - Bootstrap event store from WU YAMLs
- */
-export const stateBootstrapTool = {
-    name: 'state_bootstrap',
-    description: 'Bootstrap state store from existing WU YAML files',
-    inputSchema: stateBootstrapSchema,
-    async execute(input, options) {
-        const args = [];
-        if (input.execute)
-            args.push(CliArgs.EXECUTE);
-        if (input.dry_run)
-            args.push('--dry-run');
-        if (input.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 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 success(unwrapExecuteViaPackData(execution.data));
-    },
-};
-/**
- * state_cleanup - Run unified state cleanup
- */
-export const stateCleanupTool = {
-    name: 'state_cleanup',
-    description: 'Clean stale state, memory, and signal data',
-    inputSchema: stateCleanupSchema,
-    async execute(input, options) {
-        const args = [];
-        if (input.dry_run)
-            args.push('--dry-run');
-        if (input.signals_only)
-            args.push('--signals-only');
-        if (input.memory_only)
-            args.push('--memory-only');
-        if (input.events_only)
-            args.push('--events-only');
-        if (input.json)
-            args.push(CliArgs.JSON);
-        if (input.quiet)
-            args.push(CliArgs.QUIET);
-        if (input.base_dir)
-            args.push(CliArgs.BASE_DIR, input.base_dir);
-        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 success(unwrapExecuteViaPackData(execution.data));
-    },
-};
-/**
- * state_doctor - Diagnose and repair state issues
- */
-export const stateDoctorTool = {
-    name: 'state_doctor',
-    description: 'Diagnose state store integrity issues',
-    inputSchema: stateDoctorSchema,
-    async execute(input, options) {
-        const args = [];
-        if (input.fix)
-            args.push('--fix');
-        if (input.dry_run)
-            args.push('--dry-run');
-        if (input.json)
-            args.push(CliArgs.JSON);
-        if (input.quiet)
-            args.push(CliArgs.QUIET);
-        if (input.base_dir)
-            args.push(CliArgs.BASE_DIR, input.base_dir);
-        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 success(unwrapExecuteViaPackData(execution.data));
-    },
-};
-/**
- * sync_templates - Sync templates from source docs
- */
-export const syncTemplatesTool = {
-    name: 'sync_templates',
-    description: 'Sync internal docs to CLI templates',
-    inputSchema: syncTemplatesMcpSchema,
-    async execute(input, options) {
-        const args = [];
-        if (input.dry_run)
-            args.push('--dry-run');
-        if (input.verbose)
-            args.push(CliArgs.VERBOSE);
-        if (input.check_drift)
-            args.push('--check-drift');
-        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 success(unwrapExecuteViaPackData(execution.data));
-    },
-};
-// ============================================================================
-// Wave-2 Public Parity Operations (WU-1483)
-// ============================================================================
-/**
- * file_read - Read file content with audit trail
- */
-export const fileReadTool = {
-    name: 'file_read',
-    description: 'Read a file with optional line ranges and encoding',
-    inputSchema: fileReadSchema,
-    async execute(input, options) {
-        if (!input.path) {
-            return error(ErrorMessages.PATH_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        const args = [CliArgs.PATH, input.path];
-        if (input.encoding)
-            args.push(CliArgs.ENCODING, input.encoding);
-        if (input.start_line !== undefined)
-            args.push('--start-line', String(input.start_line));
-        if (input.end_line !== undefined)
-            args.push('--end-line', String(input.end_line));
-        if (input.max_size !== undefined)
-            args.push('--max-size', String(input.max_size));
-        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 success(unwrapExecuteViaPackData(execution.data));
-    },
-};
-/**
- * file_write - Write file content with audit trail
- */
-export const fileWriteTool = {
-    name: 'file_write',
-    description: 'Write content to a file with audit trail',
-    inputSchema: fileWriteSchema,
-    async execute(input, options) {
-        if (!input.path) {
-            return error(ErrorMessages.PATH_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        if (input.content === undefined) {
-            return error(ErrorMessages.CONTENT_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        // 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 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 success(unwrapExecuteViaPackData(execution.data));
-    },
-};
-/**
- * file_edit - Replace exact string matches in a file
- */
-export const fileEditTool = {
-    name: 'file_edit',
-    description: 'Edit a file via exact string replacement',
-    inputSchema: fileEditSchema,
-    async execute(input, options) {
-        if (!input.path) {
-            return error(ErrorMessages.PATH_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        if (!input.old_string) {
-            return error(ErrorMessages.OLD_STRING_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        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 = [
-            CliArgs.PATH,
-            input.path,
-            '--old-string',
-            input.old_string,
-            '--new-string',
-            input.new_string,
-        ];
-        if (input.encoding)
-            args.push(CliArgs.ENCODING, input.encoding);
-        if (input.replace_all)
-            args.push('--replace-all');
-        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 success(unwrapExecuteViaPackData(execution.data));
-    },
-};
-/**
- * file_delete - Delete file or directory with audit trail
- */
-export const fileDeleteTool = {
-    name: 'file_delete',
-    description: 'Delete files or directories with safety flags',
-    inputSchema: fileDeleteSchema,
-    async execute(input, options) {
-        if (!input.path) {
-            return error(ErrorMessages.PATH_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        const args = [CliArgs.PATH, input.path];
-        if (input.recursive)
-            args.push('--recursive');
-        if (input.force)
-            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 success(unwrapExecuteViaPackData(execution.data));
-    },
-};
-/**
- * git_status - Show git status
- */
-export const gitStatusTool = {
-    name: 'git_status',
-    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);
-        if (input.porcelain)
-            args.push('--porcelain');
-        if (input.short)
-            args.push('--short');
-        if (input.path)
-            args.push(input.path);
-        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;
-        }
-        const runtimeData = unwrapExecuteViaPackData(execution.data);
-        return success({ output: extractGitOutput(runtimeData) });
-    },
-};
-/**
- * git_diff - Show git diff
- */
-export const gitDiffTool = {
-    name: 'git_diff',
-    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);
-        if (input.staged)
-            args.push('--staged');
-        if (input.name_only)
-            args.push('--name-only');
-        if (input.stat)
-            args.push('--stat');
-        if (input.ref)
-            args.push(input.ref);
-        if (input.path)
-            args.push('--', input.path);
-        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;
-        }
-        const runtimeData = unwrapExecuteViaPackData(execution.data);
-        return success({ output: extractGitOutput(runtimeData) });
-    },
-};
-/**
- * git_log - Show commit history
- */
-export const gitLogTool = {
-    name: 'git_log',
-    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);
-        if (input.oneline)
-            args.push('--oneline');
-        if (input.max_count !== undefined)
-            args.push('-n', String(input.max_count));
-        if (input.format)
-            args.push(CliArgs.FORMAT, input.format);
-        if (input.since)
-            args.push(CliArgs.SINCE, input.since);
-        if (input.author)
-            args.push('--author', input.author);
-        if (input.ref)
-            args.push(input.ref);
-        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;
-        }
-        const runtimeData = unwrapExecuteViaPackData(execution.data);
-        return success({ output: extractGitOutput(runtimeData) });
-    },
-};
-/**
- * git_branch - Show branch information
- */
-export const gitBranchTool = {
-    name: 'git_branch',
-    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);
-        if (input.list)
-            args.push('--list');
-        if (input.all)
-            args.push('--all');
-        if (input.remotes)
-            args.push('--remotes');
-        if (input.show_current)
-            args.push('--show-current');
-        if (input.contains)
-            args.push('--contains', input.contains);
-        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;
-        }
-        const runtimeData = unwrapExecuteViaPackData(execution.data);
-        return success({ output: extractGitOutput(runtimeData) });
-    },
-};
-/**
- * init_plan - Link plan to initiative (alias)
- */
-export const initPlanTool = {
-    name: 'init_plan',
-    description: 'Link or create a plan for an initiative',
-    inputSchema: initiativePlanSchema,
-    async execute(input, options) {
-        if (!input.initiative) {
-            return error(SharedErrorMessages.INITIATIVE_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        if (!input.plan && !input.create) {
-            return error(ErrorMessages.PLAN_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        const args = ['--initiative', input.initiative];
-        if (input.plan)
-            args.push('--plan', input.plan);
-        if (input.create)
-            args.push('--create');
-        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);
-    },
-};
-/**
- * plan_create - Create a plan file
- */
-export const planCreateTool = {
-    name: 'plan_create',
-    description: 'Create a new plan for a WU or initiative',
-    inputSchema: planCreateSchema,
-    async execute(input, options) {
-        if (!input.id) {
-            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        if (!input.title) {
-            return error(ErrorMessages.TITLE_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        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 success(unwrapExecuteViaPackData(execution.data));
-    },
-};
-/**
- * plan_edit - Edit an existing plan section
- */
-export const planEditTool = {
-    name: 'plan_edit',
-    description: 'Edit or append content to a plan section',
-    inputSchema: planEditSchema,
-    async execute(input, options) {
-        if (!input.id) {
-            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        if (!input.section) {
-            return error(ErrorMessages.SECTION_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        if (!input.content && !input.append) {
-            return error(ErrorMessages.CONTENT_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        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 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 success(unwrapExecuteViaPackData(execution.data));
-    },
-};
-/**
- * plan_link - Link plan URI to WU/initiative
- */
-export const planLinkTool = {
-    name: 'plan_link',
-    description: 'Link an existing plan URI to a WU or initiative',
-    inputSchema: planLinkSchema,
-    async execute(input, options) {
-        if (!input.id) {
-            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        if (!input.plan) {
-            return error(ErrorMessages.PLAN_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        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 success(unwrapExecuteViaPackData(execution.data));
-    },
-};
-/**
- * plan_promote - Promote plan to approved status
- */
-export const planPromoteTool = {
-    name: 'plan_promote',
-    description: 'Promote plan from draft to approved status',
-    inputSchema: planPromoteSchema,
-    async execute(input, options) {
-        if (!input.id) {
-            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        const args = [CliArgs.ID, input.id];
-        if (input.force)
-            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 success(unwrapExecuteViaPackData(execution.data));
-    },
-};
-/**
- * signal_cleanup - Clean stale signals
- */
-export const signalCleanupTool = {
-    name: 'signal_cleanup',
-    description: 'Cleanup stale signals using TTL policy',
-    inputSchema: signalCleanupSchema,
-    async execute(input, options) {
-        const args = [];
-        if (input.dry_run)
-            args.push('--dry-run');
-        if (input.ttl)
-            args.push('--ttl', input.ttl);
-        if (input.unread_ttl)
-            args.push('--unread-ttl', input.unread_ttl);
-        if (input.max_entries !== undefined)
-            args.push('--max-entries', String(input.max_entries));
-        if (input.json)
-            args.push(CliArgs.JSON);
-        if (input.quiet)
-            args.push(CliArgs.QUIET);
-        if (input.base_dir)
-            args.push(CliArgs.BASE_DIR, input.base_dir);
-        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);
-        }
-        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));
-    },
-};
-/**
- * wu_proto - Create and claim a prototype WU
- */
-export const wuProtoTool = {
-    name: 'wu_proto',
-    description: 'Create and claim a prototype WU with relaxed validation',
-    inputSchema: wuProtoSchema,
-    async execute(input, options) {
-        if (!input.lane) {
-            return error(ErrorMessages.LANE_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        if (!input.title) {
-            return error(ErrorMessages.TITLE_REQUIRED, ErrorCodes.MISSING_PARAMETER);
-        }
-        const args = [CliArgs.LANE, input.lane, '--title', input.title];
-        if (input.description)
-            args.push(CliArgs.DESCRIPTION, input.description);
-        if (Array.isArray(input.code_paths)) {
-            for (const codePath of input.code_paths) {
-                args.push(CliArgs.CODE_PATHS, String(codePath));
-            }
-        }
-        if (Array.isArray(input.labels) && input.labels.length > 0) {
-            args.push('--labels', input.labels.join(','));
-        }
-        if (input.assigned_to)
-            args.push('--assigned-to', input.assigned_to);
-        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 success(execution.data ?? { message: 'Prototype WU created' });
-    },
-};
-//# sourceMappingURL=parity-tools.js.map