@lumenflow/cli 2.1.2 → 2.2.1

package/dist/validate.d.ts

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+/**
+ * @file validate.ts
+ * @description Main WU YAML validator CLI (WU-1111)
+ *
+ * Validates WU tasks and status consistency. This is the replacement for
+ * tools/validate.js that was previously a stub.
+ *
+ * Usage:
+ *   validate                     # Validate all WUs
+ *   validate --id WU-123         # Validate specific WU
+ *   validate --strict            # Fail on warnings too
+ *   validate --done-only         # Only validate done WUs
+ *
+ * Exit codes:
+ *   0 - All validations passed
+ *   1 - Validation errors found
+ *
+ * @see {@link wu-validate.ts} - Detailed WU validation with schema
+ * @see {@link docs/04-operations/_frameworks/lumenflow/lumenflow-complete.md} - WU lifecycle
+ */
+/**
+ * Validation result for a single WU
+ */
+export interface ValidationResult {
+    valid: boolean;
+    warnings: string[];
+    errors: string[];
+}
+/**
+ * Validation summary for multiple WUs
+ */
+export interface ValidationSummary {
+    totalValid: number;
+    totalInvalid: number;
+    totalWarnings: number;
+    results: Array<{
+        wuId: string;
+    } & ValidationResult>;
+}
+/**
+ * Validate a single WU file
+ *
+ * @param wuPath - Path to WU YAML file
+ * @param options - Validation options
+ * @returns Validation result
+ */
+export declare function validateSingleWU(wuPath: string, options?: {
+    strict?: boolean;
+}): ValidationResult;
+/**
+ * Validate all WU files in the WU directory
+ *
+ * @param options - Validation options
+ * @returns Summary of all validations
+ */
+export declare function validateAllWUs(options?: {
+    strict?: boolean;
+    doneOnly?: boolean;
+}): ValidationSummary;

package/dist/wu-block.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+/**
+ * WU Block Helper
+ *
+ * Sequence (micro-worktree pattern):
+ * 1) Create micro-worktree from main
+ * 2) Auto-update WU YAML/backlog/status to Blocked in micro-worktree
+ * 3) Commit in micro-worktree, push directly to origin/main
+ * 4) Optionally remove work worktree (default: keep)
+ *
+ * Uses micro-worktree pattern to avoid pre-commit hook blocking commits to main.
+ *
+ * Usage:
+ *   pnpm wu:block --id WU-334 [--reason "Waiting on policy"] [--worktree ...] [--remove-worktree] [--no-auto]
+ */
+export {};

package/dist/wu-claim.d.ts

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * WU Claim Helper
+ *
+ * Canonical sequence:
+ * 1) Auto-update backlog/status/WU YAML (safe parsing) unless `--no-auto`
+ * 2) Commit and push to `main`
+ * 3) Create a dedicated worktree+branch for the WU
+ *
+ * Usage:
+ *   node tools/wu-claim.mjs --id WU-334 --lane Intelligence \
+ *     [--worktree worktrees/intelligence-wu-334] [--branch lane/intelligence/wu-334]
+ *
+ * WU-2542: This script imports utilities from @lumenflow/core package.
+ * Full migration to thin shim pending @lumenflow/core CLI export implementation.
+ */
+/**
+ * WU-1746: Get list of files to commit in worktree mode
+ * Excludes backlog.md and status.md to prevent merge conflicts.
+ * These generated files should only be updated on main during wu:done.
+ *
+ * @param {string} wuId - WU ID (e.g., 'WU-1746')
+ * @returns {string[]} List of files to commit
+ */
+export declare function getWorktreeCommitFiles(wuId: any): string[];
+/**
+ * WU-1047: Format Project Defaults section (agent-only).
+ *
+ * @param {object} methodology - Methodology defaults config
+ * @returns {string} Formatted output or empty string if disabled
+ */
+export declare function formatProjectDefaults(methodology: any): string;
+/**
+ * WU-1047: Print Project Defaults section (agent-only).
+ *
+ * @param {object} methodology - Methodology defaults config
+ */
+export declare function printProjectDefaults(methodology: any): void;
+/**
+ * WU-1763: Print a single concise tips line to improve tool adoption.
+ * Non-blocking, single-line output to avoid flooding the console.
+ *
+ * @param {string} _id - WU ID being claimed (unused, kept for future use)
+ */
+export declare function printLifecycleNudge(_id: any): void;
+/**
+ * WU-1029: Apply symlink fallback (root + nested node_modules) after install failure.
+ *
+ * @param {string} worktreePath - Worktree path
+ * @param {string} mainRepoPath - Main repo path
+ * @param {Console} logger - Logger (console-compatible)
+ */
+export declare function applyFallbackSymlinks(worktreePath: any, mainRepoPath: any, logger?: Console): {
+    symlinkResult: {
+        created: boolean;
+        skipped: boolean;
+        refused?: undefined;
+        reason?: undefined;
+        error?: undefined;
+    } | {
+        created: boolean;
+        skipped: boolean;
+        refused: boolean;
+        reason: string;
+        error?: undefined;
+    } | {
+        created: boolean;
+        skipped: boolean;
+        error: any;
+        refused?: undefined;
+        reason?: undefined;
+    };
+    nestedResult: any;
+};

