@lumenflow/core 1.4.0 → 1.6.0

package/dist/cycle-detector.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Cycle Detection Module (WU-1088)
+ *
+ * Provides cycle detection for WU dependency graphs.
+ * Extracted from @lumenflow/initiatives to break circular dependency.
+ *
+ * @module @lumenflow/core/cycle-detector
+ */
+/**
+ * WU object interface for validation and cycle detection
+ * Note: This interface is shared with @lumenflow/initiatives for backward compatibility
+ */
+export interface WUObject {
+    id?: string;
+    blocks?: string[];
+    blocked_by?: string[];
+    initiative?: string;
+    phase?: number;
+    [key: string]: unknown;
+}
+/**
+ * Result of cycle detection
+ */
+export interface CycleResult {
+    hasCycle: boolean;
+    cycles: string[][];
+}
+/**
+ * Detects circular dependencies in WU dependency graph using DFS
+ *
+ * Uses standard cycle detection: tracks visited nodes and nodes in current
+ * recursion stack. If we encounter a node already in the recursion stack,
+ * we've found a cycle.
+ *
+ * Note: This function treats both `blocks` and `blocked_by` as edges for
+ * traversal. This means if WU-A blocks WU-B, and WU-B's blocked_by includes
+ * WU-A, following both directions will find a path back to WU-A.
+ *
+ * @param wuMap - Map of WU ID to WU object
+ * @returns Cycle detection result with hasCycle boolean and cycles array
+ *
+ * @example
+ * const wuMap = new Map([
+ *   ['WU-001', { id: 'WU-001', blocks: ['WU-002'] }],
+ *   ['WU-002', { id: 'WU-002', blocks: ['WU-001'] }],
+ * ]);
+ * const result = detectCycles(wuMap);
+ * // result.hasCycle === true
+ * // result.cycles contains the cycle path
+ */
+export declare function detectCycles(wuMap: Map<string, WUObject>): CycleResult;

package/dist/cycle-detector.js

@@ -0,0 +1,89 @@
+/**
+ * Cycle Detection Module (WU-1088)
+ *
+ * Provides cycle detection for WU dependency graphs.
+ * Extracted from @lumenflow/initiatives to break circular dependency.
+ *
+ * @module @lumenflow/core/cycle-detector
+ */
+/**
+ * Detects circular dependencies in WU dependency graph using DFS
+ *
+ * Uses standard cycle detection: tracks visited nodes and nodes in current
+ * recursion stack. If we encounter a node already in the recursion stack,
+ * we've found a cycle.
+ *
+ * Note: This function treats both `blocks` and `blocked_by` as edges for
+ * traversal. This means if WU-A blocks WU-B, and WU-B's blocked_by includes
+ * WU-A, following both directions will find a path back to WU-A.
+ *
+ * @param wuMap - Map of WU ID to WU object
+ * @returns Cycle detection result with hasCycle boolean and cycles array
+ *
+ * @example
+ * const wuMap = new Map([
+ *   ['WU-001', { id: 'WU-001', blocks: ['WU-002'] }],
+ *   ['WU-002', { id: 'WU-002', blocks: ['WU-001'] }],
+ * ]);
+ * const result = detectCycles(wuMap);
+ * // result.hasCycle === true
+ * // result.cycles contains the cycle path
+ */
+export function detectCycles(wuMap) {
+    const visited = new Set();
+    const recursionStack = new Set();
+    const cycles = [];
+    /**
+     * DFS traversal to detect cycles
+     * @param wuId - Current WU ID
+     * @param path - Current path from root
+     * @returns True if cycle found
+     */
+    function dfs(wuId, path) {
+        // If node is in recursion stack, we found a cycle
+        if (recursionStack.has(wuId)) {
+            const cycleStart = path.indexOf(wuId);
+            if (cycleStart !== -1) {
+                cycles.push([...path.slice(cycleStart), wuId]);
+            }
+            else {
+                // Self-reference case
+                cycles.push([wuId, wuId]);
+            }
+            return true;
+        }
+        // If already fully visited, skip
+        if (visited.has(wuId)) {
+            return false;
+        }
+        // Mark as being processed
+        visited.add(wuId);
+        recursionStack.add(wuId);
+        // Get dependencies (both blocks and blocked_by create edges)
+        // Only use arrays - ignore legacy string format for backward compatibility
+        const wu = wuMap.get(wuId);
+        const blocks = Array.isArray(wu?.blocks) ? wu.blocks : [];
+        const blockedBy = Array.isArray(wu?.blocked_by) ? wu.blocked_by : [];
+        const deps = [...blocks, ...blockedBy];
+        // Visit all dependencies
+        for (const dep of deps) {
+            // Only traverse if the dependency exists in our map
+            if (wuMap.has(dep)) {
+                dfs(dep, [...path, wuId]);
+            }
+        }
+        // Remove from recursion stack (done processing)
+        recursionStack.delete(wuId);
+        return false;
+    }
+    // Run DFS from each node to find all cycles
+    for (const wuId of wuMap.keys()) {
+        if (!visited.has(wuId)) {
+            dfs(wuId, []);
+        }
+    }
+    return {
+        hasCycle: cycles.length > 0,
+        cycles,
+    };
+}

