@riotprompt/riotplan 0.0.3 → 1.0.0

package/dist/index.d.ts

@@ -1,3 +1,119 @@
+import { Command } from 'commander';
+
+/**
+ * Acceptance criterion from a step file
+ */
+export declare interface AcceptanceCriterion {
+    text: string;
+    checked: boolean;
+    stepNumber: number;
+}
+
+/**
+ * Add a relationship to a plan
+ *
+ * @param plan - The source plan
+ * @param options - Relationship options
+ * @returns Result with the created relationship
+ */
+export declare function addRelationship(plan: Plan, options: AddRelationshipOptions): Promise<AddRelationshipResult>;
+
+/**
+ * Options for adding a relationship
+ */
+export declare interface AddRelationshipOptions {
+    /** Type of relationship */
+    type: RelationshipType;
+    /** Path to the related plan (absolute or relative to current plan) */
+    targetPath: string;
+    /** Specific steps involved in the relationship */
+    steps?: number[];
+    /** Reason/description for the relationship */
+    reason?: string;
+}
+
+/**
+ * Result of adding a relationship
+ */
+export declare interface AddRelationshipResult {
+    /** The created relationship */
+    relationship: PlanRelationship;
+    /** Whether the target plan was found and valid */
+    targetValid: boolean;
+    /** Target plan metadata if found */
+    targetPlan?: {
+        code: string;
+        name: string;
+        path: string;
+    };
+}
+
+export declare interface Analysis {
+    /** Path to analysis directory */
+    path: string;
+    /** Requirements document content */
+    requirements: string;
+    /** Philosophy/approach document (optional) */
+    philosophy?: string;
+    /** All elaboration prompts */
+    elaborations: ElaborationRecord[];
+    /** Analysis metadata */
+    metadata: AnalysisMetadata;
+}
+
+export declare interface AnalysisMetadata {
+    createdAt: Date;
+    updatedAt: Date;
+    elaborationCount: number;
+    status: "draft" | "ready" | "converted";
+}
+
+/**
+ * Apply a template to create a new plan
+ */
+export declare function applyTemplate(options: ApplyTemplateOptions): Promise<ApplyTemplateResult>;
+
+/**
+ * Options for applying a template
+ */
+export declare interface ApplyTemplateOptions {
+    /** Template ID to apply */
+    templateId: string;
+    /** Plan code (directory name) */
+    code: string;
+    /** Plan display name */
+    name: string;
+    /** Base path to create the plan in */
+    basePath: string;
+    /** Custom description (overrides template) */
+    description?: string;
+    /** Variable substitutions for template content */
+    variables?: Record<string, string>;
+    /** Additional tags to add */
+    tags?: string[];
+}
+
+/**
+ * Result of applying a template
+ */
+export declare interface ApplyTemplateResult {
+    /** Whether application succeeded */
+    success: boolean;
+    /** Path to created plan */
+    path?: string;
+    /** Template that was applied */
+    template?: PlanTemplate;
+    /** Error message if failed */
+    error?: string;
+}
+
+/**
+ * Create the archive command
+ */
+export declare function archiveCommand(): Command;
+
+export declare const BasicTemplate: PlanTemplate;
+
 /**
  * Blocker preventing progress
  */
@@ -18,38 +134,467 @@ export declare interface Blocker {
     resolution?: string;
 }
 
+/**
+ * Block a step with a reason
+ */
+export declare function blockStep(plan: Plan, stepNumber: number, reason: string): PlanStep;
+
+/**
+ * Build a dependency graph from a plan
+ *
+ * @param plan - The plan to analyze
+ * @returns Dependency graph
+ */
+export declare function buildDependencyGraph(plan: Plan): Promise<DependencyGraph>;
+
+/**
+ * Build a dependency graph from a pre-parsed dependency map
+ *
+ * @param plan - The plan
+ * @param rawDeps - Map of step number to dependencies
+ * @returns Dependency graph
+ */
+export declare function buildDependencyGraphFromMap(plan: Plan, rawDeps: Map<number, number[]>): DependencyGraph;
+
+/**
+ * Check completion of plan execution
+ */
+export declare function checkCompletion(planPath: string): Promise<CompletionReport>;
+
+/**
+ * Check coverage of analysis criteria in plan steps
+ */
+export declare function checkCoverage(planPath: string, options?: CoverageOptions): Promise<CoverageReport>;
+
+/**
+ * Error Handling Utilities
+ */
+/**
+ * CLI-specific error with code and exit code
+ */
+export declare class CliError extends Error {
+    code: string;
+    exitCode: number;
+    constructor(message: string, code: string, exitCode?: number);
+}
+
+/**
+ * Compare two revisions
+ */
+export declare function compareRevisions(history: PlanHistory, fromVersion: string, toVersion: string): RevisionComparison | undefined;
+
+/**
+ * Complete a step
+ */
+export declare function completeStep(plan: Plan, stepNumber: number, notes?: string): PlanStep;
+
+/**
+ * Completion report for plan → execution verification
+ */
+export declare interface CompletionReport {
+    /** Total steps */
+    totalSteps: number;
+    /** Steps by completion status */
+    complete: StepCompletionResult[];
+    partial: StepCompletionResult[];
+    incomplete: StepCompletionResult[];
+    pending: StepCompletionResult[];
+    /** Overall completion percentage */
+    completionScore: number;
+    /** Outstanding items */
+    outstandingItems: string[];
+}
+
+/**
+ * Compute execution order that respects dependencies
+ *
+ * Returns both a linear order and parallel execution levels.
+ *
+ * @param plan - The plan to analyze
+ * @param graph - Optional pre-built dependency graph
+ * @returns Execution order information
+ */
+export declare function computeExecutionOrder(plan: Plan, graph?: DependencyGraph): Promise<ExecutionOrder>;
+
+/**
+ * Context identifier (e.g., "work", "personal", "work/kjerneverk")
+ */
+export declare type ContextId = string;
+
+export declare interface CoverageOptions {
+    /** Minimum keyword match score to consider "covered" */
+    coverageThreshold?: number;
+    /** Minimum keyword match score to consider "partial" */
+    partialThreshold?: number;
+}
+
+/**
+ * Coverage report for analysis → plan verification
+ */
+export declare interface CoverageReport {
+    /** Total criteria checked */
+    totalCriteria: number;
+    /** Fully covered criteria */
+    covered: CriterionResult[];
+    /** Partially covered criteria */
+    partial: CriterionResult[];
+    /** Missing criteria */
+    missing: CriterionResult[];
+    /** Coverage by priority */
+    byPriority: {
+        must: {
+            total: number;
+            covered: number;
+            partial: number;
+            missing: number;
+        };
+        should: {
+            total: number;
+            covered: number;
+            partial: number;
+            missing: number;
+        };
+        could: {
+            total: number;
+            covered: number;
+            partial: number;
+            missing: number;
+        };
+    };
+    /** Overall coverage percentage (weighted by priority) */
+    coverageScore: number;
+    /** Generated verification questions */
+    questions: string[];
+}
+
+/**
+ * Create the analysis directory structure
+ */
+export declare function createAnalysisDirectory(options: CreateAnalysisOptions): Promise<string>;
+
+export declare interface CreateAnalysisOptions {
+    planPath: string;
+    planName: string;
+    initialPrompt: string;
+}
+
+/**
+ * Create a bidirectional relationship between two plans
+ *
+ * @param sourcePlan - The source plan
+ * @param targetPlan - The target plan
+ * @param type - Relationship type from source's perspective
+ * @param reason - Optional reason
+ */
+export declare function createBidirectionalRelationship(sourcePlan: Plan, targetPlan: Plan, type: RelationshipType, reason?: string): void;
+
+/**
+ * Create a step executor for the given provider
+ *
+ * Note: This currently only supports mock execution.
+ * Full provider integration requires importing @riotprompt/execution-* packages.
+ */
+export declare function createExecutor(config: ProviderConfig): StepExecutor;
+
+/**
+ * Create a new feedback record
+ *
+ * @param planPath - Path to the plan directory
+ * @param options - Feedback options
+ * @returns The created feedback record and file path
+ *
+ * @example
+ * ```typescript
+ * const result = await createFeedback('./prompts/my-plan', {
+ *   title: 'Initial Review',
+ *   feedback: 'Consider adding more error handling',
+ *   participants: [
+ *     { name: 'Tim', type: 'human' },
+ *     { name: 'Claude', type: 'ai', model: 'claude-sonnet-4' }
+ *   ],
+ *   platform: 'cursor'
+ * });
+ * console.log(result.record.id); // '001'
+ * ```
+ */
+export declare function createFeedback(planPath: string, options: CreateFeedbackOptions): Promise<CreateFeedbackResult>;
+
+/**
+ * Options for creating feedback
+ */
+export declare interface CreateFeedbackOptions {
+    /** Feedback title */
+    title: string;
+    /** The feedback content */
+    feedback: string;
+    /** Participants */
+    participants?: FeedbackParticipant[];
+    /** Platform where feedback occurred */
+    platform?: FeedbackPlatform;
+    /** What was proposed before feedback */
+    proposed?: string;
+    /** Discussion/debate content */
+    discussion?: string;
+    /** Resolution/outcome */
+    resolution?: string;
+    /** Changes made as a result */
+    changes?: string[];
+    /** Open questions remaining */
+    openQuestions?: string[];
+    /** Context references (file:lines) */
+    context?: FeedbackContext[];
+    /** Plan version this relates to */
+    planVersion?: string;
+}
+
+/**
+ * Result of creating feedback
+ */
+export declare interface CreateFeedbackResult {
+    /** Created feedback record */
+    record: FeedbackRecord;
+    /** Path to created file */
+    path: string;
+}
+
+/**
+ * Create a new milestone
+ */
+export declare function createMilestone(history: PlanHistory, name: string, description?: string): PlanMilestone;
+
 /**
  * Create a new plan
  *
  * @param config - Plan configuration
- * @returns The created plan
+ * @returns The created plan and files
  *
  * @example
  * ```typescript
- * const plan = await createPlan({
+ * const result = await createPlan({
  *   code: 'my-feature',
  *   name: 'My Feature Implementation',
- *   path: './prompts/my-feature',
+ *   basePath: './prompts',
+ *   description: 'Implementing the new feature',
  *   steps: [
  *     { title: 'Setup', description: 'Initial setup' },
  *     { title: 'Implementation', description: 'Core work' },
  *     { title: 'Testing', description: 'Verify it works' },
  *   ]
  * });
+ * console.log(result.path); // './prompts/my-feature'
  * ```
- *
- * @stub Not yet implemented
  */