package/dist/wu-cleanup.d.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+/**
+ * WU Cleanup Helper
+ *
+ * Cleans up worktree and branch after PR merge (PR-based completion workflow).
+ *
+ * Sequence:
+ * 1) Verify PR is merged (via gh API; no merge-base fallback)
+ * 2) Remove worktree (if exists)
+ * 3) Delete lane branch (local + remote)
+ *
+ * Idempotent: Safe no-op if already cleaned.
+ *
+ * Usage:
+ *   pnpm wu:cleanup --id WU-703
+ *   pnpm wu:cleanup --artifacts
+ */
+export declare const CLEANUP_GUARD_REASONS: {
+    UNCOMMITTED_CHANGES: string;
+    UNPUSHED_COMMITS: string;
+    STATUS_NOT_DONE: string;
+    MISSING_STAMP: string;
+    PR_NOT_MERGED: string;
+};
+export declare function evaluateCleanupGuards({ hasUncommittedChanges, hasUnpushedCommits, hasStamp, yamlStatus, ghAvailable, prMerged, }: {
+    hasUncommittedChanges: any;
+    hasUnpushedCommits: any;
+    hasStamp: any;
+    yamlStatus: any;
+    ghAvailable: any;
+    prMerged: any;
+}): {
+    allowed: boolean;
+    reason: string;
+};

package/dist/wu-cleanup.js

@@ -57,13 +57,22 @@ export function evaluateCleanupGuards({ hasUncommittedChanges, hasUnpushedCommit
     return { allowed: true, reason: null };
 }
 // Help text is now auto-generated by commander via createWUParser
-async function verifyPRMerged(laneBranch) {
+/**
+ * Verify if a PR for the given branch has been merged.
+ * WU-1141: Fixed to query closed/merged PRs by adding state=all parameter.
+ * The GitHub API /pulls endpoint returns only open PRs by default, so merged
+ * PRs were not being found, causing false "PR not merged" errors.
+ */
+export async function verifyPRMerged(laneBranch) {
     if (!isGhCliAvailable()) {
         return { merged: null, method: 'gh_unavailable' };
     }
     let ghResult;
     try {
-        ghResult = execSync(`gh api repos/:owner/:repo/pulls -q '.[] | select(.head.ref == "${laneBranch}") | .merged'`, { encoding: FILE_SYSTEM.UTF8 }).trim();
+        // WU-1141: Add state=all to include closed/merged PRs
+        // Without this parameter, the API only returns open PRs,
+        // causing merged PRs to not be found and verification to fail
+        ghResult = execSync(`gh api "repos/:owner/:repo/pulls?state=all" -q '.[] | select(.head.ref == "${laneBranch}") | .merged'`, { encoding: FILE_SYSTEM.UTF8 }).trim();
     }
     catch {
         ghResult = STRING_LITERALS.EMPTY;

package/dist/wu-create.d.ts

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * WU Create Helper (WU-1262, WU-1439)
+ *
+ * Race-safe WU creation using shared micro-worktree isolation.
+ *
+ * Canonical sequence:
+ * 1) Validate inputs (id, lane, title)
+ * 2) Ensure on main branch
+ * 3) Use withMicroWorktree() to atomically:
+ *    a) Create temp branch without switching main checkout
+ *    b) Create WU-{id}.yaml and update backlog.md in micro-worktree
+ *    c) Commit with "docs: create wu-{id} for <title>" message
+ *    d) Merge to main with ff-only (retry with rebase if needed)
+ *    e) Push to origin/main
+ *    f) Cleanup temp branch and micro-worktree
+ *
+ * Benefits:
+ * - Main checkout never switches branches (no impact on other agents)
+ * - Race conditions handled via rebase+retry (up to 3 attempts)
+ * - Cleanup guaranteed even on failure
+ *
+ * Usage:
+ *   pnpm wu:create --id WU-706 --lane Intelligence --title "Fix XYZ issue"
+ *
+ * Context: WU-705 (fix agent coordination failures), WU-1262 (micro-worktree isolation),
+ *          WU-1439 (refactor to shared helper)
+ */
+/**
+ * WU-2330: Check if a more specific sub-lane matches the provided inputs.
+ * Non-blocking - just logs a warning if a better lane is suggested.
+ *
+ * @param {string} providedLane - Lane provided by the user
+ * @param {string|undefined} codePathsRaw - Comma-separated code paths
+ * @param {string} title - WU title (used as fallback description)
+ * @param {string|undefined} description - WU description
+ */
+export declare function warnIfBetterLaneExists(providedLane: any, codePathsRaw: any, title: any, description: any): void;
+/** Options for creating WU YAML */
+interface CreateWUOptions {
+    initiative?: string;
+    phase?: string;
+    blockedBy?: string;
+    blocks?: string;
+    labels?: string;
+    assignedTo?: string;
+    description?: string;
+    acceptance?: string[];
+    codePaths?: string;
+    testPathsManual?: string;
+    testPathsUnit?: string;
+    testPathsE2e?: string;
+    exposure?: string;
+    userJourney?: string;
+    uiPairingWus?: string;
+    specRefs?: string;
+}
+export declare function validateCreateSpec({ id, lane, title, priority, type, opts, }: {
+    id: string;
+    lane: string;
+    title: string;
+    priority: string;
+    type: string;
+    opts: CreateWUOptions;
+}): {
+    valid: boolean;
+    errors: any[];
+};
+export {};

