@lumenflow/core 1.5.0 → 2.0.0

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(),
+});

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

@@ -0,0 +1,146 @@
+/**
+ * Validation Schemas
+ *
+ * WU-1093: INIT-002 Phase 1 - Define ports and domain schemas
+ *
+ * Zod schemas for validation-related types in the context-aware validation system.
+ * Types are inferred from Zod schemas using z.infer<> for single source of truth.
+ *
+ * @module domain/validation.schemas
+ */
+import { z } from 'zod';
+import { LocationTypeSchema } from './context.schemas.js';
+export { LocationTypeSchema };
+/**
+ * Validation error code values
+ *
+ * Mirrors CONTEXT_VALIDATION.ERROR_CODES from wu-constants.ts
+ */
+export declare const VALIDATION_ERROR_CODE_VALUES: readonly ["WRONG_LOCATION", "WU_NOT_FOUND", "WU_ALREADY_EXISTS", "WRONG_WU_STATUS", "LANE_OCCUPIED", "WORKTREE_EXISTS", "WORKTREE_MISSING", "GATES_NOT_PASSED", "DIRTY_GIT", "REMOTE_UNAVAILABLE", "INCONSISTENT_STATE"];
+/**
+ * Schema for validation error codes
+ */
+export declare const ValidationErrorCodeSchema: z.ZodEnum<{
+    WU_NOT_FOUND: "WU_NOT_FOUND";
+    WRONG_LOCATION: "WRONG_LOCATION";
+    WU_ALREADY_EXISTS: "WU_ALREADY_EXISTS";
+    WRONG_WU_STATUS: "WRONG_WU_STATUS";
+    LANE_OCCUPIED: "LANE_OCCUPIED";
+    WORKTREE_EXISTS: "WORKTREE_EXISTS";
+    WORKTREE_MISSING: "WORKTREE_MISSING";
+    GATES_NOT_PASSED: "GATES_NOT_PASSED";
+    DIRTY_GIT: "DIRTY_GIT";
+    REMOTE_UNAVAILABLE: "REMOTE_UNAVAILABLE";
+    INCONSISTENT_STATE: "INCONSISTENT_STATE";
+}>;
+/**
+ * Severity values
+ *
+ * Mirrors CONTEXT_VALIDATION.SEVERITY from wu-constants.ts
+ */
+export declare const PREDICATE_SEVERITY_VALUES: readonly ["error", "warning"];
+/**
+ * Schema for predicate severity
+ */
+export declare const PredicateSeveritySchema: z.ZodEnum<{
+    error: "error";
+    warning: "warning";
+}>;
+/**
+ * Schema for validation error with fix guidance
+ */
+export declare const ValidationErrorSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        WU_NOT_FOUND: "WU_NOT_FOUND";
+        WRONG_LOCATION: "WRONG_LOCATION";
+        WU_ALREADY_EXISTS: "WU_ALREADY_EXISTS";
+        WRONG_WU_STATUS: "WRONG_WU_STATUS";
+        LANE_OCCUPIED: "LANE_OCCUPIED";
+        WORKTREE_EXISTS: "WORKTREE_EXISTS";
+        WORKTREE_MISSING: "WORKTREE_MISSING";
+        GATES_NOT_PASSED: "GATES_NOT_PASSED";
+        DIRTY_GIT: "DIRTY_GIT";
+        REMOTE_UNAVAILABLE: "REMOTE_UNAVAILABLE";
+        INCONSISTENT_STATE: "INCONSISTENT_STATE";
+    }>;
+    message: z.ZodString;
+    fixCommand: z.ZodNullable<z.ZodString>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Schema for validation warning (non-blocking)
+ */
+export declare const ValidationWarningSchema: z.ZodObject<{
+    id: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Schema for validation result (partial, without context for serialization)
+ *
+ * Note: The full ValidationResult in types.ts includes the context object,
+ * but this schema is for serializable results without the context.
+ */
+export declare const ValidationResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    errors: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            WU_NOT_FOUND: "WU_NOT_FOUND";
+            WRONG_LOCATION: "WRONG_LOCATION";
+            WU_ALREADY_EXISTS: "WU_ALREADY_EXISTS";
+            WRONG_WU_STATUS: "WRONG_WU_STATUS";
+            LANE_OCCUPIED: "LANE_OCCUPIED";
+            WORKTREE_EXISTS: "WORKTREE_EXISTS";
+            WORKTREE_MISSING: "WORKTREE_MISSING";
+            GATES_NOT_PASSED: "GATES_NOT_PASSED";
+            DIRTY_GIT: "DIRTY_GIT";
+            REMOTE_UNAVAILABLE: "REMOTE_UNAVAILABLE";
+            INCONSISTENT_STATE: "INCONSISTENT_STATE";
+        }>;
+        message: z.ZodString;
+        fixCommand: z.ZodNullable<z.ZodString>;
+        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Schema for command predicate configuration (serializable)
+ *
+ * This schema represents the serializable configuration of a predicate,
+ * not the full CommandPredicate which includes the check function.
+ */
+export declare const CommandPredicateConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+    }>;
+}, z.core.$strip>;
+/**
+ * Schema for command definition configuration (serializable)
+ *
+ * This schema represents the serializable configuration of a command definition,
+ * not the full CommandDefinition which includes function references.
+ */
+export declare const CommandDefinitionConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    requiredLocation: z.ZodNullable<z.ZodEnum<{
+        unknown: "unknown";
+        main: "main";
+        worktree: "worktree";
+        detached: "detached";
+    }>>;
+    requiredWuStatus: z.ZodNullable<z.ZodString>;
+    predicateIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ValidationErrorCode = z.infer<typeof ValidationErrorCodeSchema>;
+export type PredicateSeverity = z.infer<typeof PredicateSeveritySchema>;
+export type ValidationError = z.infer<typeof ValidationErrorSchema>;
+export type ValidationWarning = z.infer<typeof ValidationWarningSchema>;
+export type ValidationResult = z.infer<typeof ValidationResultSchema>;
+export type CommandPredicateConfig = z.infer<typeof CommandPredicateConfigSchema>;
+export type CommandDefinitionConfig = z.infer<typeof CommandDefinitionConfigSchema>;