-export declare function createPlan(_config: {
+export declare function createPlan(config: CreatePlanConfig): Promise<CreatePlanResult>;
+
+/**
+ * Configuration for creating a new plan
+ */
+export declare interface CreatePlanConfig {
+    /** Plan code/slug (directory name) - lowercase letters, numbers, hyphens only */
     code: string;
+    /** Human-readable name */
     name: string;
-    path: string;
+    /** Base path for plan (plan created as subdirectory) */
+    basePath: string;
+    /** Plan description */
     description?: string;
+    /** Initial steps */
     steps?: Array<{
         title: string;
         description?: string;
     }>;
-}): Promise<never>;
+    /** Context assignment */
+    context?: string;
+    /** Author name */
+    author?: string;
+    /** Create feedback directory (default: true) */
+    createFeedbackDir?: boolean;
+    /** Create evidence directory (default: true) */
+    createEvidenceDir?: boolean;
+    /** Template to use (basic support) */
+    template?: "blank" | "default";
+}
+
+/**
+ * Result of plan creation
+ */
+export declare interface CreatePlanResult {
+    /** Created plan */
+    plan: Plan;
+    /** Path where plan was created */
+    path: string;
+    /** Files that were created */
+    filesCreated: string[];
+}
+
+/**
+ * Create the CLI program with all commands
+ */
+export declare function createProgram(): Command;
+
+/**
+ * Create a new empty registry
+ */
+export declare function createRegistry(searchPaths?: string[]): PlanRegistry;
+
+/**
+ * Create and save a RETROSPECTIVE.md file
+ */
+export declare function createRetrospective(plan: Plan, options?: GenerateRetrospectiveOptions): Promise<string>;
+
+/**
+ * Create a new revision
+ */
+export declare function createRevision(history: PlanHistory, message: string, options?: {
+    author?: string;
+    feedbackId?: string;
+}): PlanRevision;
+
+/**
+ * Patterns for detecting criteria in markdown
+ */
+export declare const CRITERIA_PATTERNS: {
+    /** Checkbox item: - [ ] or - [x] */
+    readonly checkbox: RegExp;
+    /** Section headers for criteria */
+    readonly mustHaveHeader: RegExp;
+    readonly shouldHaveHeader: RegExp;
+    readonly couldHaveHeader: RegExp;
+    /** Verification criteria section */
+    readonly verificationSection: RegExp;
+};
+
+/**
+ * Priority level for verification criteria
+ */
+export declare type CriteriaPriority = "must" | "should" | "could";
+
+/**
+ * Status of a verification criterion
+ */
+export declare type CriteriaStatus = "covered" | "partial" | "missing" | "unknown";
+
+/**
+ * Result of checking a single criterion
+ */
+export declare interface CriterionResult {
+    criterion: VerificationCriterion;
+    status: CriteriaStatus;
+    matchedSteps: number[];
+    notes?: string;
+}
+
+/**
+ * Critical path analysis result
+ */
+export declare interface CriticalPath {
+    /** Steps in the critical path (in order) */
+    path: number[];
+    /** Total length of the critical path */
+    length: number;
+    /** Estimated duration (if steps have duration estimates) */
+    estimatedDuration?: number;
+}
+
+/**
+ * A dependency error
+ */
+export declare interface DependencyError {
+    /** Error type */
+    type: "circular" | "missing" | "self-reference" | "invalid-step" | "duplicate";
+    /** Affected step */
+    stepNumber: number;
+    /** Related steps */
+    relatedSteps?: number[];
+    /** Error message */
+    message: string;
+}
+
+/**
+ * A dependency graph for the entire plan
+ */
+export declare interface DependencyGraph {
+    /** Map of step number to its dependencies */
+    dependencies: Map<number, StepDependency>;
+    /** Steps with no dependencies (can start immediately) */
+    roots: number[];
+    /** Steps with no dependents (end points) */
+    leaves: number[];
+    /** Whether the graph has circular dependencies */
+    hasCircular: boolean;
+    /** Circular dependency chains if any */
+    circularChains: number[][];
+}
+
+/**
+ * Result of dependency validation
+ */
+export declare interface DependencyValidation {
+    /** Whether all dependencies are valid */
+    valid: boolean;
+    /** Errors found */
+    errors: DependencyError[];
+    /** Warnings found */
+    warnings: DependencyWarning[];
+}
+
+/**
+ * A dependency warning
+ */
+export declare interface DependencyWarning {
+    /** Warning type */
+    type: "long-chain" | "bottleneck" | "orphan";
+    /** Affected step */
+    stepNumber: number;
+    /** Warning message */
+    message: string;
+}
+
+export declare interface ElaborationRecord {
+    id: string;
+    timestamp: Date;
+    content: string;
+}
+
+/**
+ * Evidence record for inception phase materials
+ *
+ * Tracks documentation gathered during plan inception to support
+ * decisions and provide context for future reference.
+ */
+export declare interface EvidenceRecord {
+    /** Unique identifier */
+    id: string;
+    /** Evidence type */
+    type: EvidenceType;
+    /** Title/description */
+    title: string;
+    /** When gathered */
+    createdAt: Date;
+    /** Source of evidence */
+    source?: string;
+    /** Filename */
+    filename: string;
+    /** Summary of key findings */
+    summary?: string;
+    /** Tags for categorization */
+    tags?: string[];
+}
+
+/**
+ * Type of evidence gathered during inception phase
+ */
+export declare type EvidenceType = "case-study" | "research" | "analysis" | "example" | "external-review" | "reference";
+
+/**
+ * Execute all pending steps in a plan
+ */
+export declare function executePendingSteps(executor: StepExecutor, plan: Plan, options?: {
+    provider?: ProviderConfig;
+    stopOnError?: boolean;
+    onProgress?: (step: number, message: string) => void;
+    onStepComplete?: (step: number, result: StepResult) => void;
+}): Promise<StepResult[]>;
 
 /**
  * Execute a plan step
@@ -63,6 +608,47 @@ export declare function createPlan(_config: {
  */
 export declare function executeStep(_plan: unknown, _stepNumber: number, _context?: unknown): Promise<never>;
 
+/**
+ * Execute a step with the given executor
+ */
+export declare function executeStepWithExecutor(executor: StepExecutor, plan: Plan, stepNumber: number, options?: {
+    provider?: ProviderConfig;
+    workingDirectory?: string;
+    env?: Record<string, string>;
+    onProgress?: (message: string) => void;
+    onComplete?: (result: StepResult) => void;
+}): Promise<StepResult>;
+
+/**
+ * Execution context passed to step execution
+ */
+export declare interface ExecutionContext {
+    /** The plan being executed */
+    plan: Plan;
+    /** Current step being executed */
+    step: PlanStep;
+    /** Provider configuration */
+    provider: ProviderConfig;
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Working directory */
+    workingDirectory?: string;
+    /** Callback for progress updates */
+    onProgress?: (message: string) => void;
+    /** Callback for step completion */
+    onComplete?: (result: StepResult) => void;
+}
+
+/**
+ * Execution order for steps
+ */
+export declare interface ExecutionOrder {
+    /** Steps in execution order (respects dependencies) */
+    order: number[];
+    /** Steps grouped by parallel execution level */
+    levels: number[][];
+}
+
 /**
  * EXECUTION_PLAN.md schema
  */
@@ -84,276 +670,1554 @@ export declare interface ExecutionPlanDocument {
 }
 
 /**
- * Generate a STATUS.md file
- *
- * @param plan - The plan to generate status for
- * @returns STATUS.md content
+ * Available execution providers
+ */
+export declare type ExecutionProviderType = "anthropic" | "openai" | "gemini" | "mock";
+
+/**
+ * Provider-specific executor factory type
  *
- * @stub Not yet implemented
+ * External provider packages should export functions matching this signature.
  */
-export declare function generateStatus(_plan: unknown): never;
+export declare type ExecutorFactory = (config: ProviderConfig) => StepExecutor;
 
 /**
- * Issue encountered during execution
+ * Fail a step
  */