package/dist/wu-delete.d.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+/**
+ * WU Delete Helper
+ *
+ * Race-safe WU deletion using micro-worktree isolation.
+ *
+ * Uses micro-worktree pattern:
+ * 1) Validate inputs (WU exists, status is not in_progress)
+ * 2) Ensure main is clean and up-to-date with origin
+ * 3) Create temp branch WITHOUT switching (main checkout stays on main)
+ * 4) Create micro-worktree in /tmp pointing to temp branch
+ * 5) Delete WU file and update backlog.md in micro-worktree
+ * 6) Commit, ff-only merge, push
+ * 7) Cleanup temp branch and micro-worktree
+ *
+ * Usage:
+ *   pnpm wu:delete --id WU-123           # Single WU deletion
+ *   pnpm wu:delete --id WU-123 --dry-run # Dry run
+ *   pnpm wu:delete --batch WU-1,WU-2,WU-3 # Batch deletion
+ */
+export {};

package/dist/wu-deps.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * WU Dependency Visualization (WU-1247)
+ *
+ * Shows dependency graph for a WU in ASCII or Mermaid format.
+ *
+ * Usage:
+ *   pnpm wu:deps WU-1247                    # ASCII format
+ *   pnpm wu:deps WU-1247 --format mermaid   # Mermaid diagram
+ *   pnpm wu:deps WU-1247 --depth 5          # Deeper traversal
+ *   pnpm wu:deps WU-1247 --direction up     # Only upstream deps
+ */
+export {};