package/dist/dependency-graph.js

@@ -3,17 +3,7 @@ import path from 'node:path';
 import { readWU } from './wu-yaml.js';
 import { WU_PATHS } from './wu-paths.js';
 import { STRING_LITERALS, WU_STATUS } from './wu-constants.js';
-// Optional import from @lumenflow/initiatives - if not available, provide stub
-let detectCycles;
-try {
-    // Dynamic import for optional peer dependency
-    const module = await import('@lumenflow/initiatives');
-    detectCycles = module.detectCycles;
-}
-catch {
-    // Fallback stub if @lumenflow/initiatives is not available
-    detectCycles = () => ({ hasCycle: false, cycles: [] });
-}
+import { detectCycles } from './cycle-detector.js';
 /**
  * Dependency Graph Module (WU-1247, WU-1568)
  *

package/dist/domain/context.schemas.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Context Schemas
+ *
+ * WU-1093: INIT-002 Phase 1 - Define ports and domain schemas
+ *
+ * Zod schemas for context-related types in the context-aware validation system.
+ * Types are inferred from Zod schemas using z.infer<> for single source of truth.
+ *
+ * @module domain/context.schemas
+ */
+import { z } from 'zod';
+/**
+ * Location type enum values
+ *
+ * Mirrors CONTEXT_VALIDATION.LOCATION_TYPES from wu-constants.ts
+ */
+export declare const LOCATION_TYPE_VALUES: readonly ["main", "worktree", "detached", "unknown"];
+/**
+ * Schema for location types
+ */
+export declare const LocationTypeSchema: z.ZodEnum<{
+    unknown: "unknown";
+    main: "main";
+    worktree: "worktree";
+    detached: "detached";
+}>;
+/**
+ * Schema for location context
+ *
+ * Captures where the command is being run from and related paths.
+ */
+export declare const LocationContextSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        unknown: "unknown";
+        main: "main";
+        worktree: "worktree";
+        detached: "detached";
+    }>;
+    cwd: z.ZodString;
+    gitRoot: z.ZodString;
+    mainCheckout: z.ZodString;
+    worktreeName: z.ZodNullable<z.ZodString>;
+    worktreeWuId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Schema for git state
+ *
+ * Captures the current git state relevant to command execution.
+ */
+export declare const GitStateSchema: z.ZodObject<{
+    branch: z.ZodNullable<z.ZodString>;
+    isDetached: z.ZodBoolean;
+    isDirty: z.ZodBoolean;
+    hasStaged: z.ZodBoolean;
+    ahead: z.ZodNumber;
+    behind: z.ZodNumber;
+    tracking: z.ZodNullable<z.ZodString>;
+    modifiedFiles: z.ZodArray<z.ZodString>;
+    hasError: z.ZodBoolean;
+    errorMessage: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Schema for WU state result
+ *
+ * Result of reading WU state from YAML and state store.
+ */
+export declare const WuStateResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodString;
+    lane: z.ZodString;
+    title: z.ZodString;
+    yamlPath: z.ZodString;
+    isConsistent: z.ZodBoolean;
+    inconsistencyReason: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Schema for session state
+ *
+ * Session state for active WU work.
+ */
+export declare const SessionStateSchema: z.ZodObject<{
+    isActive: z.ZodBoolean;
+    sessionId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Schema for unified WU context
+ *
+ * Captures all environmental state relevant to command execution.
+ */
+export declare const WuContextSchema: z.ZodObject<{
+    location: z.ZodObject<{
+        type: z.ZodEnum<{
+            unknown: "unknown";
+            main: "main";
+            worktree: "worktree";
+            detached: "detached";
+        }>;
+        cwd: z.ZodString;
+        gitRoot: z.ZodString;
+        mainCheckout: z.ZodString;
+        worktreeName: z.ZodNullable<z.ZodString>;
+        worktreeWuId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    git: z.ZodObject<{
+        branch: z.ZodNullable<z.ZodString>;
+        isDetached: z.ZodBoolean;
+        isDirty: z.ZodBoolean;
+        hasStaged: z.ZodBoolean;
+        ahead: z.ZodNumber;
+        behind: z.ZodNumber;
+        tracking: z.ZodNullable<z.ZodString>;
+        modifiedFiles: z.ZodArray<z.ZodString>;
+        hasError: z.ZodBoolean;
+        errorMessage: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    wu: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodString;
+        lane: z.ZodString;
+        title: z.ZodString;
+        yamlPath: z.ZodString;
+        isConsistent: z.ZodBoolean;
+        inconsistencyReason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    session: z.ZodObject<{
+        isActive: z.ZodBoolean;
+        sessionId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    worktreeGit: z.ZodOptional<z.ZodObject<{
+        branch: z.ZodNullable<z.ZodString>;
+        isDetached: z.ZodBoolean;
+        isDirty: z.ZodBoolean;
+        hasStaged: z.ZodBoolean;
+        ahead: z.ZodNumber;
+        behind: z.ZodNumber;
+        tracking: z.ZodNullable<z.ZodString>;
+        modifiedFiles: z.ZodArray<z.ZodString>;
+        hasError: z.ZodBoolean;
+        errorMessage: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type LocationType = z.infer<typeof LocationTypeSchema>;
+export type LocationContext = z.infer<typeof LocationContextSchema>;
+export type GitState = z.infer<typeof GitStateSchema>;
+export type WuStateResult = z.infer<typeof WuStateResultSchema>;
+export type SessionState = z.infer<typeof SessionStateSchema>;
+export type WuContext = z.infer<typeof WuContextSchema>;

package/dist/domain/context.schemas.js

@@ -0,0 +1,126 @@
+/**
+ * Context Schemas
+ *
+ * WU-1093: INIT-002 Phase 1 - Define ports and domain schemas
+ *
+ * Zod schemas for context-related types in the context-aware validation system.
+ * Types are inferred from Zod schemas using z.infer<> for single source of truth.
+ *
+ * @module domain/context.schemas
+ */
+import { z } from 'zod';
+/**
+ * Location type enum values
+ *
+ * Mirrors CONTEXT_VALIDATION.LOCATION_TYPES from wu-constants.ts
+ */
+export const LOCATION_TYPE_VALUES = ['main', 'worktree', 'detached', 'unknown'];
+/**
+ * Schema for location types
+ */
+export const LocationTypeSchema = z.enum(LOCATION_TYPE_VALUES);
+/**
+ * Schema for location context
+ *
+ * Captures where the command is being run from and related paths.
+ */
+export const LocationContextSchema = z.object({
+    /** Location type: 'main', 'worktree', 'detached', or 'unknown' */
+    type: LocationTypeSchema,
+    /** Absolute path to current working directory */
+    cwd: z.string(),
+    /** Absolute path to git root (top-level of working tree) */
+    gitRoot: z.string(),
+    /** Absolute path to main checkout (primary repo) */
+    mainCheckout: z.string(),
+    /** Worktree name if in a worktree (e.g., 'framework-core-wu-1090') */
+    worktreeName: z.string().nullable(),
+    /** WU ID extracted from worktree path (e.g., 'WU-1090') */
+    worktreeWuId: z.string().nullable(),
+});
+/**
+ * Schema for git state
+ *
+ * Captures the current git state relevant to command execution.
+ */
+export const GitStateSchema = z.object({
+    /** Current branch name (null if detached) */
+    branch: z.string().nullable(),
+    /** Whether HEAD is detached */
+    isDetached: z.boolean(),
+    /** Whether working tree has uncommitted changes */
+    isDirty: z.boolean(),
+    /** Whether there are staged changes */
+    hasStaged: z.boolean(),
+    /** Commits ahead of tracking branch */
+    ahead: z.number().int().min(0),
+    /** Commits behind tracking branch */
+    behind: z.number().int().min(0),
+    /** Tracking branch (e.g., 'origin/main') */
+    tracking: z.string().nullable(),
+    /** List of modified files */
+    modifiedFiles: z.array(z.string()),
+    /** Whether an error occurred reading state */
+    hasError: z.boolean(),
+    /** Error message if hasError is true */
+    errorMessage: z.string().nullable(),
+});
+/**
+ * Schema for WU state result
+ *
+ * Result of reading WU state from YAML and state store.
+ */
+export const WuStateResultSchema = z.object({
+    /** WU ID (uppercase, e.g., 'WU-1090') */
+    id: z.string(),
+    /** Current status from YAML */
+    status: z.string(),
+    /** Lane name */
+    lane: z.string(),
+    /** WU title */
+    title: z.string(),
+    /** Absolute path to WU YAML file */
+    yamlPath: z.string(),
+    /** Whether YAML and state store are consistent */
+    isConsistent: z.boolean(),
+    /** Reason for inconsistency if not consistent */
+    inconsistencyReason: z.string().nullable(),
+});
+/**
+ * Schema for session state
+ *
+ * Session state for active WU work.
+ */
+export const SessionStateSchema = z.object({
+    /** Whether a session is active */
+    isActive: z.boolean(),
+    /** Session ID if active */
+    sessionId: z.string().nullable(),
+});
+/**
+ * Schema for unified WU context
+ *
+ * Captures all environmental state relevant to command execution.
+ */
+export const WuContextSchema = z.object({
+    /** Location context (main vs worktree) */
+    location: LocationContextSchema,
+    /** Git state (branch, dirty, staged, ahead/behind) */
+    git: GitStateSchema,
+    /** WU state (null if no WU specified) */
+    wu: WuStateResultSchema.nullable(),
+    /** Session state */
+    session: SessionStateSchema,
+    /**
+     * Git state of the WU's worktree (WU-1092).
+     *
+     * When running wu:done from main checkout, we need to check the worktree's
+     * git state, not main's. This field is populated when:
+     * - Running from main checkout (location.type === 'main')
+     * - A WU is specified (wu !== null)
+     * - WU has an active worktree (status === 'in_progress')
+     *
+     * If undefined, predicates should fall back to checking `git.isDirty`.
+     */
+    worktreeGit: GitStateSchema.optional(),
+});

package/dist/domain/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Domain Schemas Index
+ *
+ * WU-1093: INIT-002 Phase 1 - Define ports and domain schemas
+ *
+ * Re-exports all domain schemas and types for the context-aware validation system.
+ *
+ * @module domain
+ */
+export * from './context.schemas.js';
+export { VALIDATION_ERROR_CODE_VALUES, ValidationErrorCodeSchema, PREDICATE_SEVERITY_VALUES, PredicateSeveritySchema, ValidationErrorSchema, ValidationWarningSchema, ValidationResultSchema, CommandPredicateConfigSchema, CommandDefinitionConfigSchema, type ValidationErrorCode, type PredicateSeverity, type ValidationError, type ValidationWarning, type ValidationResult, type CommandPredicateConfig, type CommandDefinitionConfig, } from './validation.schemas.js';
+export * from './recovery.schemas.js';
+export * from './orchestration.schemas.js';
+export * from './orchestration.constants.js';

package/dist/domain/index.js

@@ -0,0 +1,18 @@
+/**
+ * Domain Schemas Index
+ *
+ * WU-1093: INIT-002 Phase 1 - Define ports and domain schemas
+ *
+ * Re-exports all domain schemas and types for the context-aware validation system.
+ *
+ * @module domain
+ */
+// Context schemas (primary definitions for location, git, wu state)
+export * from './context.schemas.js';
+// Validation schemas (excludes re-exports from context.schemas)
+export { VALIDATION_ERROR_CODE_VALUES, ValidationErrorCodeSchema, PREDICATE_SEVERITY_VALUES, PredicateSeveritySchema, ValidationErrorSchema, ValidationWarningSchema, ValidationResultSchema, CommandPredicateConfigSchema, CommandDefinitionConfigSchema, } from './validation.schemas.js';
+// Recovery schemas
+export * from './recovery.schemas.js';
+// Orchestration schemas (existing)
+export * from './orchestration.schemas.js';
+export * from './orchestration.constants.js';

package/dist/domain/recovery.schemas.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Recovery Schemas
+ *
+ * WU-1093: INIT-002 Phase 1 - Define ports and domain schemas
+ *
+ * Zod schemas for recovery-related types in the context-aware validation system.
+ * Types are inferred from Zod schemas using z.infer<> for single source of truth.
+ *
+ * @module domain/recovery.schemas
+ */
+import { z } from 'zod';
+/**
+ * Recovery issue code values
+ *
+ * Mirrors CONTEXT_VALIDATION.RECOVERY_ISSUES from wu-constants.ts
+ */
+export declare const RECOVERY_ISSUE_CODE_VALUES: readonly ["PARTIAL_CLAIM", "ORPHAN_CLAIM", "INCONSISTENT_STATE", "ORPHAN_BRANCH", "STALE_LOCK", "LEFTOVER_WORKTREE"];
+/**
+ * Schema for recovery issue codes
+ */
+export declare const RecoveryIssueCodeSchema: z.ZodEnum<{
+    INCONSISTENT_STATE: "INCONSISTENT_STATE";
+    PARTIAL_CLAIM: "PARTIAL_CLAIM";
+    ORPHAN_CLAIM: "ORPHAN_CLAIM";
+    ORPHAN_BRANCH: "ORPHAN_BRANCH";
+    STALE_LOCK: "STALE_LOCK";
+    LEFTOVER_WORKTREE: "LEFTOVER_WORKTREE";
+}>;
+/**
+ * Recovery action type values
+ *
+ * Mirrors CONTEXT_VALIDATION.RECOVERY_ACTIONS from wu-constants.ts
+ */
+export declare const RECOVERY_ACTION_TYPE_VALUES: readonly ["resume", "reset", "nuke", "cleanup"];
+/**
+ * Schema for recovery action types
+ */
+export declare const RecoveryActionTypeSchema: z.ZodEnum<{
+    reset: "reset";
+    resume: "resume";
+    nuke: "nuke";
+    cleanup: "cleanup";
+}>;
+/**
+ * Schema for recovery issue
+ *
+ * Issue detected during recovery analysis.
+ */
+export declare const RecoveryIssueSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        INCONSISTENT_STATE: "INCONSISTENT_STATE";
+        PARTIAL_CLAIM: "PARTIAL_CLAIM";
+        ORPHAN_CLAIM: "ORPHAN_CLAIM";
+        ORPHAN_BRANCH: "ORPHAN_BRANCH";
+        STALE_LOCK: "STALE_LOCK";
+        LEFTOVER_WORKTREE: "LEFTOVER_WORKTREE";
+    }>;
+    description: z.ZodString;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Schema for recovery action
+ *
+ * Suggested recovery action.
+ */
+export declare const RecoveryActionSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        reset: "reset";
+        resume: "resume";
+        nuke: "nuke";
+        cleanup: "cleanup";
+    }>;
+    description: z.ZodString;
+    command: z.ZodString;
+    requiresForce: z.ZodBoolean;
+    warning: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Schema for recovery analysis result
+ *
+ * Result of recovery analysis.
+ */
+export declare const RecoveryAnalysisSchema: z.ZodObject<{
+    hasIssues: z.ZodBoolean;
+    issues: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            INCONSISTENT_STATE: "INCONSISTENT_STATE";
+            PARTIAL_CLAIM: "PARTIAL_CLAIM";
+            ORPHAN_CLAIM: "ORPHAN_CLAIM";
+            ORPHAN_BRANCH: "ORPHAN_BRANCH";
+            STALE_LOCK: "STALE_LOCK";
+            LEFTOVER_WORKTREE: "LEFTOVER_WORKTREE";
+        }>;
+        description: z.ZodString;
+        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    actions: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            reset: "reset";
+            resume: "resume";
+            nuke: "nuke";
+            cleanup: "cleanup";
+        }>;
+        description: z.ZodString;
+        command: z.ZodString;
+        requiresForce: z.ZodBoolean;
+        warning: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    wuId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type RecoveryIssueCode = z.infer<typeof RecoveryIssueCodeSchema>;
+export type RecoveryActionType = z.infer<typeof RecoveryActionTypeSchema>;
+export type RecoveryIssue = z.infer<typeof RecoveryIssueSchema>;
+export type RecoveryAction = z.infer<typeof RecoveryActionSchema>;
+export type RecoveryAnalysis = z.infer<typeof RecoveryAnalysisSchema>;

package/dist/domain/recovery.schemas.js

@@ -0,0 +1,83 @@
+/**
+ * Recovery Schemas
+ *
+ * WU-1093: INIT-002 Phase 1 - Define ports and domain schemas
+ *
+ * Zod schemas for recovery-related types in the context-aware validation system.
+ * Types are inferred from Zod schemas using z.infer<> for single source of truth.
+ *
+ * @module domain/recovery.schemas
+ */
+import { z } from 'zod';
+/**
+ * Recovery issue code values
+ *
+ * Mirrors CONTEXT_VALIDATION.RECOVERY_ISSUES from wu-constants.ts
+ */
+export const RECOVERY_ISSUE_CODE_VALUES = [
+    'PARTIAL_CLAIM',
+    'ORPHAN_CLAIM',
+    'INCONSISTENT_STATE',
+    'ORPHAN_BRANCH',
+    'STALE_LOCK',
+    'LEFTOVER_WORKTREE',
+];
+/**
+ * Schema for recovery issue codes
+ */
+export const RecoveryIssueCodeSchema = z.enum(RECOVERY_ISSUE_CODE_VALUES);
+/**
+ * Recovery action type values
+ *
+ * Mirrors CONTEXT_VALIDATION.RECOVERY_ACTIONS from wu-constants.ts
+ */
+export const RECOVERY_ACTION_TYPE_VALUES = ['resume', 'reset', 'nuke', 'cleanup'];
+/**
+ * Schema for recovery action types
+ */
+export const RecoveryActionTypeSchema = z.enum(RECOVERY_ACTION_TYPE_VALUES);
+/**
+ * Schema for recovery issue
+ *
+ * Issue detected during recovery analysis.
+ */
+export const RecoveryIssueSchema = z.object({
+    /** Issue code from RECOVERY_ISSUES */
+    code: RecoveryIssueCodeSchema,
+    /** Human-readable description */
+    description: z.string(),
+    /** Additional context for the issue */
+    context: z.record(z.string(), z.unknown()).optional(),
+});
+/**
+ * Schema for recovery action
+ *
+ * Suggested recovery action.
+ */
+export const RecoveryActionSchema = z.object({
+    /** Action type from RECOVERY_ACTIONS */
+    type: RecoveryActionTypeSchema,
+    /** Human-readable description of what this action does */
+    description: z.string(),
+    /** Command to execute (copy-paste ready) */
+    command: z.string(),
+    /** Whether this action requires --force flag */
+    requiresForce: z.boolean(),
+    /** Warning message if any */
+    warning: z.string().optional(),
+});
+/**
+ * Schema for recovery analysis result
+ *
+ * Result of recovery analysis.
+ */
+export const RecoveryAnalysisSchema = z.object({
+    /** Whether any issues were found */
+    hasIssues: z.boolean(),
+    /** List of detected issues */
+    issues: z.array(RecoveryIssueSchema),
+    /** Suggested recovery actions */
+    actions: z.array(RecoveryActionSchema),
+    /** WU ID analyzed */
+    wuId: z.string().nullable(),
+});