-export declare interface Issue {
-    /** Unique identifier */
-    id: string;
-    /** Issue title */
-    title: string;
-    /** Description */
-    description: string;
-    /** Severity */
-    severity: Priority;
-    /** Related step */
-    step?: number;
-    /** When encountered */
-    createdAt: Date;
-    /** When resolved */
-    resolvedAt?: Date;
-    /** How it was resolved */
+export declare function failStep(plan: Plan, stepNumber: number, reason?: string): PlanStep;
+
+export declare const FeatureTemplate: PlanTemplate;
+
+/**
+ * Context reference for feedback (file:lines)
+ */
+export declare interface FeedbackContext {
+    /** File path */
+    file: string;
+    /** Start line number */
+    startLine?: number;
+    /** End line number */
+    endLine?: number;
+    /** Content excerpt */
+    content?: string;
+}
+
+/**
+ * Participant in a feedback discussion
+ */
+export declare interface FeedbackParticipant {
+    /** Participant name */
+    name: string;
+    /** Type of participant */
+    type: "human" | "ai";
+    /** Model identifier for AI participants */
+    model?: string;
+}
+
+/**
+ * Platform where feedback occurred
+ */
+export declare type FeedbackPlatform = "cursor" | "chatgpt" | "slack" | "email" | "meeting" | "voice" | "document" | "other";
+
+/**
+ * Feedback record for deliberation capture
+ *
+ * Captures discussions, decisions, and changes made during plan development.
+ * Each feedback record represents a deliberation session that influenced the plan.
+ */
+export declare interface FeedbackRecord {
+    /** Unique identifier (e.g., "001", "002") */
+    id: string;
+    /** Title/subject of the feedback */
+    title: string;
+    /** When created */
+    createdAt: Date;
+    /** Participants in the discussion */
+    participants: FeedbackParticipant[];
+    /** Platform where feedback occurred */
+    platform: FeedbackPlatform;
+    /** Plan version this feedback relates to */
+    planVersion?: string;
+    /** Related file references (file:lines) */
+    context?: FeedbackContext[];
+    /** What was proposed before feedback */
+    proposed?: string;
+    /** The feedback given */
+    feedback: string;
+    /** Discussion/debate content */
+    discussion?: string;
+    /** Resolution/outcome */
     resolution?: string;
+    /** Changes made as a result */
+    changes?: string[];
+    /** Open questions remaining */
+    openQuestions?: string[];
+    /** Filename (e.g., "001-initial-review.md") */
+    filename: string;
 }
 
 /**
- * Load a plan from a directory
+ * Find the critical path through the plan
  *
- * @param path - Path to the plan directory
- * @returns The loaded plan
+ * The critical path is the longest sequence of dependent steps
+ * that determines the minimum time to complete the plan.
  *
- * @example
- * ```typescript
- * const plan = await loadPlan('./prompts/big-splitup');
- * console.log(plan.metadata.code); // 'big-splitup'
- * console.log(plan.steps.length);  // 11
- * ```
+ * @param plan - The plan to analyze
+ * @param graph - Optional pre-built dependency graph
+ * @returns Critical path information
+ */
+export declare function findCriticalPath(plan: Plan, graph?: DependencyGraph): Promise<CriticalPath>;
+
+export declare interface FixableIssue {
+    code: string;
+    description: string;
+    fix: () => Promise<void>;
+}
+
+/**
+ * Format status with color
+ */
+export declare function formatStatus(status: TaskStatus): string;
+
+/**
+ * Generate markdown for a plan's relationships section
  *
- * @stub Not yet implemented
+ * @param plan - The plan with relationships
+ * @returns Markdown string for ## Related Plans section
+ */
+export declare function generateRelationshipsMarkdown(plan: Plan): string;
+
+/**
+ * Generate retrospective data from a plan
+ */
+export declare function generateRetrospective(plan: Plan, options?: GenerateRetrospectiveOptions): Retrospective;
+
+/**
+ * Generate RETROSPECTIVE.md content
  */
-export declare function loadPlan(_path: string): Promise<never>;
+export declare function generateRetrospectiveMarkdown(retro: Retrospective): string;
 
 /**
- * Parse a STATUS.md file
+ * Options for generating a retrospective
+ */
+export declare interface GenerateRetrospectiveOptions {
+    /** Custom "what went well" entries */
+    whatWentWell?: string[];
+    /** Custom "what could improve" entries */
+    whatCouldImprove?: string[];
+    /** Custom key learnings */
+    keyLearnings?: string[];
+    /** Custom action items */
+    actionItems?: string[];
+    /** Author */
+    author?: string;
+}
+
+/**
+ * Generate a complete STATUS.md document from a plan
+ */
+export declare function generateStatus(plan: Plan, options?: GenerateStatusOptions): string;
+
+export declare interface GenerateStatusOptions {
+    /** Preserve existing notes section */
+    preserveNotes?: boolean;
+    /** Existing STATUS.md content (for preservation) */
+    existingContent?: string;
+    /** Include phase progress if phases defined */
+    includePhases?: boolean;
+    /** Date format for timestamps */
+    dateFormat?: "iso" | "short" | "long";
+}
+
+/**
+ * Find all plans that this plan blocks
  *
- * @param content - The STATUS.md content
- * @returns Parsed status document
+ * @param plan - The plan to check
+ * @returns Paths to blocked plans
+ */
+export declare function getBlockedPlans(plan: Plan): string[];
+
+/**
+ * Get steps that are blocked by a specific step
  *
- * @stub Not yet implemented
+ * @param plan - The plan
+ * @param stepNumber - The blocking step
+ * @param graph - Optional pre-built dependency graph
+ * @returns Steps blocked by this step
  */
-export declare function parseStatus(_content: string): never;
+export declare function getBlockedSteps(plan: Plan, stepNumber: number, graph?: DependencyGraph): Promise<PlanStep[]>;
 
 /**
- * Complete plan definition
+ * Find all plans that block this plan
+ *
+ * @param plan - The plan to check
+ * @returns Paths to blocking plans
  */
-export declare interface Plan {
-    /** Plan metadata */
-    metadata: PlanMetadata;
-    /** Plan files */
-    files: PlanFiles;
-    /** Plan steps */
-    steps: PlanStep[];
-    /** Plan phases (optional grouping) */
-    phases?: PlanPhase[];
-    /** Current state */
-    state: PlanState;
-}
+export declare function getBlockingPlans(plan: Plan): string[];
 
 /**
- * File naming conventions
+ * Find all child plans (plans spawned from this one)
+ *
+ * @param plan - The plan to check
+ * @returns Paths to child plans
  */
-export declare const PLAN_CONVENTIONS: {
-    /** Meta-prompt file patterns */
-    readonly metaPromptPatterns: readonly ["{code}-prompt.md", "prompt-of-prompts.md", "{code}.md"];
-    /** Step file pattern */
-    readonly stepPattern: RegExp;
-    /** Standard files */
-    readonly standardFiles: {
-        readonly summary: "SUMMARY.md";
-        readonly status: "STATUS.md";
-        readonly executionPlan: "EXECUTION_PLAN.md";
-        readonly readme: "README.md";
+export declare function getChildPlans(plan: Plan): string[];
+
+/**
+ * Get criteria summary statistics
+ */
+export declare function getCriteriaSummary(criteria: VerificationCriterion[]): {
+    total: number;
+    must: number;
+    should: number;
+    could: number;
+};
+
+/**
+ * Get the default registry path
+ */
+export declare function getDefaultRegistryPath(): string;
+
+/**
+ * Get the dependency chain for a step (all transitive dependencies)
+ *
+ * @param plan - The plan
+ * @param stepNumber - The step to analyze
+ * @param graph - Optional pre-built dependency graph
+ * @returns All steps that must be completed before this step
+ */
+export declare function getDependencyChain(plan: Plan, stepNumber: number, graph?: DependencyGraph): Promise<number[]>;
+
+/**
+ * Get a specific feedback record by ID
+ *
+ * @param planPath - Path to the plan directory
+ * @param id - Feedback ID (e.g., '001' or '1')
+ * @returns The feedback record or null if not found
+ */
+export declare function getFeedback(planPath: string, id: string): Promise<FeedbackRecord | null>;
+
+/**
+ * Get the inverse relationship type
+ */
+export declare function getInverseRelationType(type: RelationshipType): RelationshipType;
+
+/**
+ * Get the latest milestone
+ */
+export declare function getLatestMilestone(history: PlanHistory): MilestoneInfo | undefined;
+
+/**
+ * Get the latest revision
+ */
+export declare function getLatestRevision(history: PlanHistory): RevisionInfo | undefined;
+
+/**
+ * Get a milestone by name
+ */
+export declare function getMilestone(history: PlanHistory, name: string): MilestoneInfo | undefined;
+
+/**
+ * Find the parent plan (if this plan was spawned from another)
+ *
+ * @param plan - The plan to check
+ * @returns Path to parent plan or null
+ */
+export declare function getParentPlan(plan: Plan): string | null;
+
+/**
+ * Get a plan by code
+ */
+export declare function getPlanByCode(registry: PlanRegistry, code: string): RegisteredPlan | null;
+
+/**
+ * Get a plan by path
+ */
+export declare function getPlanByPath(registry: PlanRegistry, path: string): RegisteredPlan | null;
+
+/**
+ * Get all plans with a specific status
+ */
+export declare function getPlansByStatus(registry: PlanRegistry, status: TaskStatus): RegisteredPlan[];
+
+/**
+ * Get steps that can be started now (all dependencies completed)
+ *
+ * @param plan - The plan
+ * @param graph - Optional pre-built dependency graph
+ * @returns Steps ready to start
+ */
+export declare function getReadySteps(plan: Plan, graph?: DependencyGraph): Promise<PlanStep[]>;
+
+/**
+ * Get statistics about the registry
+ */
+export declare function getRegistryStats(registry: PlanRegistry): RegistryStats;
+
+/**
+ * Find all related plans (general relationships)
+ *
+ * @param plan - The plan to check
+ * @returns Paths to related plans
+ */
+export declare function getRelatedPlans(plan: Plan): string[];
+
+/**
+ * Get all relationships of a specific type
+ *
+ * @param plan - The plan to query
+ * @param type - Relationship type to filter by
+ * @returns Matching relationships
+ */
+export declare function getRelationshipsByType(plan: Plan, type: RelationshipType): PlanRelationship[];
+
+/**
+ * Get a specific revision by version
+ */
+export declare function getRevision(history: PlanHistory, version: string): RevisionInfo | undefined;
+
+/**
+ * Get emoji icon for status
+ */
+export declare function getStatusIcon(status: TaskStatus): string;
+
+/**
+ * Get a template by ID
+ */
+export declare function getTemplate(id: string): PlanTemplate | undefined;
+
+/**
+ * Handle errors and exit appropriately
+ */
+export declare function handleError(error: unknown): never;
+
+/**
+ * Check if a plan has an analysis
+ */
+export declare function hasAnalysis(planPath: string): Promise<boolean>;
+
+/**
+ * Minimum scores for "healthy" status
+ */
+export declare const HEALTH_THRESHOLDS: {
+    readonly coverage: {
+        readonly good: 80;
+        readonly warning: 60;
+        readonly critical: 40;
     };
-    /** Standard directories */
-    readonly standardDirs: {
-        readonly plan: "plan";
-        readonly analysis: "analysis";
-        readonly architecture: "architecture";
-        readonly implementation: "implementation";
-        readonly testing: "testing";
+    readonly completion: {
+        readonly good: 90;
+        readonly warning: 70;
+        readonly critical: 50;
     };
-    /** Status emoji mapping */
-    readonly statusEmoji: Record<TaskStatus, string>;
 };
 
 /**
- * Context for plan execution
+ * History manager interface
  */
-export declare interface PlanContext {
-    /** Working directory */
-    workingDirectory: string;
-    /** The plan being executed */
-    plan: Plan;
-    /** Logger instance */
-    logger?: any;
-    /** Storage for artifacts */
-    storage?: any;
-    /** Environment variables */
-    env?: Record<string, string>;
+export declare interface HistoryManager {
+    /** History data */
+    history: PlanHistory;
+    /** Path to history file */
+    path: string;
+    /** Save history to disk */
+    save(): Promise<void>;
+    /** Reload history from disk */
+    reload(): Promise<void>;
 }
 
 /**
- * Standard plan files
+ * Options for HTML rendering
  */
-export declare interface PlanFiles {
-    /** Meta-prompt file (e.g., "big-splitup-prompt.md" or "prompt-of-prompts.md") */
-    metaPrompt?: string;
-    /** Summary file */
-    summary?: string;
-    /** Status file */
-    status?: string;
-    /** Execution plan file */
-    executionPlan?: string;
-    /** README file */
-    readme?: string;
-    /** Step files in order */
-    steps: string[];
-    /** Analysis directory */
-    analysisDir?: string;
-    /** Other directories (architecture/, implementation/, testing/) */
-    subdirectories: string[];
+export declare interface HtmlRenderOptions {
+    /** Include full HTML document (with head/body) */
+    fullDocument?: boolean;
+    /** Document title (defaults to plan name) */
+    title?: string;
+    /** Include inline CSS styles */
+    includeStyles?: boolean;
+    /** CSS theme: light or dark */
+    theme?: "light" | "dark";
+    /** Include step details */
+    includeStepDetails?: boolean;
+    /** Include feedback records */
+    includeFeedback?: boolean;
+    /** Include evidence records */
+    includeEvidence?: boolean;
+}
+
+/**
+ * Create the init command
+ */
+export declare function initCommand(): Command;
+
+/**
+ * Initialize a new history for a plan
+ */
+export declare function initHistory(initialVersion?: string): PlanHistory;
+
+/**
+ * Insert a new step into a plan
+ */
+export declare function insertStep(plan: Plan, options: InsertStepOptions): Promise<InsertStepResult>;
+
+export declare interface InsertStepOptions {
+    /** Step title */
+    title: string;
+    /** Step description */
+    description?: string;
+    /** Position to insert (1-based). If omitted, appends. */
+    position?: number;
+    /** Insert after this step number */
+    after?: number;
+    /** Initial status */
+    status?: TaskStatus;
+}
+
+export declare interface InsertStepResult {
+    /** Inserted step */
+    step: PlanStep;
+    /** Files that were renamed */
+    renamedFiles: Array<{
+        from: string;
+        to: string;
+    }>;
+    /** Created file path */
+    createdFile: string;
+}
+
+/**
+ * An invalid relationship
+ */
+export declare interface InvalidRelationship {
+    relationship: PlanRelationship;
+    reason: string;
+}
+
+/**
+ * Issue encountered during execution
+ */
+export declare interface Issue {
+    /** Unique identifier */
+    id: string;
+    /** Issue title */
+    title: string;
+    /** Description */
+    description: string;
+    /** Severity */
+    severity: Priority;
+    /** Related step */
+    step?: number;
+    /** When encountered */
+    createdAt: Date;
+    /** When resolved */
+    resolvedAt?: Date;
+    /** How it was resolved */
+    resolution?: string;
+}
+
+/**
+ * Options for JSON rendering
+ */
+export declare interface JsonRenderOptions {
+    /** Pretty print with indentation */
+    pretty?: boolean;
+    /** Indentation (spaces or tab) */
+    indent?: number | string;
+    /** Include full step content */
+    includeStepContent?: boolean;
+    /** Include feedback records */
+    includeFeedback?: boolean;
+    /** Include evidence records */
+    includeEvidence?: boolean;
+    /** Only include specific fields */
+    fields?: string[];
+}
+
+/**
+ * List all feedback records for a plan
+ *
+ * @param planPath - Path to the plan directory
+ * @returns Array of feedback records sorted by ID
+ */
+export declare function listFeedback(planPath: string): Promise<FeedbackRecord[]>;
+
+/**
+ * List all milestones
+ */
+export declare function listMilestones(history: PlanHistory): MilestoneInfo[];
+
+/**
+ * List all revisions
+ */
+export declare function listRevisions(history: PlanHistory): RevisionInfo[];
+
+/**
+ * List all available templates
+ */
+export declare function listTemplates(): PlanTemplate[];
+
+/**
+ * List templates by category
+ */
+export declare function listTemplatesByCategory(category: PlanTemplate["category"]): PlanTemplate[];
+
+/**
+ * Load all amendment prompts for a plan
+ */
+export declare function loadAmendmentPrompts(planPath: string): Promise<SavedPrompt[]>;
+
+/**
+ * Load an analysis from disk
+ */
+export declare function loadAnalysis(planPath: string): Promise<Analysis | null>;
+
+/**
+ * Load all elaboration prompts for a plan
+ */
+export declare function loadElaborationPrompts(planPath: string): Promise<SavedPrompt[]>;
+
+/**
+ * Load history from disk
+ */
+export declare function loadHistory(planPath: string): Promise<HistoryManager>;
+
+/**
+ * Load a plan from a directory
+ *
+ * @param path - Path to the plan directory
+ * @param options - Loading options
+ * @returns The loaded plan
+ *
+ * @example
+ * ```typescript
+ * const plan = await loadPlan('./prompts/big-splitup');
+ * console.log(plan.metadata.code); // 'big-splitup'
+ * console.log(plan.steps.length);  // 11
+ * ```
+ */
+export declare function loadPlan(path: string, options?: LoadPlanOptions): Promise<Plan>;
+
+/**
+ * Options for loading a plan
+ */
+export declare interface LoadPlanOptions {
+    /** Include feedback records (default: true) */
+    includeFeedback?: boolean;
+    /** Include evidence files (default: true) */
+    includeEvidence?: boolean;
+    /** Parse STATUS.md for state (default: true) */
+    parseStatus?: boolean;
+}
+
+/**
+ * Load registry from file
+ *
+ * @param path - Path to registry file (defaults to home directory)
+ */
+export declare function loadRegistry(path?: string): Promise<PlanRegistry | null>;
+
+/**
+ * Options for Markdown rendering
+ */
+export declare interface MarkdownRenderOptions {
+    /** Include metadata section */
+    includeMetadata?: boolean;
+    /** Include step details */
+    includeStepDetails?: boolean;
+    /** Include feedback records */
+    includeFeedback?: boolean;
+    /** Include evidence records */
+    includeEvidence?: boolean;
+    /** Use task list format for steps */
+    useTaskList?: boolean;
+    /** Table of contents */
+    includeToc?: boolean;
+}
+
+export declare const MigrationTemplate: PlanTemplate;
+
+/**
+ * Extended milestone info
+ */
+export declare interface MilestoneInfo extends PlanMilestone {
+    /** Milestone index */
+    index: number;
+}
+
+/**
+ * Mock step executor for testing
+ */
+export declare class MockStepExecutor implements StepExecutor {
+    private delay;
+    private shouldFail;
+    constructor(options?: {
+        delay?: number;
+        shouldFail?: boolean;
+    });
+    execute(context: ExecutionContext): Promise<StepResult>;
+}
+
+/**
+ * Move a step to a new position
+ */
+export declare function moveStep(plan: Plan, fromNumber: number, toNumber: number): Promise<MoveStepResult>;
+
+export declare interface MoveStepResult {
+    /** Moved step */
+    step: PlanStep;
+    /** New position */
+    newPosition: number;
+    /** Files that were renamed */
+    renamedFiles: Array<{
+        from: string;
+        to: string;
+    }>;
+}
+
+/**
+ * Generate a new version number
+ */
+export declare function nextVersion(currentVersion: string): string;
+
+/**
+ * Show "not implemented" message for future features
+ */
+export declare function notImplemented(feature: string): never;
+
+/**
+ * Output an error message
+ */
+export declare function outputError(message: string): void;
+
+/**
+ * Output an info message
+ */
+export declare function outputInfo(message: string): void;
+
+/**
+ * Output data as JSON
+ */
+export declare function outputJson(data: unknown): void;
+
+/**
+ * Output a plan summary
+ */
+export declare function outputPlanSummary(plan: Plan): void;
+
+/**
+ * Output a list of steps
+ */
+export declare function outputStepList(steps: PlanStep[]): void;
+
+/**
+ * Output a success message
+ */
+export declare function outputSuccess(message: string): void;
+
+/**
+ * Output a warning message
+ */
+export declare function outputWarning(message: string): void;
+
+/**
+ * Parse all dependencies from a plan
+ *
+ * @param plan - The plan to analyze
+ * @returns Map of step number to its dependencies
+ */
+export declare function parseAllDependencies(plan: Plan): Promise<Map<number, number[]>>;
+
+/**
+ * Parse verification criteria from a plan's analysis
+ */
+export declare function parseCriteria(planPath: string): Promise<ParsedCriteria>;
+
+/**
+ * Parse criteria from markdown content
+ */
+export declare function parseCriteriaFromContent(content: string, source: string): ParsedCriteria;
+
+export declare interface ParsedCriteria {
+    criteria: VerificationCriterion[];
+    source: string;
+    parseErrors: string[];
+}
+
+/**
+ * Parse dependencies from step content
+ *
+ * Looks for dependency declarations in the markdown:
+ * - `## Dependencies` section with bullet points
+ * - `depends-on: 1, 2, 3` in frontmatter
+ * - Inline references like `(depends on Step 01)`
+ *
+ * @param content - Step file content
+ * @returns Array of step numbers this step depends on
+ */
+export declare function parseDependenciesFromContent(content: string): number[];
+
+/**
+ * Parse dependencies from a step file
+ *
+ * @param filePath - Path to step file
+ * @returns Array of step numbers this step depends on
+ */
+export declare function parseDependenciesFromFile(filePath: string): Promise<number[]>;
+
+/**
+ * Parsed relationship from file content
+ */
+export declare interface ParsedRelationship {
+    type: RelationshipType;
+    targetPath: string;
+    steps?: number[];
+    reason?: string;
+}
+
+/**
+ * Parse relationships from plan content
+ *
+ * Looks for relationship declarations in markdown:
+ * - `## Related Plans` section with formatted links
+ * - `spawned-from: path/to/plan` in frontmatter
+ * - `blocks: path/to/plan` in frontmatter
+ *
+ * Supported formats in ## Related Plans:
+ * - `- **spawned-from**: path/to/plan - reason`
+ * - `- [plan-name](path/to/plan) - blocks Step 3`
+ * - `- path/to/plan (related)`
+ *
+ * @param content - Plan file content (typically SUMMARY.md or meta-prompt)
+ * @returns Array of parsed relationships
+ */
+export declare function parseRelationshipsFromContent(content: string): ParsedRelationship[];
+
+/**
+ * Parse relationships from a plan's SUMMARY.md or meta-prompt
+ *
+ * @param planPath - Path to the plan directory
+ * @returns Array of parsed relationships
+ */
+export declare function parseRelationshipsFromPlan(planPath: string): Promise<ParsedRelationship[]>;
+
+/**
+ * Parse STATUS.md content into structured data
+ *
+ * @param content - The STATUS.md file content
+ * @param options - Parsing options
+ * @returns Parsed document, state, and any warnings
+ *
+ * @example
+ * ```typescript
+ * const content = await readFile('STATUS.md', 'utf-8');
+ * const result = parseStatus(content);
+ * console.log(result.state.progress); // 40
+ * console.log(result.document.stepProgress.length); // 5
+ * ```
+ */
+export declare function parseStatus(content: string, options?: ParseStatusOptions): ParseStatusResult;
+
+/**
+ * Options for parsing STATUS.md
+ */
+export declare interface ParseStatusOptions {
+    /** Steps to cross-reference for status updates */
+    steps?: PlanStep[];
+}
+
+/**
+ * Result of parsing STATUS.md
+ */
+export declare interface ParseStatusResult {
+    /** Parsed status document */
+    document: StatusDocument;
+    /** Derived plan state */
+    state: PlanState;
+    /** Parsing warnings */
+    warnings: string[];
+}
+
+/**
+ * Complete plan definition
+ */
+export declare interface Plan {
+    /** Plan metadata */
+    metadata: PlanMetadata;
+    /** Plan files */
+    files: PlanFiles;
+    /** Plan steps */
+    steps: PlanStep[];
+    /** Plan phases (optional grouping) */
+    phases?: PlanPhase[];
+    /** Current state */
+    state: PlanState;
+    /** Feedback records */
+    feedback?: FeedbackRecord[];
+    /** Evidence files */
+    evidence?: EvidenceRecord[];
+    /** Revision history */
+    history?: PlanHistory;
+    /** Context assignment */
+    context?: ContextId;
+    /** Relationships to other plans */
+    relationships?: PlanRelationship[];
+}
+
+/**
+ * File naming conventions
+ */
+export declare const PLAN_CONVENTIONS: {
+    /** Meta-prompt file patterns */
+    readonly metaPromptPatterns: readonly ["{code}-prompt.md", "prompt-of-prompts.md", "{code}.md"];
+    /** Step file pattern (e.g., "01-step-name.md") */
+    readonly stepPattern: RegExp;
+    /** Feedback file pattern (e.g., "001-initial-review.md") */
+    readonly feedbackPattern: RegExp;
+    /** Evidence file patterns */
+    readonly evidencePatterns: readonly [RegExp, RegExp, RegExp, RegExp];
+    /** Standard files */
+    readonly standardFiles: {
+        readonly summary: "SUMMARY.md";
+        readonly status: "STATUS.md";
+        readonly executionPlan: "EXECUTION_PLAN.md";
+        readonly readme: "README.md";
+        readonly changelog: "CHANGELOG.md";
+    };
+    /** Standard directories */
+    readonly standardDirs: {
+        readonly plan: "plan";
+        readonly analysis: "analysis";
+        readonly architecture: "architecture";
+        readonly implementation: "implementation";
+        readonly testing: "testing";
+        readonly feedback: "feedback";
+        readonly evidence: "evidence";
+        readonly history: ".history";
+    };
+    /** Status emoji mapping */
+    readonly statusEmoji: Record<TaskStatus, string>;
+    /** Emoji to status mapping (reverse lookup) */
+    readonly emojiToStatus: Record<string, TaskStatus>;
+};
+
+/**
+ * Context for plan execution
+ */
+export declare interface PlanContext {
+    /** Working directory */
+    workingDirectory: string;
+    /** The plan being executed */
+    plan: Plan;
+    /** Logger instance */
+    logger?: any;
+    /** Storage for artifacts */
+    storage?: any;
+    /** Environment variables */
+    env?: Record<string, string>;
+}
+
+/**
+ * Plan context definition
+ *
+ * Contexts allow organizing plans by domain (work, personal, etc.)
+ * with optional hierarchy support.
+ */
+export declare interface PlanContextDefinition {
+    /** Context identifier */
+    id: ContextId;
+    /** Display name */
+    name: string;
+    /** Parent context (for hierarchy) */
+    parent?: ContextId;
+    /** Default for this directory? */
+    isDefault?: boolean;
+}
+
+/**
+ * Standard plan files
+ */
+export declare interface PlanFiles {
+    /** Meta-prompt file (e.g., "big-splitup-prompt.md" or "prompt-of-prompts.md") */
+    metaPrompt?: string;
+    /** Summary file */
+    summary?: string;
+    /** Status file */
+    status?: string;
+    /** Execution plan file */
+    executionPlan?: string;
+    /** README file */
+    readme?: string;
+    /** Step files in order */
+    steps: string[];
+    /** Analysis directory */
+    analysisDir?: string;
+    /** Other directories (architecture/, implementation/, testing/) */
+    subdirectories: string[];
+    /** Feedback directory */
+    feedbackDir?: string;
+    /** Feedback files */
+    feedbackFiles?: string[];
+    /** Evidence directory */
+    evidenceDir?: string;
+    /** Evidence files */
+    evidenceFiles?: string[];
+    /** History directory */
+    historyDir?: string;
+    /** CHANGELOG.md */
+    changelog?: string;
+}
+
+/**
+ * Plan version history
+ *
+ * Embedded version tracking without Git dependency.
+ * Supports milestones for explicit cleanup points.
+ */
+export declare interface PlanHistory {
+    /** All revisions in order */
+    revisions: PlanRevision[];
+    /** Current version */
+    currentVersion: string;
+    /** Milestones (explicit cleanup points) */
+    milestones?: PlanMilestone[];
+}
+
+/**
+ * Plan metadata from the directory and files
+ */
+export declare interface PlanMetadata {
+    /** Plan code (directory name, e.g., "big-splitup") */
+    code: string;
+    /** Human-readable name */
+    name: string;
+    /** Description from SUMMARY.md or meta-prompt */
+    description?: string;
+    /** Version (for tracking changes to the plan itself) */
+    version?: string;
+    /** Author */
+    author?: string;
+    /** Tags for categorization */
+    tags?: string[];
+    /** When the plan was created */
+    createdAt?: Date;
+    /** Path to the plan directory */
+    path: string;
+}
+
+/**
+ * A milestone in plan history (explicit cleanup point)
+ */
+export declare interface PlanMilestone {
+    /** Milestone name */
+    name: string;
+    /** Version at this milestone */
+    version: string;
+    /** When created */
+    createdAt: Date;
+    /** Description */
+    description?: string;
+}
+
+/**
+ * A phase grouping multiple steps
+ */
+export declare interface PlanPhase {
+    /** Phase number */
+    number: number;
+    /** Phase name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Steps in this phase */
+    steps: number[];
+    /** Phase status (derived from step statuses) */
+    status: TaskStatus;
+    /** Estimated duration */
+    estimatedDuration?: string;
+    /** Actual duration */
+    actualDuration?: string;
+}
+
+/**
+ * Plan registry containing all discovered plans
+ */
+export declare interface PlanRegistry {
+    /** Version of the registry format */
+    version: string;
+    /** When last updated */
+    lastUpdatedAt: Date;
+    /** Search paths for plan discovery */
+    searchPaths: string[];
+    /** All registered plans indexed by path */
+    plans: Map<string, RegisteredPlan>;
+    /** Index by code for quick lookup */
+    byCode: Map<string, string[]>;
+    /** Index by status */
+    byStatus: Map<TaskStatus, string[]>;
+}
+
+/**
+ * Relationship between plans
+ *
+ * Tracks dependencies, spawning, and other relationships
+ * between plans for cross-plan coordination.
+ */
+export declare interface PlanRelationship {
+    /** Type of relationship */
+    type: RelationshipType;
+    /** Related plan path */
+    planPath: string;
+    /** Specific step(s) involved */
+    steps?: number[];
+    /** Reason for relationship */
+    reason?: string;
+    /** When established */
+    createdAt: Date;
+}
+
+/**
+ * Result of executing a plan
+ */
+export declare interface PlanResult {
+    /** Whether the plan completed successfully */
+    success: boolean;
+    /** Steps that were executed */
+    executedSteps: number[];
+    /** Steps that succeeded */
+    completedSteps: number[];
+    /** Steps that failed */
+    failedSteps: number[];
+    /** Steps that were skipped */
+    skippedSteps: number[];
+    /** Total duration */
+    duration: number;
+    /** Final plan state */
+    finalState: PlanState;
+}
+
+/**
+ * A single revision in plan history
+ */
+export declare interface PlanRevision {
+    /** Version string (e.g., "0.1", "0.2") */
+    version: string;
+    /** When this revision was created */
+    createdAt: Date;
+    /** Commit message/description */
+    message?: string;
+    /** Author */
+    author?: string;
+    /** Feedback record that triggered this revision */
+    feedbackId?: string;
+}
+
+/**
+ * Current state of plan execution
+ */
+export declare interface PlanState {
+    /** Overall plan status */
+    status: TaskStatus;
+    /** Current step being executed */
+    currentStep?: number;
+    /** Last completed step */
+    lastCompletedStep?: number;
+    /** When execution started */
+    startedAt?: Date;
+    /** When last updated */
+    lastUpdatedAt: Date;
+    /** When completed */
+    completedAt?: Date;
+    /** Active blockers */
+    blockers: Blocker[];
+    /** Issues encountered */
+    issues: Issue[];
+    /** Progress percentage (0-100) */
+    progress: number;
+}
+
+/**
+ * A single step in a plan (corresponds to a numbered file like 01-STEP.md)
+ */
+export declare interface PlanStep {
+    /** Step number (1, 2, 3...) */
+    number: number;
+    /** Step code/slug (extracted from filename, e.g., "execution-interfaces") */
+    code: string;
+    /** Full filename (e.g., "01-execution-interfaces.md") */
+    filename: string;
+    /** Human-readable title */
+    title: string;
+    /** Step description */
+    description?: string;
+    /** Current status */
+    status: TaskStatus;
+    /** Dependencies on other steps (by number) */
+    dependencies?: number[];
+    /** When this step was started */
+    startedAt?: Date;
+    /** When this step was completed */
+    completedAt?: Date;
+    /** Duration in milliseconds */
+    duration?: number;
+    /** Notes or issues encountered */
+    notes?: string;
+    /** Path to the step file */
+    filePath: string;
+}
+
+/**
+ * A plan template definition
+ */
+export declare interface PlanTemplate {
+    /** Unique template ID */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Description of the template */
+    description: string;
+    /** Category */
+    category: "general" | "development" | "operations" | "documentation";
+    /** Tags for searchability */
+    tags: string[];
+    /** Default steps for this template */
+    steps: TemplateStep[];
+    /** Default phases (optional grouping) */
+    phases?: Array<{
+        name: string;
+        description: string;
+        steps: number[];
+    }>;
+    /** Custom SUMMARY.md content template */
+    summaryTemplate?: string;
+    /** Custom EXECUTION_PLAN.md content template */
+    executionPlanTemplate?: string;
+    /** Additional files to create */
+    additionalFiles?: Array<{
+        path: string;
+        content: string;
+    }>;
+}
+
+/**
+ * Priority level
+ */
+export declare type Priority = "high" | "medium" | "low";
+
+/**
+ * Weight multipliers for coverage scoring by priority
+ */
+export declare const PRIORITY_WEIGHTS: {
+    readonly must: 1;
+    readonly should: 0.7;
+    readonly could: 0.3;
+};
+
+/**
+ * Configuration for an execution provider
+ */
+export declare interface ProviderConfig {
+    /** Provider type */
+    type: ExecutionProviderType;
+    /** API key (if required) */
+    apiKey?: string;
+    /** Model to use */
+    model?: string;
+    /** Maximum tokens */
+    maxTokens?: number;
+    /** Temperature */
+    temperature?: number;
+}
+
+export declare const RefactoringTemplate: PlanTemplate;
+
+/**
+ * Refresh all plans in the registry
+ */
+export declare function refreshAllPlans(registry: PlanRegistry): Promise<{
+    updated: number;
+    removed: number;
+}>;
+
+/**
+ * Refresh a single plan's entry
+ *
+ * @param registry - The registry
+ * @param path - Path to the plan
+ * @returns Updated entry or null if plan no longer exists
+ */
+export declare function refreshPlan(registry: PlanRegistry, path: string): Promise<RegisteredPlan | null>;
+
+/**
+ * A registered plan entry
+ */
+export declare interface RegisteredPlan {
+    /** Plan code (directory name) */
+    code: string;
+    /** Human-readable name */
+    name: string;
+    /** Absolute path to plan directory */
+    path: string;
+    /** Overall status */
+    status: TaskStatus;
+    /** Progress percentage */
+    progress: number;
+    /** Number of steps */
+    stepCount: number;
+    /** Number of completed steps */
+    completedSteps: number;
+    /** When discovered/registered */
+    registeredAt: Date;
+    /** When last scanned */
+    lastScannedAt: Date;
+    /** Tags (if any) */
+    tags?: string[];
+    /** Description snippet */
+    description?: string;
+    /** Parent plan path (if spawned from another) */
+    parentPlan?: string;
+}
+
+/**
+ * Register a plan in the registry
+ */
+export declare function registerPlan(registry: PlanRegistry, entry: RegisteredPlan): void;
+
+/**
+ * Register all plan commands on a Commander program
+ */
+export declare function registerPlanCommands(program: Command): void;
+
+/**
+ * Register all render commands on a Commander program
+ */
+export declare function registerRenderCommands(program: Command): void;
+
+/**
+ * Register a template
+ */
+export declare function registerTemplate(template: PlanTemplate): void;
+
+/**
+ * Options for creating/loading a registry
+ */
+export declare interface RegistryOptions {
+    /** Search paths to scan for plans */
+    searchPaths?: string[];
+    /** Maximum depth to scan (default: 3) */
+    maxDepth?: number;
+    /** Include hidden directories (default: false) */
+    includeHidden?: boolean;
+    /** Directories to skip */
+    excludeDirs?: string[];
+}
+
+/**
+ * Get registry statistics
+ */
+export declare interface RegistryStats {
+    totalPlans: number;
+    byStatus: Record<TaskStatus, number>;
+    averageProgress: number;
+    oldestPlan?: RegisteredPlan;
+    newestPlan?: RegisteredPlan;
+    searchPathCount: number;
+}
+
+/**
+ * Type of relationship between plans
+ */
+export declare type RelationshipType = "spawned-from" | "spawned" | "blocks" | "blocked-by" | "related";
+
+/**
+ * Relationship validation result
+ */
+export declare interface RelationshipValidation {
+    /** All relationships valid */
+    valid: boolean;
+    /** Invalid relationships */
+    invalid: InvalidRelationship[];
+    /** Valid relationships */
+    validRelationships: PlanRelationship[];
+}
+
+/**
+ * Remove a relationship from a plan
+ *
+ * @param plan - The source plan
+ * @param targetPath - Path to the related plan to remove
+ * @param type - Optional type to match (removes all types if not specified)
+ * @returns Removed relationships
+ */
+export declare function removeRelationship(plan: Plan, targetPath: string, type?: RelationshipType): PlanRelationship[];
+
+/**
+ * Remove a step from a plan
+ */
+export declare function removeStep(plan: Plan, stepNumber: number): Promise<RemoveStepResult>;
+
+export declare interface RemoveStepResult {
+    /** Removed step */
+    removedStep: PlanStep;
+    /** Files that were renamed */
+    renamedFiles: Array<{
+        from: string;
+        to: string;
+    }>;
+    /** Deleted file path */
+    deletedFile: string;
+}
+
+/**
+ * Create the render command
+ */
+export declare function renderCommand(): Command;
+
+/**
+ * Supported render formats
+ */
+export declare type RenderFormat = "markdown" | "json" | "html";
+
+/**
+ * Render options (union of all format-specific options)
+ */
+export declare type RenderOptions = {
+    /** Output format */
+    format: RenderFormat;
+} & Partial<MarkdownRenderOptions & JsonRenderOptions & HtmlRenderOptions>;
+
+/**
+ * Render a plan to the specified format
+ */
+export declare function renderPlan(plan: Plan, options: RenderOptions): RenderResult;
+
+/**
+ * Result of rendering a plan
+ */
+export declare interface RenderResult {
+    /** Whether rendering succeeded */
+    success: boolean;
+    /** Rendered output content */
+    content?: string;
+    /** Output format */
+    format?: RenderFormat;
+    /** Error message if failed */
+    error?: string;
+}
+
+/**
+ * Render a plan to HTML
+ */
+export declare function renderToHtml(plan: Plan, options?: Partial<HtmlRenderOptions>): string;
+
+/**
+ * Render a plan to JSON
+ */
+export declare function renderToJson(plan: Plan, options?: Partial<JsonRenderOptions>): string;
+
+/**
+ * Render a plan to Markdown
+ */
+export declare function renderToMarkdown(plan: Plan, options?: Partial<MarkdownRenderOptions>): string;
+
+/**
+ * Resume a plan from its current state
+ *
+ * @param plan - The plan to resume
+ * @param context - Execution context
+ * @returns Plan result
+ *
+ * @stub Not yet implemented
+ */
+export declare function resumePlan(_plan: unknown, _context?: unknown): Promise<never>;
+
+/**
+ * Retrospective data structure
+ */
+export declare interface Retrospective {
+    /** Plan name */
+    planName: string;
+    /** Plan code */
+    planCode: string;
+    /** When the plan started */
+    startedAt?: Date;
+    /** When the plan completed */
+    completedAt?: Date;
+    /** Total duration in milliseconds */
+    duration?: number;
+    /** Total steps */
+    totalSteps: number;
+    /** Completed steps */
+    completedSteps: number;
+    /** Skipped steps */
+    skippedSteps: number;
+    /** What went well */
+    whatWentWell: string[];
+    /** What could improve */
+    whatCouldImprove: string[];
+    /** Key learnings */
+    keyLearnings: string[];
+    /** Action items for future */
+    actionItems: string[];
+    /** Steps summary */
+    stepsSummary: Array<{
+        number: number;
+        title: string;
+        status: string;
+        duration?: number;
+        notes?: string;
+    }>;
 }
 
 /**
- * Plan metadata from the directory and files
+ * Comparison result between revisions
  */
-export declare interface PlanMetadata {
-    /** Plan code (directory name, e.g., "big-splitup") */
-    code: string;
-    /** Human-readable name */
-    name: string;
-    /** Description from SUMMARY.md or meta-prompt */
-    description?: string;
-    /** Version (for tracking changes to the plan itself) */
-    version?: string;
-    /** Author */
-    author?: string;
-    /** Tags for categorization */
-    tags?: string[];
-    /** When the plan was created */
-    createdAt?: Date;
-    /** Path to the plan directory */
-    path: string;
+export declare interface RevisionComparison {
+    /** Earlier revision */
+    from: RevisionInfo;
+    /** Later revision */
+    to: RevisionInfo;
+    /** Time difference in milliseconds */
+    timeDiff: number;
+    /** Number of revisions between */
+    revisionCount: number;
 }
 
 /**
- * A phase grouping multiple steps
+ * Extended revision info with computed fields
  */
-export declare interface PlanPhase {
-    /** Phase number */
-    number: number;
-    /** Phase name */
-    name: string;
-    /** Description */
-    description?: string;
-    /** Steps in this phase */
-    steps: number[];
-    /** Phase status (derived from step statuses) */
-    status: TaskStatus;
-    /** Estimated duration */
-    estimatedDuration?: string;
-    /** Actual duration */
-    actualDuration?: string;
+export declare interface RevisionInfo extends PlanRevision {
+    /** Revision index in history */
+    index: number;
+    /** Whether this is the current revision */
+    isCurrent: boolean;
 }
 
 /**
- * Result of executing a plan
+ * Rollback result
  */
-export declare interface PlanResult {
-    /** Whether the plan completed successfully */
+export declare interface RollbackResult {
+    /** Whether rollback succeeded */
     success: boolean;
-    /** Steps that were executed */
-    executedSteps: number[];
-    /** Steps that succeeded */
-    completedSteps: number[];
-    /** Steps that failed */
-    failedSteps: number[];
-    /** Steps that were skipped */
-    skippedSteps: number[];
-    /** Total duration */
-    duration: number;
-    /** Final plan state */
-    finalState: PlanState;
+    /** Target milestone */
+    milestone?: MilestoneInfo;
+    /** New current version */
+    newVersion?: string;
+    /** Revisions rolled back */
+    revisionsRolledBack?: number;
+    /** Error message if failed */
+    error?: string;
 }
 
 /**
- * Current state of plan execution
+ * Rollback to a milestone
+ *
+ * This resets the current version to the milestone's version.
+ * Revisions after the milestone are kept but no longer current.
  */
-export declare interface PlanState {
-    /** Overall plan status */
-    status: TaskStatus;
-    /** Current step being executed */
-    currentStep?: number;
-    /** Last completed step */
-    lastCompletedStep?: number;
-    /** When execution started */
-    startedAt?: Date;
-    /** When last updated */
-    lastUpdatedAt: Date;
-    /** When completed */
-    completedAt?: Date;
-    /** Active blockers */
-    blockers: Blocker[];
-    /** Issues encountered */
-    issues: Issue[];
-    /** Progress percentage (0-100) */
-    progress: number;
-}
+export declare function rollbackToMilestone(history: PlanHistory, milestoneName: string): RollbackResult;
 
 /**
- * A single step in a plan (corresponds to a numbered file like 01-STEP.md)
+ * Save an amendment prompt to amendments/
  */
-export declare interface PlanStep {
-    /** Step number (1, 2, 3...) */
-    number: number;
-    /** Step code/slug (extracted from filename, e.g., "execution-interfaces") */
-    code: string;
-    /** Full filename (e.g., "01-execution-interfaces.md") */
-    filename: string;
-    /** Human-readable title */
-    title: string;
-    /** Step description */
-    description?: string;
-    /** Current status */
-    status: TaskStatus;
-    /** Dependencies on other steps (by number) */
-    dependencies?: number[];
-    /** When this step was started */
-    startedAt?: Date;
-    /** When this step was completed */
-    completedAt?: Date;
-    /** Duration in milliseconds */
-    duration?: number;
-    /** Notes or issues encountered */
-    notes?: string;
-    /** Path to the step file */
-    filePath: string;
+export declare function saveAmendmentPrompt(planPath: string, content: string, metadata?: Record<string, unknown>): Promise<string>;
+
+export declare interface SavedPrompt {
+    id: string;
+    timestamp: Date;
+    type: "initial" | "elaborate" | "amend";
+    content: string;
+    metadata?: Record<string, unknown>;
 }
 
 /**
- * Priority level
+ * Save an elaboration prompt to analysis/prompts/
  */
-export declare type Priority = "high" | "medium" | "low";
+export declare function saveElaborationPrompt(planPath: string, content: string, metadata?: Record<string, unknown>): Promise<string>;
 
 /**
- * Resume a plan from its current state
+ * Save history to disk
+ */
+export declare function saveHistory(history: PlanHistory, planPath: string): Promise<void>;
+
+/**
+ * Save the initial plan prompt
+ */
+export declare function saveInitialPrompt(planPath: string, planName: string, content: string): Promise<string>;
+
+/**
+ * Save registry to file
  *
- * @param plan - The plan to resume
- * @param context - Execution context
- * @returns Plan result
+ * @param registry - The registry to save
+ * @param path - Path to save to (defaults to home directory)
+ */
+export declare function saveRegistry(registry: PlanRegistry, path?: string): Promise<void>;
+
+/**
+ * Scan directories for plans and add them to registry
  *
- * @stub Not yet implemented
+ * @param registry - The registry to update
+ * @param options - Scan options
  */
-export declare function resumePlan(_plan: unknown, _context?: unknown): Promise<never>;
+export declare function scanForPlans(registry: PlanRegistry, options?: RegistryOptions): Promise<number>;
+
+/**
+ * Options for searching plans
+ */
+export declare interface SearchOptions {
+    /** Filter by status */
+    status?: TaskStatus | TaskStatus[];
+    /** Filter by code pattern (glob or regex) */
+    codePattern?: string;
+    /** Filter by name pattern */
+    namePattern?: string;
+    /** Filter by tag */
+    tags?: string[];
+    /** Minimum progress */
+    minProgress?: number;
+    /** Maximum progress */
+    maxProgress?: number;
+    /** Sort by field */
+    sortBy?: "name" | "code" | "progress" | "status" | "registeredAt";
+    /** Sort direction */
+    sortDir?: "asc" | "desc";
+    /** Limit results */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+}
+
+/**
+ * Search for plans in the registry
+ */
+export declare function searchPlans(registry: PlanRegistry, options?: SearchOptions): SearchResult;
+
+/**
+ * Result of a plan search
+ */
+export declare interface SearchResult {
+    /** Matching plans */
+    plans: RegisteredPlan[];
+    /** Total matches */
+    total: number;
+}
+
+/**
+ * Search templates by tag
+ */
+export declare function searchTemplatesByTag(tag: string): PlanTemplate[];
+
+/**
+ * Skip a step
+ */
+export declare function skipStep(plan: Plan, stepNumber: number, reason?: string): PlanStep;
+
+export declare const SprintTemplate: PlanTemplate;
+
+/**
+ * Start a step
+ */
+export declare function startStep(plan: Plan, stepNumber: number): PlanStep;
 
 /**
  * STATUS.md schema for parsing/generating
@@ -386,6 +2250,43 @@ export declare interface StatusDocument {
     notes?: string;
 }
 
+/**
+ * Result of checking step completion
+ */
+export declare interface StepCompletionResult {
+    stepNumber: number;
+    stepTitle: string;
+    status: StepCompletionStatus;
+    acceptanceCriteria: AcceptanceCriterion[];
+    markedStatus: string;
+    notes?: string;
+}
+
+/**
+ * Step completion status
+ */
+export declare type StepCompletionStatus = "complete" | "partial" | "incomplete" | "pending" | "skipped";
+
+/**
+ * Dependency information for a step
+ */
+export declare interface StepDependency {
+    /** The step that has dependencies */
+    stepNumber: number;
+    /** Steps this step depends on (must be completed before this step) */
+    dependsOn: number[];
+    /** Steps that depend on this step (blocked until this completes) */
+    blockedBy: number[];
+}
+
+/**
+ * Step executor interface
+ */
+export declare interface StepExecutor {
+    /** Execute a single step */
+    execute(context: ExecutionContext): Promise<StepResult>;
+}
+
 /**
  * Result of executing a step
  */
@@ -405,23 +2306,65 @@ export declare interface StepResult {
 }
 
 /**
- * RiotPlan Type Definitions
- *
- * Types for long-lived, stateful AI workflows (plans).
+ * Status of a task, phase, or step
+ */
+export declare type TaskStatus = "pending" | "in_progress" | "completed" | "failed" | "blocked" | "skipped";
+
+/**
+ * Create the template command group
+ */
+export declare function templateCommand(): Command;
+
+/**
+ * Create the template list command
+ */
+export declare function templateListCommand(): Command;
+
+/**
+ * Create the template show command
+ */
+export declare function templateShowCommand(): Command;
+
+/**
+ * Template Registry
  *
- * A plan consists of:
- * - A directory (the plan code/name)
- * - A meta-prompt (prompt-of-prompts)
- * - Numbered step files (01-STEP.md, 02-STEP.md, etc.)
- * - Status tracking (STATUS.md)
- * - Execution strategy (EXECUTION_PLAN.md)
- * - Summary (SUMMARY.md)
- * - Optional analysis directory
+ * Central registry for all available plan templates.
  */
 /**
- * Status of a task, phase, or step
+ * A step definition for a template
  */
-export declare type TaskStatus = "pending" | "in_progress" | "completed" | "failed" | "blocked" | "skipped";
+export declare interface TemplateStep {
+    /** Step title */
+    title: string;
+    /** Step description */
+    description: string;
+    /** Tasks in this step */
+    tasks?: string[];
+    /** Acceptance criteria */
+    criteria?: string[];
+}
+
+/**
+ * Create the template use command
+ */
+export declare function templateUseCommand(): Command;
+
+/**
+ * Unblock a step
+ */
+export declare function unblockStep(plan: Plan, stepNumber: number): PlanStep;
+
+/**
+ * Unregister a plan from the registry
+ */
+export declare function unregisterPlan(registry: PlanRegistry, path: string): boolean;
+
+/**
+ * Update a plan's SUMMARY.md with relationships
+ *
+ * @param plan - The plan to update
+ */
+export declare function updatePlanRelationships(plan: Plan): Promise<void>;
 
 /**
  * Update plan state after step completion
@@ -435,6 +2378,144 @@ export declare type TaskStatus = "pending" | "in_progress" | "completed" | "fail
  */
 export declare function updatePlanState(_plan: unknown, _stepNumber: number, _result: unknown): never;
 
+/**
+ * Update a plan's state based on status changes
+ */
+export declare function updateStatus(plan: Plan, updates: UpdateStatusOptions): Plan;
+
+export declare interface UpdateStatusOptions {
+    /** Step that was completed/updated */
+    step?: number;
+    /** New status for step */
+    stepStatus?: TaskStatus;
+    /** Add blocker */
+    addBlocker?: string;
+    /** Remove blocker by description match */
+    removeBlocker?: string;
+    /** Add issue */
+    addIssue?: {
+        title: string;
+        description: string;
+    };
+    /** Add note */
+    addNote?: string;
+}
+
+/**
+ * Update step dependencies in memory
+ *
+ * @param step - The step to update
+ * @param dependencies - New dependency list
+ * @returns Updated step
+ */
+export declare function updateStepDependencies(step: PlanStep, dependencies: number[]): PlanStep;
+
+/**
+ * Create the validate command
+ */
+export declare function validateCommand(): Command;
+
+/**
+ * Validate dependencies in a plan
+ *
+ * @param plan - The plan to validate
+ * @param graph - Optional pre-built dependency graph
+ * @param rawDeps - Optional raw dependencies map (before filtering)
+ * @returns Validation result
+ */
+export declare function validateDependencies(plan: Plan, graph?: DependencyGraph, rawDeps?: Map<number, number[]>): Promise<DependencyValidation>;
+
+export declare interface ValidateOptions {
+    /** Check step content */
+    validateContent?: boolean;
+    /** Check dependencies */
+    validateDependencies?: boolean;
+    /** Check STATUS.md consistency */
+    validateStatus?: boolean;
+    /** Strict mode (warnings become errors) */
+    strict?: boolean;
+}
+
+/**
+ * Validate a plan
+ */
+export declare function validatePlan(planPath: string, options?: ValidateOptions): Promise<ValidationResult>;
+
+/**
+ * Validate all relationships in a plan
+ *
+ * @param plan - The plan to validate
+ * @returns Validation result
+ */
+export declare function validateRelationships(plan: Plan): Promise<RelationshipValidation>;
+
+export declare interface ValidationError {
+    code: string;
+    message: string;
+    path?: string;
+    step?: number;
+}
+
+export declare interface ValidationInfo {
+    code: string;
+    message: string;
+}
+
+/**
+ * Plan Validation
+ *
+ * Validates plan structure, step numbering, dependencies, and content.
+ * Provides actionable error messages and identifies fixable issues.
+ */
+export declare interface ValidationResult {
+    /** Is the plan valid? */
+    valid: boolean;
+    /** Errors (must fix) */
+    errors: ValidationError[];
+    /** Warnings (should fix) */
+    warnings: ValidationWarning[];
+    /** Info (observations) */
+    info: ValidationInfo[];
+    /** Auto-fixable issues */
+    fixable: FixableIssue[];
+}
+
+export declare interface ValidationWarning {
+    code: string;
+    message: string;
+    path?: string;
+    step?: number;
+}
+
+/**
+ * A single verification criterion extracted from analysis
+ */
+export declare interface VerificationCriterion {
+    id: string;
+    text: string;
+    priority: CriteriaPriority;
+    source: string;
+    lineNumber?: number;
+}
+
+/**
+ * Full verification report
+ */
+export declare interface VerificationReport {
+    planPath: string;
+    timestamp: Date;
+    /** Analysis → Plan coverage (if analysis exists) */
+    coverage?: CoverageReport;
+    /** Plan → Execution completion */
+    completion?: CompletionReport;
+    /** Overall health score (0-100) */
+    healthScore: number;
+    /** Summary messages */
+    summary: string[];
+    /** Recommendations */
+    recommendations: string[];
+}
+
 export declare const VERSION = "0.0.1";
 
 export { }