package/dist/wu-done.d.ts

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+/**
+ * WU Done Helper
+ *
+ * Canonical sequence (Worktree mode - DEFAULT):
+ * 1) Run gates in lane worktree (validates the change, not just main)
+ * 2) Pre-flight validation: run ALL pre-commit hooks before merge (prevents partial completion)
+ * 3) cd into worktree
+ * 4) Auto-update WU YAML/backlog/status to Done in worktree (unless --no-auto)
+ * 5) Create `.lumenflow/stamps/WU-{id}.done` in worktree
+ * 6) Validate staged files against whitelist
+ * 7) Commit metadata changes in worktree (on lane branch)
+ * 8) cd back to main
+ * 9) Merge lane branch to main with --ff-only (metadata + code merged atomically)
+ * 10) Push to `main`
+ * 11) Remove the associated worktree (unless --no-remove)
+ * 12) Optionally delete the lane branch (with --delete-branch)
+ * 13) Emit telemetry to .lumenflow/flow.log
+ *
+ * Canonical sequence (Branch-Only mode - LEGACY):
+ * 1) Run gates on lane branch (in main checkout)
+ * 2) Pre-flight validation
+ * 3) Merge lane branch to main
+ * 4) Update metadata on main
+ * 5) Commit and push
+ * 6) Delete lane branch
+ *
+ * Usage:
+ *   pnpm wu:done --id WU-334 [--worktree worktrees/intelligence-wu-334] [--no-auto] [--no-remove] [--no-merge] [--delete-branch]
+ *
+ * WU-2542: This script imports utilities from @lumenflow/core package.
+ * Full migration to thin shim pending @lumenflow/core CLI export implementation.
+ */
+/**
+ * WU-1999: Print exposure validation warnings.
+ *
+ * Validates exposure field and UI pairing for user-facing WUs.
+ * Non-blocking - logs warnings but doesn't prevent completion.
+ *
+ * Checks:
+ * - exposure field is present (warn if missing)
+ * - If exposure=api, warns if no ui_pairing_wus specified
+ * - If exposure=api, checks acceptance criteria for UI verification mention
+ * - If exposure=ui, recommends user_journey field if not present
+ *
+ * @param {object} wu - WU YAML document
+ * @param {object} options - Validation options
+ * @param {boolean} [options.skipExposureCheck=false] - Skip all exposure validation
+ * @returns {void}
+ */
+interface ExposureOptions {
+    skipExposureCheck?: boolean;
+}
+export declare function printExposureWarnings(wu: Record<string, unknown>, options?: ExposureOptions): void;
+/**
+ * WU-2022: Validate feature accessibility for UI-exposed WUs.
+ *
+ * BLOCKING validation - prevents wu:done if exposure=ui but feature is not accessible.
+ * This prevents "orphaned code" where UI features exist but users cannot navigate to them.
+ *
+ * Accessibility is verified by ANY of:
+ * 1. navigation_path field is specified (explicit route)
+ * 2. code_paths includes a page.tsx file (Next.js page)
+ * 3. tests.manual includes navigation/accessibility verification
+ *
+ * @param {object} wu - WU YAML document
+ * @param {object} options - Validation options
+ * @param {boolean} [options.skipAccessibilityCheck=false] - Skip accessibility validation
+ * @returns {void} Calls die() if validation fails
+ */
+interface AccessibilityOptions {
+    skipAccessibilityCheck?: boolean;
+}
+export declare function validateAccessibilityOrDie(wu: Record<string, unknown>, options?: AccessibilityOptions): void;
+/**
+ * WU-1012: Validate --docs-only flag usage.
+ *
+ * The --docs-only flag can only be used when the WU is documentation-focused:
+ * 1. exposure field is 'documentation'
+ * 2. OR all code_paths are documentation paths (docs/, ai/, .claude/, *.md)
+ * 3. OR type is 'documentation'
+ *
+ * @param {object} wu - WU YAML document
+ * @param {object} args - Parsed CLI arguments
+ * @param {boolean} args.docsOnly - Whether --docs-only flag was passed
+ * @returns {{ valid: boolean, errors: string[] }} Validation result
+ */
+interface DocsOnlyArgs {
+    docsOnly?: boolean;
+}
+export declare function validateDocsOnlyFlag(wu: Record<string, unknown>, args: DocsOnlyArgs): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * WU-1012: Build gates command with --docs-only flag support.
+ *
+ * Returns the appropriate gates command based on:
+ * - Explicit --docs-only flag from CLI
+ * - Auto-detected isDocsOnly from code_paths analysis
+ *
+ * @param {object} options - Build options
+ * @param {boolean} options.docsOnly - Explicit --docs-only flag from CLI
+ * @param {boolean} options.isDocsOnly - Auto-detected docs-only from code_paths
+ * @returns {string} Gates command string
+ */
+interface BuildGatesOptions {
+    docsOnly?: boolean;
+    isDocsOnly?: boolean;
+}
+export declare function buildGatesCommand(options: BuildGatesOptions): string;
+/**
+ * WU-1946: Update spawn registry on WU completion.
+ * Non-blocking wrapper - failures logged as warnings.
+ *
+ * When a WU is completed via wu:done, this function updates the spawn registry
+ * to mark the spawned entry as completed (if one exists). This allows orchestrators
+ * to track sub-agent spawn completion status.
+ *
+ * Gracefully skips if:
+ * - No spawn entry found for this WU (legacy WU created before registry)
+ * - Registry file doesn't exist
+ * - Any error during update
+ *
+ * @param {string} id - WU ID being completed
+ * @param {string} baseDir - Base directory containing .lumenflow/state/
+ * @returns {Promise<void>}
+ */
+export declare function updateSpawnRegistryOnCompletion(id: any, baseDir?: string): Promise<void>;
+/**
+ * WU-1234: Normalize username for ownership comparison
+ * Extracts username from email address for comparison.
+ * This allows tom@hellm.ai to match 'tom' assigned_to field.
+ *
+ * @param {string|null|undefined} value - Email address or username
+ * @returns {string} Normalized username (lowercase)
+ */
+export declare function normalizeUsername(value: any): string;
+/**
+ * WU-1234: Detect if branch is already merged to main
+ * Checks if branch tip is an ancestor of main HEAD (i.e., already merged).
+ * This prevents merge loops when code was merged via emergency fix or manual merge.
+ *
+ * @param {string} branch - Lane branch name
+ * @returns {Promise<boolean>} True if branch is already merged to main
+ */
+export declare function isBranchAlreadyMerged(branch: any): Promise<boolean>;
+export { shouldSkipWebTests as isDocsOnlyByPaths } from '@lumenflow/core/dist/path-classifiers.js';
+/**
+ * WU-1234: Pre-flight check for backlog state consistency
+ * Fails fast if the WU appears in both Done and In Progress sections.
+ *
+ * @param {string} id - WU ID to check
+ * @param {string} backlogPath - Path to backlog.md
+ * @returns {{ valid: boolean, error: string|null }}
+ */
+export declare function checkBacklogConsistencyForWU(id: any, backlogPath: any): {
+    valid: boolean;
+    error: string;
+};
+/**
+ * WU-1084: Check for uncommitted changes on main after merge completes.
+ *
+ * This catches cases where pnpm format (or other tooling) touched files
+ * outside the WU's code_paths during worktree work. These changes survive
+ * the merge and would be silently left behind when the worktree is removed.
+ *
+ * @param gitStatus - Output from git status (porcelain format)
+ * @param wuId - The WU ID for error messaging
+ * @returns Object with isDirty flag and optional error message
+ */
+export declare function checkPostMergeDirtyState(gitStatus: string, wuId: string): {
+    isDirty: boolean;
+    error?: string;
+};
+export declare function emitTelemetry(event: any): void;
+/**
+ * Print State HUD for visibility
+ * Extracted from main() to reduce complexity (WU-1215 Phase 2 Extraction #4)
+ * @param {object} params - Parameters
+ * @param {string} params.id - WU ID
+ * @param {object} params.docMain - Main WU YAML document
+ * @param {boolean} params.isBranchOnly - Whether in branch-only mode
+ * @param {boolean} params.isDocsOnly - Whether this is a docs-only WU
+ * @param {string|null} params.derivedWorktree - Derived worktree path
+ * @param {string} params.STAMPS_DIR - Stamps directory path
+ */
+export declare function computeBranchOnlyFallback({ isBranchOnly, branchOnlyRequested, worktreeExists, derivedWorktree, }: {
+    isBranchOnly: boolean;
+    branchOnlyRequested: boolean | undefined;
+    worktreeExists: boolean;
+    derivedWorktree: string | null;
+}): {
+    allowFallback: boolean;
+    effectiveBranchOnly: boolean;
+};
+/**
+ * WU-1983: Print migration deployment nudge when WU includes supabase changes.
+ * Notifies agent to deploy new migrations to production via MCP tools.
+ * Conditional output - only prints when migrations are in scope and new migrations exist.
+ *
+ * @param {string[]} codePaths - WU code_paths array
+ * @param {string} baseDir - Base directory for migration discovery
+ * @returns {Promise<void>}
+ */
+export declare function printMigrationDeploymentNudge(codePaths: any, baseDir: any): Promise<void>;
+/**
+ * WU-1763: Print discovery summary nudge when discoveries exist for this WU.
+ * Conditional output - only prints when discoveryCount > 0.
+ * Non-blocking, single-line output to avoid flooding the console.
+ *
+ * @param {string} id - WU ID being completed
+ * @param {number} discoveryCount - Number of open discoveries for this WU
+ * @param {string[]} discoveryIds - List of discovery IDs (limited to 5 in output)
+ */
+export declare function printDiscoveryNudge(id: any, discoveryCount: any, discoveryIds: any): void;
+/**
+ * WU-1763: Print documentation validation nudge when docs changed.
+ * Conditional output - only prints when changedDocPaths.length > 0.
+ * Non-blocking, single-line output to avoid flooding the console.
+ *
+ * @param {string} id - WU ID being completed
+ * @param {string[]} changedDocPaths - List of documentation paths that changed
+ */
+export declare function printDocValidationNudge(id: any, changedDocPaths: any): void;

