@lumenflow/mcp 3.2.0 → 3.2.2

package/dist/tools/parity-tools.js

@@ -0,0 +1,1690 @@
+// 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 modular 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 cloudConnectSchema = z.object({
+    endpoint: z.string().optional(),
+    org_id: z.string().optional(),
+    project_id: z.string().optional(),
+    token_env: z.string().optional(),
+    policy_mode: z.enum(['authoritative', 'tighten-only', 'dev-override']).optional(),
+    sync_interval: z.number().int().positive().optional(),
+    output: z.string().optional(),
+    force: z.boolean().optional(),
+});
+const onboardSchema = z.object({
+    yes: z.boolean().optional(),
+    domain: z.enum(['software-delivery', 'infra', 'custom']).optional(),
+    project_name: z.string().optional(),
+    output: z.string().optional(),
+    force: z.boolean().optional(),
+    skip_pack_install: z.boolean().optional(),
+    skip_dashboard: z.boolean().optional(),
+});
+const workspaceInitSchema = z.object({
+    yes: z.boolean().optional(),
+    output: z.string().optional(),
+    force: z.boolean().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 BootstrapFlags = {
+    ENDPOINT: '--endpoint',
+    ORG_ID: '--org-id',
+    PROJECT_ID: '--project-id',
+    TOKEN_ENV: '--token-env',
+    POLICY_MODE: '--policy-mode',
+    SYNC_INTERVAL: '--sync-interval',
+    OUTPUT: '--output',
+    YES: '--yes',
+    DOMAIN: '--domain',
+    PROJECT_NAME: '--project-name',
+    SKIP_PACK_INSTALL: '--skip-pack-install',
+    SKIP_DASHBOARD: '--skip-dashboard',
+};
+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 workspace.yaml via micro-worktree
+ * WU-1902: config:set MCP parity tool
+ */
+export const configSetTool = {
+    name: 'config_set',
+    description: 'Safely update workspace.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 workspace.yaml
+ * WU-1902: config:get MCP parity tool
+ */
+export const configGetTool = {
+    name: 'config_get',
+    description: 'Read and display a value from workspace.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));
+    },
+};
+/**
+ * cloud_connect - Connect workspace.yaml to cloud control plane
+ */
+export const cloudConnectTool = {
+    name: 'cloud_connect',
+    description: 'Connect workspace.yaml to cloud control plane',
+    inputSchema: cloudConnectSchema,
+    async execute(input, options) {
+        if (!input.endpoint) {
+            return error(ErrorMessages.ENDPOINT_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        if (!input.org_id) {
+            return error(ErrorMessages.ORG_ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        if (!input.project_id) {
+            return error(ErrorMessages.PROJECT_ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = [
+            BootstrapFlags.ENDPOINT,
+            input.endpoint,
+            BootstrapFlags.ORG_ID,
+            input.org_id,
+            BootstrapFlags.PROJECT_ID,
+            input.project_id,
+        ];
+        if (input.token_env)
+            args.push(BootstrapFlags.TOKEN_ENV, input.token_env);
+        if (input.policy_mode)
+            args.push(BootstrapFlags.POLICY_MODE, input.policy_mode);
+        if (input.sync_interval !== undefined) {
+            args.push(BootstrapFlags.SYNC_INTERVAL, String(input.sync_interval));
+        }
+        if (input.output)
+            args.push(BootstrapFlags.OUTPUT, input.output);
+        if (input.force)
+            args.push(CliArgs.FORCE);
+        const execution = await executeViaPack(CliCommands.CLOUD_CONNECT, {
+            endpoint: input.endpoint,
+            org_id: input.org_id,
+            project_id: input.project_id,
+            token_env: input.token_env,
+            policy_mode: input.policy_mode,
+            sync_interval: input.sync_interval,
+            output: input.output,
+            force: input.force,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.CLOUD_CONNECT,
+                args,
+                errorCode: ErrorCodes.CLOUD_CONNECT_ERROR,
+            },
+        });
+        if (!execution.success) {
+            return execution;
+        }
+        return success(unwrapExecuteViaPackData(execution.data));
+    },
+};
+function buildOnboardArgs(input) {
+    const args = [];
+    if (input.yes)
+        args.push(BootstrapFlags.YES);
+    if (input.domain)
+        args.push(BootstrapFlags.DOMAIN, input.domain);
+    if (input.project_name)
+        args.push(BootstrapFlags.PROJECT_NAME, input.project_name);
+    if (input.output)
+        args.push(BootstrapFlags.OUTPUT, input.output);
+    if (input.force)
+        args.push(CliArgs.FORCE);
+    if (input.skip_pack_install)
+        args.push(BootstrapFlags.SKIP_PACK_INSTALL);
+    if (input.skip_dashboard)
+        args.push(BootstrapFlags.SKIP_DASHBOARD);
+    return args;
+}
+async function executeOnboardAlias(command, errorCode, input, options) {
+    return executeViaPack(command, {
+        yes: input.yes,
+        domain: input.domain,
+        project_name: input.project_name,
+        output: input.output,
+        force: input.force,
+        skip_pack_install: input.skip_pack_install,
+        skip_dashboard: input.skip_dashboard,
+    }, {
+        projectRoot: options?.projectRoot,
+        contextInput: {
+            metadata: {
+                [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+            },
+        },
+        fallback: {
+            command,
+            args: buildOnboardArgs(input),
+            errorCode,
+        },
+    });
+}
+/**
+ * onboard - Interactive setup wizard for LumenFlow workspace
+ */
+export const onboardTool = {
+    name: 'onboard',
+    description: 'Interactive setup wizard for LumenFlow workspace',
+    inputSchema: onboardSchema,
+    async execute(input, options) {
+        const execution = await executeOnboardAlias(CliCommands.ONBOARD, ErrorCodes.ONBOARD_ERROR, input, options);
+        if (!execution.success) {
+            return execution;
+        }
+        return success(unwrapExecuteViaPackData(execution.data));
+    },
+};
+/**
+ * lumenflow_onboard - Alias for onboard command
+ */
+export const lumenflowOnboardTool = {
+    name: 'lumenflow_onboard',
+    description: 'Interactive setup wizard for LumenFlow workspace (alias)',
+    inputSchema: onboardSchema,
+    async execute(input, options) {
+        const execution = await executeOnboardAlias(CliCommands.LUMENFLOW_ONBOARD, ErrorCodes.LUMENFLOW_ONBOARD_ERROR, input, options);
+        if (!execution.success) {
+            return execution;
+        }
+        return success(unwrapExecuteViaPackData(execution.data));
+    },
+};
+/**
+ * workspace_init - Initialize workspace.yaml via interactive prompts
+ */
+export const workspaceInitTool = {
+    name: 'workspace_init',
+    description: 'Initialize workspace.yaml from interactive prompts',
+    inputSchema: workspaceInitSchema,
+    async execute(input, options) {
+        const args = [];
+        if (input.yes)
+            args.push(BootstrapFlags.YES);
+        if (input.output)
+            args.push(BootstrapFlags.OUTPUT, input.output);
+        if (input.force)
+            args.push(CliArgs.FORCE);
+        const execution = await executeViaPack(CliCommands.WORKSPACE_INIT, {
+            yes: input.yes,
+            output: input.output,
+            force: input.force,
+        }, {
+            projectRoot: options?.projectRoot,
+            contextInput: {
+                metadata: {
+                    [MetadataKeys.PROJECT_ROOT]: options?.projectRoot,
+                },
+            },
+            fallback: {
+                command: CliCommands.WORKSPACE_INIT,
+                args,
+                errorCode: ErrorCodes.WORKSPACE_INIT_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