@lumenflow/mcp 2.18.3 → 2.20.0

package/dist/tools/wu-tools.js

@@ -0,0 +1,768 @@
+/**
+ * @file wu-tools.ts
+ * @description WU lifecycle tool implementations (create, claim, done, block, edit, etc.)
+ *
+ * WU-1642: Extracted from tools.ts during domain decomposition.
+ * WU-1412: Core WU tools: wu_status, wu_create, wu_claim, wu_done, gates_run
+ * WU-1422: Additional WU tools
+ * WU-1431: Uses shared Zod schemas from @lumenflow/core for CLI/MCP parity
+ * WU-1454: All 16 WU lifecycle commands now use shared schemas
+ */
+import { z } from 'zod';
+import { wuCreateSchema, wuClaimSchema, wuStatusSchema, wuDoneSchema, gatesSchema, 
+// WU-1454: Lifecycle command schemas
+wuBlockSchema, wuUnblockSchema, wuEditSchema, wuReleaseSchema, wuRecoverSchema, wuRepairSchema, wuDepsSchema, wuPrepSchema, wuPreflightSchema, wuPruneSchema, wuDeleteSchema, wuCleanupSchema, wuSpawnSchema, wuValidateSchema, wuInferLaneSchema, wuUnlockLaneSchema, } from '@lumenflow/core';
+import { ErrorCodes, ErrorMessages, CliArgs, SuccessMessages, getCore, success, error, buildWuPromptArgs, runCliCommand, } from '../tools-shared.js';
+/**
+ * wu_status - Get status of a specific WU
+ * Uses CLI shell-out for consistency
+ *
+ * WU-1431: Uses shared wuStatusSchema for parity with CLI
+ * Note: CLI allows id to be optional (auto-detect from worktree), but MCP requires it
+ * since there's no "current directory" concept for MCP clients
+ */
+export const wuStatusTool = {
+    name: 'wu_status',
+    description: 'Get detailed status of a specific Work Unit',
+    // WU-1431: Extend shared schema to require id for MCP (CLI allows optional for auto-detect)
+    inputSchema: wuStatusSchema.extend({
+        id: z.string().describe('WU ID (e.g., WU-1412)'),
+    }),
+    async execute(input, options) {
+        if (!input.id) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = ['--id', input.id, '--json'];
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:status', args, cliOptions);
+        if (result.success) {
+            try {
+                const data = JSON.parse(result.stdout);
+                return success(data);
+            }
+            catch {
+                return success({ message: result.stdout });
+            }
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:status failed', ErrorCodes.WU_STATUS_ERROR);
+        }
+    },
+};
+/**
+ * wu_create - Create a new WU
+ *
+ * WU-1431: Uses shared wuCreateSchema for CLI/MCP parity
+ */
+export const wuCreateTool = {
+    name: 'wu_create',
+    description: 'Create a new Work Unit specification',
+    // WU-1431: Use shared schema - CLI-only aliases are not exposed here
+    inputSchema: wuCreateSchema,
+    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 = ['--lane', input.lane, '--title', input.title];
+        if (input.id)
+            args.push('--id', input.id);
+        if (input.description)
+            args.push(CliArgs.DESCRIPTION, input.description);
+        if (input.acceptance) {
+            for (const criterion of input.acceptance) {
+                args.push('--acceptance', criterion);
+            }
+        }
+        if (input.code_paths) {
+            for (const p of input.code_paths) {
+                args.push(CliArgs.CODE_PATHS, p);
+            }
+        }
+        if (input.exposure)
+            args.push('--exposure', input.exposure);
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:create', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'WU created successfully' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:create failed', ErrorCodes.WU_CREATE_ERROR);
+        }
+    },
+};
+/**
+ * wu_claim - Claim a WU and create worktree
+ *
+ * WU-1431: Uses shared wuClaimSchema for CLI/MCP parity
+ * WU-1491: Supports --cloud, --branch-only, and --pr-mode passthrough
+ */
+const wuClaimToolSchema = wuClaimSchema.extend({
+    sandbox: z
+        .boolean()
+        .optional()
+        .describe('Launch post-claim session through wu:sandbox (requires sandbox_command in MCP)'),
+    sandbox_command: z
+        .array(z.string())
+        .optional()
+        .describe('Command argv to run with --sandbox (e.g., ["node", "-v"])'),
+});
+export const wuClaimTool = {
+    name: 'wu_claim',
+    description: 'Claim a Work Unit and create worktree for implementation',
+    // WU-1431: Extend shared schema with MCP-safe sandbox launch controls
+    inputSchema: wuClaimToolSchema,
+    async execute(input, options) {
+        if (!input.id) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        if (!input.lane) {
+            return error(ErrorMessages.LANE_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = ['--id', input.id, '--lane', input.lane];
+        // WU-1491: Pass mode flags through to CLI
+        if (input.cloud)
+            args.push('--cloud');
+        if (input.branch_only)
+            args.push('--branch-only');
+        if (input.pr_mode)
+            args.push('--pr-mode');
+        if (input.sandbox) {
+            const sandboxCommand = Array.isArray(input.sandbox_command)
+                ? input.sandbox_command
+                : [];
+            if (sandboxCommand.length === 0) {
+                return error('sandbox_command is required when sandbox=true for MCP execution', ErrorCodes.MISSING_PARAMETER);
+            }
+            args.push('--sandbox', '--', ...sandboxCommand);
+        }
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:claim', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'WU claimed successfully' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:claim failed', ErrorCodes.WU_CLAIM_ERROR);
+        }
+    },
+};
+/**
+ * wu_sandbox - Execute a command through the sandbox backend for this platform
+ */
+const wuSandboxSchema = z.object({
+    id: z.string().describe('WU ID (e.g., WU-1687)'),
+    worktree: z.string().optional().describe('Optional worktree path override'),
+    command: z
+        .array(z.string())
+        .min(1)
+        .describe('Command argv to execute (e.g., ["node", "-e", "process.exit(0)"])'),
+});
+export const wuSandboxTool = {
+    name: 'wu_sandbox',
+    description: 'Run a command through the hardened WU sandbox backend',
+    inputSchema: wuSandboxSchema,
+    async execute(input, options) {
+        if (!input.id) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const command = Array.isArray(input.command) ? input.command : [];
+        if (command.length === 0) {
+            return error('command is required', ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = ['--id', input.id];
+        if (input.worktree) {
+            args.push('--worktree', input.worktree);
+        }
+        args.push('--', ...command);
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:sandbox', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'WU sandbox command completed successfully' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:sandbox failed', ErrorCodes.WU_CLAIM_ERROR);
+        }
+    },
+};
+/**
+ * wu_done - Complete a WU (must be run from main checkout)
+ *
+ * WU-1431: Uses shared wuDoneSchema for CLI/MCP parity
+ */
+export const wuDoneTool = {
+    name: 'wu_done',
+    description: 'Complete a Work Unit (merge, stamp, cleanup). MUST be run from main checkout.',
+    // WU-1431: Use shared schema
+    inputSchema: wuDoneSchema,
+    async execute(input, options) {
+        if (!input.id) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        // Fail fast if not on main checkout (AC: wu_done fails fast if not on main checkout)
+        try {
+            const core = await getCore();
+            const context = await core.computeWuContext({
+                cwd: options?.projectRoot,
+            });
+            if (context.location.type === 'worktree') {
+                return error('wu_done must be run from main checkout, not from a worktree. ' +
+                    'Run "pnpm wu:prep" first from the worktree, then cd to main and run wu:done.', ErrorCodes.WRONG_LOCATION);
+            }
+        }
+        catch {
+            // If we can't determine context, proceed anyway - CLI will validate
+        }
+        const args = ['--id', input.id];
+        if (input.skip_gates) {
+            args.push('--skip-gates');
+            if (input.reason)
+                args.push('--reason', input.reason);
+            if (input.fix_wu)
+                args.push('--fix-wu', input.fix_wu);
+        }
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:done', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'WU completed successfully' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:done failed', ErrorCodes.WU_DONE_ERROR);
+        }
+    },
+};
+/**
+ * gates_run - Run quality gates
+ *
+ * WU-1431: Uses shared gatesSchema for CLI/MCP parity
+ */
+export const gatesRunTool = {
+    name: 'gates_run',
+    description: 'Run LumenFlow quality gates (lint, typecheck, tests)',
+    // WU-1431: Use shared schema
+    inputSchema: gatesSchema,
+    async execute(input, options) {
+        const args = [];
+        if (input.docs_only) {
+            args.push(CliArgs.DOCS_ONLY);
+        }
+        const cliOptions = {
+            projectRoot: options?.projectRoot,
+            timeout: 600000, // 10 minutes for gates
+        };
+        const result = await runCliCommand('gates', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || SuccessMessages.ALL_GATES_PASSED });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'Gates failed', ErrorCodes.GATES_ERROR);
+        }
+    },
+};
+/**
+ * wu_block - Block a WU and move it to blocked status
+ */
+export const wuBlockTool = {
+    name: 'wu_block',
+    description: 'Block a Work Unit and move it from in_progress to blocked status',
+    // WU-1454: Use shared schema
+    inputSchema: wuBlockSchema,
+    async execute(input, options) {
+        if (!input.id) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        if (!input.reason) {
+            return error(ErrorMessages.REASON_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = ['--id', input.id, '--reason', input.reason];
+        if (input.remove_worktree) {
+            args.push('--remove-worktree');
+        }
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:block', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'WU blocked successfully' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:block failed', ErrorCodes.WU_BLOCK_ERROR);
+        }
+    },
+};
+/**
+ * wu_unblock - Unblock a WU and move it back to in_progress status
+ */
+export const wuUnblockTool = {
+    name: 'wu_unblock',
+    description: 'Unblock a Work Unit and move it from blocked to in_progress status',
+    // WU-1454: Use shared schema
+    inputSchema: wuUnblockSchema,
+    async execute(input, options) {
+        if (!input.id) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = ['--id', input.id];
+        if (input.reason)
+            args.push('--reason', input.reason);
+        if (input.create_worktree)
+            args.push('--create-worktree');
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:unblock', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'WU unblocked successfully' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:unblock failed', ErrorCodes.WU_UNBLOCK_ERROR);
+        }
+    },
+};
+/**
+ * wu_edit - Edit WU spec fields
+ */
+export const wuEditTool = {
+    name: 'wu_edit',
+    description: 'Edit Work Unit spec fields with micro-worktree isolation',
+    // WU-1454: Use shared schema
+    inputSchema: wuEditSchema,
+    async execute(input, options) {
+        if (!input.id) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = ['--id', input.id];
+        if (input.description)
+            args.push(CliArgs.DESCRIPTION, input.description);
+        if (input.acceptance) {
+            for (const criterion of input.acceptance) {
+                args.push('--acceptance', criterion);
+            }
+        }
+        if (input.notes)
+            args.push('--notes', input.notes);
+        if (input.code_paths) {
+            for (const p of input.code_paths) {
+                args.push(CliArgs.CODE_PATHS, p);
+            }
+        }
+        if (input.lane)
+            args.push('--lane', input.lane);
+        if (input.priority)
+            args.push('--priority', input.priority);
+        if (input.initiative)
+            args.push(CliArgs.INITIATIVE, input.initiative);
+        if (input.phase)
+            args.push(CliArgs.PHASE, String(input.phase));
+        if (input.no_strict)
+            args.push('--no-strict');
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:edit', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'WU edited successfully' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:edit failed', ErrorCodes.WU_EDIT_ERROR);
+        }
+    },
+};
+/**
+ * wu_release - Release an orphaned WU from in_progress to ready status
+ */
+export const wuReleaseTool = {
+    name: 'wu_release',
+    description: 'Release an orphaned WU from in_progress back to ready state for reclaiming',
+    // WU-1454: Use shared schema
+    inputSchema: wuReleaseSchema,
+    async execute(input, options) {
+        if (!input.id) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = ['--id', input.id];
+        if (input.reason)
+            args.push('--reason', input.reason);
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:release', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'WU released successfully' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:release failed', ErrorCodes.WU_RELEASE_ERROR);
+        }
+    },
+};
+/**
+ * wu_recover - Analyze and fix WU state inconsistencies
+ */
+export const wuRecoverTool = {
+    name: 'wu_recover',
+    description: 'Analyze and fix WU state inconsistencies',
+    // WU-1454: Use shared schema
+    inputSchema: wuRecoverSchema,
+    async execute(input, options) {
+        if (!input.id) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = ['--id', input.id];
+        if (input.action)
+            args.push('--action', input.action);
+        if (input.force)
+            args.push('--force');
+        if (input.json)
+            args.push(CliArgs.JSON);
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:recover', args, cliOptions);
+        if (result.success) {
+            try {
+                const data = JSON.parse(result.stdout);
+                return success(data);
+            }
+            catch {
+                return success({ message: result.stdout || 'WU recovered successfully' });
+            }
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:recover failed', ErrorCodes.WU_RECOVER_ERROR);
+        }
+    },
+};
+/**
+ * wu_repair - Unified WU repair tool for state issues
+ */
+export const wuRepairTool = {
+    name: 'wu_repair',
+    description: 'Unified WU repair tool - detect and fix WU state issues',
+    // WU-1454: Use shared schema
+    inputSchema: wuRepairSchema,
+    async execute(input, options) {
+        const args = [];
+        if (input.id)
+            args.push('--id', input.id);
+        if (input.check)
+            args.push('--check');
+        if (input.all)
+            args.push('--all');
+        if (input.claim)
+            args.push('--claim');
+        if (input.admin)
+            args.push('--admin');
+        if (input.repair_state)
+            args.push('--repair-state');
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:repair', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'WU repair completed' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:repair failed', ErrorCodes.WU_REPAIR_ERROR);
+        }
+    },
+};
+/**
+ * wu_deps - Visualize WU dependency graph
+ */
+export const wuDepsTool = {
+    name: 'wu_deps',
+    description: 'Visualize WU dependency graph',
+    // WU-1454: Use shared schema
+    inputSchema: wuDepsSchema,
+    async execute(input, options) {
+        if (!input.id) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = ['--id', input.id];
+        if (input.format)
+            args.push('--format', input.format);
+        if (input.depth)
+            args.push('--depth', String(input.depth));
+        if (input.direction)
+            args.push('--direction', input.direction);
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:deps', args, cliOptions);
+        if (result.success) {
+            try {
+                const data = JSON.parse(result.stdout);
+                return success(data);
+            }
+            catch {
+                return success({ message: result.stdout });
+            }
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:deps failed', ErrorCodes.WU_DEPS_ERROR);
+        }
+    },
+};
+/**
+ * wu_prep - Prepare WU for completion (run gates in worktree)
+ */
+export const wuPrepTool = {
+    name: 'wu_prep',
+    description: 'Prepare WU for completion by running gates in worktree',
+    // WU-1454: Use shared schema
+    inputSchema: wuPrepSchema,
+    async execute(input, options) {
+        if (!input.id) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = ['--id', input.id];
+        if (input.docs_only)
+            args.push(CliArgs.DOCS_ONLY);
+        if (input.full_tests)
+            args.push('--full-tests');
+        const cliOptions = {
+            projectRoot: options?.projectRoot,
+            timeout: 600000, // 10 minutes for gates
+        };
+        const result = await runCliCommand('wu:prep', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'WU prep completed' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:prep failed', ErrorCodes.WU_PREP_ERROR);
+        }
+    },
+};
+/**
+ * wu_preflight - Fast validation before gates run
+ */
+export const wuPreflightTool = {
+    name: 'wu_preflight',
+    description: 'Fast validation of code_paths and test paths before gates run (under 5 seconds vs 2+ minutes)',
+    // WU-1454: Use shared schema
+    inputSchema: wuPreflightSchema,
+    async execute(input, options) {
+        if (!input.id) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = ['--id', input.id];
+        if (input.worktree)
+            args.push('--worktree', input.worktree);
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:preflight', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'Preflight checks passed' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:preflight failed', ErrorCodes.WU_PREFLIGHT_ERROR);
+        }
+    },
+};
+/**
+ * wu_prune - Clean stale worktrees
+ */
+export const wuPruneTool = {
+    name: 'wu_prune',
+    description: 'Clean stale worktrees (dry-run by default)',
+    // WU-1454: Use shared schema
+    inputSchema: wuPruneSchema,
+    async execute(input, options) {
+        const args = [];
+        if (input.execute)
+            args.push('--execute');
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:prune', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'Prune completed' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:prune failed', ErrorCodes.WU_PRUNE_ERROR);
+        }
+    },
+};
+/**
+ * wu_delete - Safely delete WU YAML files
+ */
+export const wuDeleteTool = {
+    name: 'wu_delete',
+    description: 'Safely delete WU YAML files with micro-worktree isolation',
+    // WU-1454: Use shared schema
+    inputSchema: wuDeleteSchema,
+    async execute(input, options) {
+        if (!input.id && !input.batch) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = [];
+        if (input.id)
+            args.push('--id', input.id);
+        if (input.dry_run)
+            args.push(CliArgs.DRY_RUN);
+        if (input.batch)
+            args.push('--batch', input.batch);
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:delete', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'WU deleted' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:delete failed', ErrorCodes.WU_DELETE_ERROR);
+        }
+    },
+};
+/**
+ * wu_cleanup - Clean up worktree and branch after PR merge
+ */
+export const wuCleanupTool = {
+    name: 'wu_cleanup',
+    description: 'Clean up worktree and branch after PR merge (PR-based completion workflow)',
+    // WU-1454: Use shared schema
+    inputSchema: wuCleanupSchema,
+    async execute(input, options) {
+        if (!input.id) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = ['--id', input.id];
+        if (input.artifacts)
+            args.push('--artifacts');
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:cleanup', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'Cleanup complete' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:cleanup failed', ErrorCodes.WU_CLEANUP_ERROR);
+        }
+    },
+};
+/**
+ * wu_brief - Generate handoff prompt for sub-agent WU execution (WU-1603)
+ *
+ * This is the canonical prompt-generation tool.
+ */
+export const wuBriefTool = {
+    name: 'wu_brief',
+    description: 'Generate handoff prompt for sub-agent WU execution',
+    // WU-1454: Use shared schema (same parameters as wu:delegate)
+    inputSchema: wuSpawnSchema,
+    async execute(input, options) {
+        if (!input.id) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = buildWuPromptArgs(input);
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:brief', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'Brief prompt generated' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:brief failed', ErrorCodes.WU_BRIEF_ERROR);
+        }
+    },
+};
+/**
+ * wu_delegate - Generate prompt and explicitly record delegation lineage intent
+ */
+export const wuDelegateTool = {
+    name: 'wu_delegate',
+    description: 'Generate delegation prompt and record explicit lineage intent',
+    inputSchema: wuSpawnSchema,
+    async execute(input, options) {
+        if (!input.id) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        if (!input.parent_wu) {
+            return error(ErrorMessages.PARENT_WU_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = buildWuPromptArgs(input);
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:delegate', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'Delegation prompt generated' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:delegate failed', ErrorCodes.WU_DELEGATE_ERROR);
+        }
+    },
+};
+/**
+ * wu_validate - Validate WU YAML files
+ */
+export const wuValidateTool = {
+    name: 'wu_validate',
+    description: 'Validate WU YAML files against schema (strict mode by default)',
+    // WU-1454: Use shared schema
+    inputSchema: wuValidateSchema,
+    async execute(input, options) {
+        if (!input.id) {
+            return error(ErrorMessages.ID_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = ['--id', input.id];
+        if (input.no_strict)
+            args.push('--no-strict');
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:validate', args, cliOptions);
+        if (result.success) {
+            return success({ message: result.stdout || 'WU is valid' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:validate failed', ErrorCodes.WU_VALIDATE_ERROR);
+        }
+    },
+};
+/**
+ * wu_infer_lane - Suggest lane for a WU based on code paths and description
+ */
+export const wuInferLaneTool = {
+    name: 'wu_infer_lane',
+    description: 'Suggest lane for a WU based on code paths and description',
+    // WU-1454: Use shared schema
+    inputSchema: wuInferLaneSchema,
+    async execute(input, options) {
+        const args = [];
+        if (input.id)
+            args.push('--id', input.id);
+        if (input.paths) {
+            for (const p of input.paths) {
+                args.push('--paths', p);
+            }
+        }
+        if (input.desc)
+            args.push('--desc', input.desc);
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:infer-lane', args, cliOptions);
+        if (result.success) {
+            return success({ lane: result.stdout?.trim() || 'Unknown' });
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:infer-lane failed', ErrorCodes.WU_INFER_LANE_ERROR);
+        }
+    },
+};
+/**
+ * wu_unlock_lane - Safely unlock a lane lock with audit logging
+ */
+export const wuUnlockLaneTool = {
+    name: 'wu_unlock_lane',
+    description: 'Safely unlock a lane lock with audit logging',
+    // WU-1454: Use shared schema
+    inputSchema: wuUnlockLaneSchema,
+    async execute(input, options) {
+        // If list mode, no lane required
+        if (!input.list && !input.lane) {
+            return error(ErrorMessages.LANE_REQUIRED, ErrorCodes.MISSING_PARAMETER);
+        }
+        const args = [];
+        if (input.lane)
+            args.push('--lane', input.lane);
+        if (input.reason)
+            args.push('--reason', input.reason);
+        if (input.force)
+            args.push('--force');
+        if (input.list)
+            args.push('--list');
+        if (input.status)
+            args.push('--status');
+        const cliOptions = { projectRoot: options?.projectRoot };
+        const result = await runCliCommand('wu:unlock-lane', args, cliOptions);
+        if (result.success) {
+            try {
+                const data = JSON.parse(result.stdout);
+                return success(data);
+            }
+            catch {
+                return success({ message: result.stdout || 'Lane unlocked' });
+            }
+        }
+        else {
+            return error(result.stderr || result.error?.message || 'wu:unlock-lane failed', ErrorCodes.WU_UNLOCK_LANE_ERROR);
+        }
+    },
+};
+//# sourceMappingURL=wu-tools.js.map