package/dist/wu-done.js

@@ -1975,9 +1975,15 @@ async function main() {
     // This prevents partial completion states where merge succeeds but commit fails
     // Validates all 8 gates: secrets, file size, ESLint, Prettier, TypeScript, audit, architecture, tasks
     // WU-2308: Pass worktreePath to run audit from worktree (checks fixed deps, not stale main deps)
-    const hookResult = validateAllPreCommitHooks(id, worktreePath);
-    if (!hookResult.valid) {
-        die('Pre-flight validation failed. Fix hook issues and try again.');
+    // WU-1145: Skip pre-flight when skipGates is true (pre-flight runs gates which was already skipped)
+    if (!args.skipGates) {
+        const hookResult = validateAllPreCommitHooks(id, worktreePath);
+        if (!hookResult.valid) {
+            die('Pre-flight validation failed. Fix hook issues and try again.');
+        }
+    }
+    else {
+        console.log(`${LOG_PREFIX.DONE} Skipping pre-flight hook validation (--skip-gates)`);
     }
     // Step 0.6: WU-1781 - Run tasks:validate preflight BEFORE any merge/push operations
     // This prevents deadlocks where validation fails after merge, leaving local main ahead of origin

package/dist/wu-edit.d.ts

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+/**
+ * WU Edit Helper
+ *
+ * Race-safe WU spec editing using micro-worktree isolation (WU-1274).
+ *
+ * Enables editing WU YAML files without claiming the WU, perfect for:
+ * - Filling in placeholder content after wu:create
+ * - Updating description/acceptance criteria
+ * - Adding code_paths, notes, or other spec fields
+ *
+ * Uses the same micro-worktree pattern as wu:create (WU-1262):
+ * 1) Validate inputs (WU exists, status is ready)
+ * 2) Ensure main is clean and up-to-date with origin
+ * 3) Create temp branch WITHOUT switching (main checkout stays on main)
+ * 4) Create micro-worktree in /tmp pointing to temp branch
+ * 5) Apply edits in micro-worktree
+ * 6) Commit, ff-only merge, push
+ * 7) Cleanup temp branch and micro-worktree
+ *
+ * Usage:
+ *   pnpm wu:edit --id WU-123 --spec-file /path/to/spec.yaml
+ *   pnpm wu:edit --id WU-123 --description "New description text"
+ *   pnpm wu:edit --id WU-123 --acceptance "Criterion 1" --acceptance "Criterion 2"
+ *
+ * Part of WU-1274: Add wu:edit command for spec-only changes
+ * @see {@link tools/lib/micro-worktree.mjs} - Shared micro-worktree logic
+ */
+/**
+ * WU-1039: Validate which edits are allowed on done WUs
+ *
+ * Done WUs only allow metadata reassignment: initiative, phase, and exposure.
+ * All other edits are blocked to preserve WU immutability after completion.
+ *
+ * @param opts - Parsed CLI options
+ * @returns { valid: boolean, disallowedEdits: string[] }
+ */
+export declare function validateDoneWUEdits(opts: Record<string, unknown>): {
+    valid: boolean;
+    disallowedEdits: string[];
+};
+/**
+ * WU-1039: Validate exposure value against schema
+ *
+ * Uses WU_EXPOSURE_VALUES from core constants (Library-First, no magic strings).
+ *
+ * @param exposure - Exposure value to validate
+ * @returns { valid: boolean, error?: string }
+ */
+export declare function validateExposureValue(exposure: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * WU-1039: Apply exposure edit to WU object
+ *
+ * Returns a new WU object with updated exposure (immutable pattern).
+ *
+ * @param wu - Original WU object
+ * @param exposure - New exposure value
+ * @returns Updated WU object (does not mutate original)
+ */
+export declare function applyExposureEdit(wu: Record<string, unknown>, exposure: string): Record<string, unknown>;