ferix-code 0.0.2-beta.9 → 0.0.2

package/dist/index.d.ts

@@ -1,2679 +1,2 @@
-import { Schema, Brand, Stream, Effect, Context, Layer } from 'effect';
-import * as effect_Cause from 'effect/Cause';
-import * as effect_Types from 'effect/Types';
-import * as effect_Effect from 'effect/Effect';
-import * as effect_ParseResult from 'effect/ParseResult';
-import * as effect_SchemaAST from 'effect/SchemaAST';
 
-declare const LLMError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
-    readonly _tag: "LLMError";
-} & Readonly<A>;
-/**
- * Error that occurs during LLM execution.
- */
-declare class LLMError extends LLMError_base<{
-    readonly message: string;
-    readonly cause?: unknown;
-}> {
-}
-declare const ParseError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
-    readonly _tag: "ParseError";
-} & Readonly<A>;
-/**
- * Error that occurs when parsing signals from LLM output.
- */
-declare class ParseError extends ParseError_base<{
-    readonly message: string;
-    readonly input?: string;
-}> {
-}
-declare const PlanStoreError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
-    readonly _tag: "PlanStoreError";
-} & Readonly<A>;
-/**
- * Error that occurs during plan storage operations.
- */
-declare class PlanStoreError extends PlanStoreError_base<{
-    readonly message: string;
-    readonly operation: "create" | "load" | "update" | "list";
-    readonly cause?: unknown;
-}> {
-}
-declare const SessionStoreError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
-    readonly _tag: "SessionStoreError";
-} & Readonly<A>;
-/**
- * Error that occurs during session storage operations.
- */
-declare class SessionStoreError extends SessionStoreError_base<{
-    readonly message: string;
-    readonly operation: "create" | "get" | "update";
-    readonly cause?: unknown;
-}> {
-}
-declare const ProgressStoreError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
-    readonly _tag: "ProgressStoreError";
-} & Readonly<A>;
-/**
- * Error that occurs during progress storage operations.
- */
-declare class ProgressStoreError extends ProgressStoreError_base<{
-    readonly message: string;
-    readonly operation: "append" | "load" | "getRecent";
-    readonly cause?: unknown;
-}> {
-}
-declare const GuardrailsStoreError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
-    readonly _tag: "GuardrailsStoreError";
-} & Readonly<A>;
-/**
- * Error that occurs during guardrails storage operations.
- */
-declare class GuardrailsStoreError extends GuardrailsStoreError_base<{
-    readonly message: string;
-    readonly operation: "add" | "load" | "getActive";
-    readonly cause?: unknown;
-}> {
-}
-declare const OrchestratorError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
-    readonly _tag: "OrchestratorError";
-} & Readonly<A>;
-/**
- * Error that occurs during orchestrator execution.
- */
-declare class OrchestratorError extends OrchestratorError_base<{
-    readonly message: string;
-    readonly phase: "setup" | "discovery" | "iteration" | "cleanup";
-    readonly cause?: unknown;
-}> {
-}
-declare const GitError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
-    readonly _tag: "GitError";
-} & Readonly<A>;
-/**
- * Error that occurs during git operations.
- */
-declare class GitError extends GitError_base<{
-    readonly message: string;
-    readonly operation: "createWorktree" | "removeWorktree" | "commit" | "push" | "createPR" | "status";
-    readonly cause?: unknown;
-}> {
-}
-/**
- * Union of all possible errors in the system.
- */
-type FerixError = LLMError | ParseError | PlanStoreError | SessionStoreError | ProgressStoreError | GuardrailsStoreError | OrchestratorError | GitError;
-
-declare const PhasePromptOverridesSchema: Schema.Struct<{
-    breakdown: Schema.optional<typeof Schema.String>;
-    planning: Schema.optional<typeof Schema.String>;
-    execution: Schema.optional<typeof Schema.String>;
-    check: Schema.optional<typeof Schema.String>;
-    verify: Schema.optional<typeof Schema.String>;
-    review: Schema.optional<typeof Schema.String>;
-    completion: Schema.optional<typeof Schema.String>;
-}>;
-type PhasePromptOverrides = typeof PhasePromptOverridesSchema.Type;
-declare const PromptConfigSchema: Schema.Struct<{
-    systemPrompt: Schema.optional<typeof Schema.String>;
-    phases: Schema.optional<Schema.Struct<{
-        breakdown: Schema.optional<typeof Schema.String>;
-        planning: Schema.optional<typeof Schema.String>;
-        execution: Schema.optional<typeof Schema.String>;
-        check: Schema.optional<typeof Schema.String>;
-        verify: Schema.optional<typeof Schema.String>;
-        review: Schema.optional<typeof Schema.String>;
-        completion: Schema.optional<typeof Schema.String>;
-    }>>;
-    additionalContext: Schema.optional<typeof Schema.String>;
-}>;
-type PromptConfig = typeof PromptConfigSchema.Type;
-declare const LoopConfigSchema: Schema.Struct<{
-    task: typeof Schema.String;
-    maxIterations: typeof Schema.Number;
-    verifyCommands: Schema.Array$<typeof Schema.String>;
-    sessionId: Schema.optional<typeof Schema.String>;
-    branch: Schema.optional<typeof Schema.String>;
-    push: Schema.optional<typeof Schema.Boolean>;
-    pr: Schema.optional<typeof Schema.Boolean>;
-    verbose: Schema.optional<typeof Schema.Boolean>;
-    prompts: Schema.optional<Schema.Struct<{
-        systemPrompt: Schema.optional<typeof Schema.String>;
-        phases: Schema.optional<Schema.Struct<{
-            breakdown: Schema.optional<typeof Schema.String>;
-            planning: Schema.optional<typeof Schema.String>;
-            execution: Schema.optional<typeof Schema.String>;
-            check: Schema.optional<typeof Schema.String>;
-            verify: Schema.optional<typeof Schema.String>;
-            review: Schema.optional<typeof Schema.String>;
-            completion: Schema.optional<typeof Schema.String>;
-        }>>;
-        additionalContext: Schema.optional<typeof Schema.String>;
-    }>>;
-}>;
-type LoopConfig = typeof LoopConfigSchema.Type;
-declare const LoopSummarySchema: Schema.Struct<{
-    iterations: typeof Schema.Number;
-    success: typeof Schema.Boolean;
-    sessionId: typeof Schema.String;
-    completedTasks: Schema.Array$<typeof Schema.String>;
-    durationMs: typeof Schema.Number;
-}>;
-type LoopSummary = typeof LoopSummarySchema.Type;
-declare const LoopErrorSchema: Schema.Struct<{
-    message: typeof Schema.String;
-    phase: typeof Schema.String;
-    iteration: Schema.optional<typeof Schema.Number>;
-}>;
-type LoopError = typeof LoopErrorSchema.Type;
-declare const decodeLoopConfig: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
-    readonly task: string;
-    readonly maxIterations: number;
-    readonly verifyCommands: readonly string[];
-    readonly push?: boolean | undefined;
-    readonly sessionId?: string | undefined;
-    readonly branch?: string | undefined;
-    readonly pr?: boolean | undefined;
-    readonly verbose?: boolean | undefined;
-    readonly prompts?: {
-        readonly systemPrompt?: string | undefined;
-        readonly phases?: {
-            readonly breakdown?: string | undefined;
-            readonly planning?: string | undefined;
-            readonly execution?: string | undefined;
-            readonly check?: string | undefined;
-            readonly verify?: string | undefined;
-            readonly review?: string | undefined;
-            readonly completion?: string | undefined;
-        } | undefined;
-        readonly additionalContext?: string | undefined;
-    } | undefined;
-}, effect_ParseResult.ParseError, never>;
-
-/**
- * Loop lifecycle events.
- */
-declare const LoopStartedEventSchema: Schema.TaggedStruct<"LoopStarted", {
-    config: Schema.Struct<{
-        task: typeof Schema.String;
-        maxIterations: typeof Schema.Number;
-        verifyCommands: Schema.Array$<typeof Schema.String>;
-        sessionId: Schema.optional<typeof Schema.String>;
-        branch: Schema.optional<typeof Schema.String>;
-        push: Schema.optional<typeof Schema.Boolean>;
-        pr: Schema.optional<typeof Schema.Boolean>;
-        verbose: Schema.optional<typeof Schema.Boolean>;
-        prompts: Schema.optional<Schema.Struct<{
-            systemPrompt: Schema.optional<typeof Schema.String>;
-            phases: Schema.optional<Schema.Struct<{
-                breakdown: Schema.optional<typeof Schema.String>;
-                planning: Schema.optional<typeof Schema.String>;
-                execution: Schema.optional<typeof Schema.String>;
-                check: Schema.optional<typeof Schema.String>;
-                verify: Schema.optional<typeof Schema.String>;
-                review: Schema.optional<typeof Schema.String>;
-                completion: Schema.optional<typeof Schema.String>;
-            }>>;
-            additionalContext: Schema.optional<typeof Schema.String>;
-        }>>;
-    }>;
-    timestamp: typeof Schema.Number;
-}>;
-type LoopStartedEvent = typeof LoopStartedEventSchema.Type;
-declare const LoopCompletedEventSchema: Schema.TaggedStruct<"LoopCompleted", {
-    summary: Schema.Struct<{
-        iterations: typeof Schema.Number;
-        success: typeof Schema.Boolean;
-        sessionId: typeof Schema.String;
-        completedTasks: Schema.Array$<typeof Schema.String>;
-        durationMs: typeof Schema.Number;
-    }>;
-}>;
-type LoopCompletedEvent = typeof LoopCompletedEventSchema.Type;
-declare const LoopFailedEventSchema: Schema.TaggedStruct<"LoopFailed", {
-    error: Schema.Struct<{
-        message: typeof Schema.String;
-        phase: typeof Schema.String;
-        iteration: Schema.optional<typeof Schema.Number>;
-    }>;
-}>;
-type LoopFailedEvent = typeof LoopFailedEventSchema.Type;
-/**
- * Discovery phase events.
- */
-declare const DiscoveryStartedEventSchema: Schema.TaggedStruct<"DiscoveryStarted", {
-    timestamp: typeof Schema.Number;
-}>;
-type DiscoveryStartedEvent = typeof DiscoveryStartedEventSchema.Type;
-declare const DiscoveryCompletedEventSchema: Schema.TaggedStruct<"DiscoveryCompleted", {
-    taskCount: typeof Schema.Number;
-    timestamp: typeof Schema.Number;
-}>;
-type DiscoveryCompletedEvent = typeof DiscoveryCompletedEventSchema.Type;
-/**
- * Iteration events.
- */
-declare const IterationStartedEventSchema: Schema.TaggedStruct<"IterationStarted", {
-    iteration: typeof Schema.Number;
-}>;
-type IterationStartedEvent = typeof IterationStartedEventSchema.Type;
-declare const IterationCompletedEventSchema: Schema.TaggedStruct<"IterationCompleted", {
-    iteration: typeof Schema.Number;
-}>;
-type IterationCompletedEvent = typeof IterationCompletedEventSchema.Type;
-/**
- * LLM events.
- */
-declare const LLMTextEventSchema: Schema.TaggedStruct<"LLMText", {
-    text: typeof Schema.String;
-}>;
-type LLMTextEvent = typeof LLMTextEventSchema.Type;
-declare const LLMToolStartEventSchema: Schema.TaggedStruct<"LLMToolStart", {
-    tool: typeof Schema.String;
-}>;
-type LLMToolStartEvent = typeof LLMToolStartEventSchema.Type;
-declare const LLMToolUseEventSchema: Schema.TaggedStruct<"LLMToolUse", {
-    tool: typeof Schema.String;
-    input: typeof Schema.Unknown;
-}>;
-type LLMToolUseEvent = typeof LLMToolUseEventSchema.Type;
-declare const LLMToolEndEventSchema: Schema.TaggedStruct<"LLMToolEnd", {
-    tool: typeof Schema.String;
-}>;
-type LLMToolEndEvent = typeof LLMToolEndEventSchema.Type;
-/**
- * Task/Phase/Criteria definition events.
- */
-declare const TasksDefinedEventSchema: Schema.TaggedStruct<"TasksDefined", Readonly<{
-    tasks: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        title: typeof Schema.String;
-        description: typeof Schema.String;
-    }>>;
-}> & Schema.Struct.Fields>;
-type TasksDefinedEvent = typeof TasksDefinedEventSchema.Type;
-declare const PhasesDefinedEventSchema: Schema.TaggedStruct<"PhasesDefined", Readonly<{
-    taskId: typeof Schema.String;
-    phases: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        description: typeof Schema.String;
-    }>>;
-}> & Schema.Struct.Fields>;
-type PhasesDefinedEvent = typeof PhasesDefinedEventSchema.Type;
-declare const CriteriaDefinedEventSchema: Schema.TaggedStruct<"CriteriaDefined", Readonly<{
-    taskId: typeof Schema.String;
-    criteria: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        description: typeof Schema.String;
-    }>>;
-}> & Schema.Struct.Fields>;
-type CriteriaDefinedEvent = typeof CriteriaDefinedEventSchema.Type;
-/**
- * Phase lifecycle events.
- */
-declare const PhaseStartedEventSchema: Schema.TaggedStruct<"PhaseStarted", Readonly<{
-    phaseId: typeof Schema.String;
-}> & Schema.Struct.Fields>;
-type PhaseStartedEvent = typeof PhaseStartedEventSchema.Type;
-declare const PhaseCompletedEventSchema: Schema.TaggedStruct<"PhaseCompleted", Readonly<{
-    phaseId: typeof Schema.String;
-}> & Schema.Struct.Fields>;
-type PhaseCompletedEvent = typeof PhaseCompletedEventSchema.Type;
-declare const PhaseFailedEventSchema: Schema.TaggedStruct<"PhaseFailed", Readonly<{
-    phaseId: typeof Schema.String;
-    reason: typeof Schema.String;
-}> & Schema.Struct.Fields>;
-type PhaseFailedEvent = typeof PhaseFailedEventSchema.Type;
-/**
- * Criterion events.
- */
-declare const CriterionPassedEventSchema: Schema.TaggedStruct<"CriterionPassed", Readonly<{
-    criterionId: typeof Schema.String;
-}> & Schema.Struct.Fields>;
-type CriterionPassedEvent = typeof CriterionPassedEventSchema.Type;
-declare const CriterionFailedEventSchema: Schema.TaggedStruct<"CriterionFailed", Readonly<{
-    criterionId: typeof Schema.String;
-    reason: typeof Schema.String;
-}> & Schema.Struct.Fields>;
-type CriterionFailedEvent = typeof CriterionFailedEventSchema.Type;
-/**
- * Check events.
- */
-declare const CheckPassedEventSchema: Schema.TaggedStruct<"CheckPassed", {}>;
-type CheckPassedEvent = typeof CheckPassedEventSchema.Type;
-declare const CheckFailedEventSchema: Schema.TaggedStruct<"CheckFailed", {
-    failedCriteria: Schema.Array$<typeof Schema.String>;
-}>;
-type CheckFailedEvent = typeof CheckFailedEventSchema.Type;
-/**
- * Review event.
- */
-declare const ReviewCompleteEventSchema: Schema.TaggedStruct<"ReviewComplete", Readonly<{
-    changesMade: typeof Schema.Boolean;
-}> & Schema.Struct.Fields>;
-type ReviewCompleteEvent = typeof ReviewCompleteEventSchema.Type;
-/**
- * Task completion event.
- */
-declare const TaskCompletedEventSchema: Schema.TaggedStruct<"TaskCompleted", Readonly<{
-    taskId: typeof Schema.String;
-    summary: typeof Schema.String;
-}> & Schema.Struct.Fields>;
-type TaskCompletedEvent = typeof TaskCompletedEventSchema.Type;
-/**
- * Plan events.
- */
-declare const PlanCreatedEventSchema: Schema.TaggedStruct<"PlanCreated", {
-    plan: Schema.Struct<{
-        id: typeof Schema.String;
-        sessionId: typeof Schema.String;
-        createdAt: typeof Schema.String;
-        originalTask: typeof Schema.String;
-        context: Schema.optional<typeof Schema.String>;
-        tasks: Schema.Array$<Schema.Struct<{
-            id: typeof Schema.String;
-            title: typeof Schema.String;
-            description: typeof Schema.String;
-            status: Schema.Literal<["pending", "planning", "in_progress", "done", "failed", "skipped"]>;
-            phases: Schema.Array$<Schema.Struct<{
-                id: typeof Schema.String;
-                description: typeof Schema.String;
-                status: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-            }>>;
-            criteria: Schema.Array$<Schema.Struct<{
-                id: typeof Schema.String;
-                description: typeof Schema.String;
-                status: Schema.Literal<["pending", "passed", "failed"]>;
-                failureReason: Schema.optional<typeof Schema.String>;
-            }>>;
-            filesToModify: Schema.Array$<typeof Schema.String>;
-            attempts: typeof Schema.Number;
-            completionNotes: Schema.optional<typeof Schema.String>;
-        }>>;
-    }>;
-}>;
-type PlanCreatedEvent = typeof PlanCreatedEventSchema.Type;
-declare const PlanUpdatedEventSchema: Schema.TaggedStruct<"PlanUpdated", {
-    plan: Schema.Struct<{
-        id: typeof Schema.String;
-        sessionId: typeof Schema.String;
-        createdAt: typeof Schema.String;
-        originalTask: typeof Schema.String;
-        context: Schema.optional<typeof Schema.String>;
-        tasks: Schema.Array$<Schema.Struct<{
-            id: typeof Schema.String;
-            title: typeof Schema.String;
-            description: typeof Schema.String;
-            status: Schema.Literal<["pending", "planning", "in_progress", "done", "failed", "skipped"]>;
-            phases: Schema.Array$<Schema.Struct<{
-                id: typeof Schema.String;
-                description: typeof Schema.String;
-                status: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-            }>>;
-            criteria: Schema.Array$<Schema.Struct<{
-                id: typeof Schema.String;
-                description: typeof Schema.String;
-                status: Schema.Literal<["pending", "passed", "failed"]>;
-                failureReason: Schema.optional<typeof Schema.String>;
-            }>>;
-            filesToModify: Schema.Array$<typeof Schema.String>;
-            attempts: typeof Schema.Number;
-            completionNotes: Schema.optional<typeof Schema.String>;
-        }>>;
-    }>;
-}>;
-type PlanUpdatedEvent = typeof PlanUpdatedEventSchema.Type;
-declare const PlanUpdateFailedEventSchema: Schema.TaggedStruct<"PlanUpdateFailed", {
-    operation: Schema.Literal<["create", "update"]>;
-    error: typeof Schema.String;
-    planId: Schema.optional<typeof Schema.String>;
-}>;
-type PlanUpdateFailedEvent = typeof PlanUpdateFailedEventSchema.Type;
-/**
- * Learning recorded event - captures insights discovered during iteration.
- */
-declare const LearningRecordedEventSchema: Schema.TaggedStruct<"LearningRecorded", {
-    iteration: typeof Schema.Number;
-    content: typeof Schema.String;
-    category: Schema.optional<Schema.Literal<["success", "failure", "optimization"]>>;
-    timestamp: typeof Schema.Number;
-}>;
-type LearningRecordedEvent = typeof LearningRecordedEventSchema.Type;
-/**
- * Guardrail added event - captures failure patterns to avoid.
- */
-declare const GuardrailAddedEventSchema: Schema.TaggedStruct<"GuardrailAdded", {
-    id: typeof Schema.String;
-    iteration: typeof Schema.Number;
-    pattern: typeof Schema.String;
-    sign: typeof Schema.String;
-    avoidance: typeof Schema.String;
-    severity: Schema.Literal<["warning", "critical"]>;
-    timestamp: typeof Schema.Number;
-}>;
-type GuardrailAddedEvent = typeof GuardrailAddedEventSchema.Type;
-/**
- * Progress updated event - signals that progress file was updated.
- */
-declare const ProgressUpdatedEventSchema: Schema.TaggedStruct<"ProgressUpdated", {
-    sessionId: typeof Schema.String;
-    iteration: typeof Schema.Number;
-    taskId: typeof Schema.String;
-    action: Schema.Literal<["started", "completed", "failed", "learning"]>;
-    timestamp: typeof Schema.Number;
-}>;
-type ProgressUpdatedEvent = typeof ProgressUpdatedEventSchema.Type;
-/**
- * Worktree created event - signals that a git worktree was created for the session.
- */
-declare const WorktreeCreatedEventSchema: Schema.TaggedStruct<"WorktreeCreated", {
-    sessionId: typeof Schema.String;
-    worktreePath: typeof Schema.String;
-    branchName: typeof Schema.String;
-    timestamp: typeof Schema.Number;
-}>;
-type WorktreeCreatedEvent = typeof WorktreeCreatedEventSchema.Type;
-/**
- * Worktree removed event - signals that a git worktree was cleaned up.
- */
-declare const WorktreeRemovedEventSchema: Schema.TaggedStruct<"WorktreeRemoved", {
-    sessionId: typeof Schema.String;
-    timestamp: typeof Schema.Number;
-}>;
-type WorktreeRemovedEvent = typeof WorktreeRemovedEventSchema.Type;
-/**
- * Union of all domain events.
- */
-declare const DomainEventSchema: Schema.Union<[Schema.TaggedStruct<"LoopStarted", {
-    config: Schema.Struct<{
-        task: typeof Schema.String;
-        maxIterations: typeof Schema.Number;
-        verifyCommands: Schema.Array$<typeof Schema.String>;
-        sessionId: Schema.optional<typeof Schema.String>;
-        branch: Schema.optional<typeof Schema.String>;
-        push: Schema.optional<typeof Schema.Boolean>;
-        pr: Schema.optional<typeof Schema.Boolean>;
-        verbose: Schema.optional<typeof Schema.Boolean>;
-        prompts: Schema.optional<Schema.Struct<{
-            systemPrompt: Schema.optional<typeof Schema.String>;
-            phases: Schema.optional<Schema.Struct<{
-                breakdown: Schema.optional<typeof Schema.String>;
-                planning: Schema.optional<typeof Schema.String>;
-                execution: Schema.optional<typeof Schema.String>;
-                check: Schema.optional<typeof Schema.String>;
-                verify: Schema.optional<typeof Schema.String>;
-                review: Schema.optional<typeof Schema.String>;
-                completion: Schema.optional<typeof Schema.String>;
-            }>>;
-            additionalContext: Schema.optional<typeof Schema.String>;
-        }>>;
-    }>;
-    timestamp: typeof Schema.Number;
-}>, Schema.TaggedStruct<"LoopCompleted", {
-    summary: Schema.Struct<{
-        iterations: typeof Schema.Number;
-        success: typeof Schema.Boolean;
-        sessionId: typeof Schema.String;
-        completedTasks: Schema.Array$<typeof Schema.String>;
-        durationMs: typeof Schema.Number;
-    }>;
-}>, Schema.TaggedStruct<"LoopFailed", {
-    error: Schema.Struct<{
-        message: typeof Schema.String;
-        phase: typeof Schema.String;
-        iteration: Schema.optional<typeof Schema.Number>;
-    }>;
-}>, Schema.TaggedStruct<"DiscoveryStarted", {
-    timestamp: typeof Schema.Number;
-}>, Schema.TaggedStruct<"DiscoveryCompleted", {
-    taskCount: typeof Schema.Number;
-    timestamp: typeof Schema.Number;
-}>, Schema.TaggedStruct<"IterationStarted", {
-    iteration: typeof Schema.Number;
-}>, Schema.TaggedStruct<"IterationCompleted", {
-    iteration: typeof Schema.Number;
-}>, Schema.TaggedStruct<"LLMText", {
-    text: typeof Schema.String;
-}>, Schema.TaggedStruct<"LLMToolStart", {
-    tool: typeof Schema.String;
-}>, Schema.TaggedStruct<"LLMToolUse", {
-    tool: typeof Schema.String;
-    input: typeof Schema.Unknown;
-}>, Schema.TaggedStruct<"LLMToolEnd", {
-    tool: typeof Schema.String;
-}>, Schema.TaggedStruct<"TasksDefined", Readonly<{
-    tasks: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        title: typeof Schema.String;
-        description: typeof Schema.String;
-    }>>;
-}> & Schema.Struct.Fields>, Schema.TaggedStruct<"PhasesDefined", Readonly<{
-    taskId: typeof Schema.String;
-    phases: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        description: typeof Schema.String;
-    }>>;
-}> & Schema.Struct.Fields>, Schema.TaggedStruct<"CriteriaDefined", Readonly<{
-    taskId: typeof Schema.String;
-    criteria: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        description: typeof Schema.String;
-    }>>;
-}> & Schema.Struct.Fields>, Schema.TaggedStruct<"PhaseStarted", Readonly<{
-    phaseId: typeof Schema.String;
-}> & Schema.Struct.Fields>, Schema.TaggedStruct<"PhaseCompleted", Readonly<{
-    phaseId: typeof Schema.String;
-}> & Schema.Struct.Fields>, Schema.TaggedStruct<"PhaseFailed", Readonly<{
-    phaseId: typeof Schema.String;
-    reason: typeof Schema.String;
-}> & Schema.Struct.Fields>, Schema.TaggedStruct<"CriterionPassed", Readonly<{
-    criterionId: typeof Schema.String;
-}> & Schema.Struct.Fields>, Schema.TaggedStruct<"CriterionFailed", Readonly<{
-    criterionId: typeof Schema.String;
-    reason: typeof Schema.String;
-}> & Schema.Struct.Fields>, Schema.TaggedStruct<"CheckPassed", {}>, Schema.TaggedStruct<"CheckFailed", {
-    failedCriteria: Schema.Array$<typeof Schema.String>;
-}>, Schema.TaggedStruct<"ReviewComplete", Readonly<{
-    changesMade: typeof Schema.Boolean;
-}> & Schema.Struct.Fields>, Schema.TaggedStruct<"TaskCompleted", Readonly<{
-    taskId: typeof Schema.String;
-    summary: typeof Schema.String;
-}> & Schema.Struct.Fields>, Schema.TaggedStruct<"PlanCreated", {
-    plan: Schema.Struct<{
-        id: typeof Schema.String;
-        sessionId: typeof Schema.String;
-        createdAt: typeof Schema.String;
-        originalTask: typeof Schema.String;
-        context: Schema.optional<typeof Schema.String>;
-        tasks: Schema.Array$<Schema.Struct<{
-            id: typeof Schema.String;
-            title: typeof Schema.String;
-            description: typeof Schema.String;
-            status: Schema.Literal<["pending", "planning", "in_progress", "done", "failed", "skipped"]>;
-            phases: Schema.Array$<Schema.Struct<{
-                id: typeof Schema.String;
-                description: typeof Schema.String;
-                status: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-            }>>;
-            criteria: Schema.Array$<Schema.Struct<{
-                id: typeof Schema.String;
-                description: typeof Schema.String;
-                status: Schema.Literal<["pending", "passed", "failed"]>;
-                failureReason: Schema.optional<typeof Schema.String>;
-            }>>;
-            filesToModify: Schema.Array$<typeof Schema.String>;
-            attempts: typeof Schema.Number;
-            completionNotes: Schema.optional<typeof Schema.String>;
-        }>>;
-    }>;
-}>, Schema.TaggedStruct<"PlanUpdated", {
-    plan: Schema.Struct<{
-        id: typeof Schema.String;
-        sessionId: typeof Schema.String;
-        createdAt: typeof Schema.String;
-        originalTask: typeof Schema.String;
-        context: Schema.optional<typeof Schema.String>;
-        tasks: Schema.Array$<Schema.Struct<{
-            id: typeof Schema.String;
-            title: typeof Schema.String;
-            description: typeof Schema.String;
-            status: Schema.Literal<["pending", "planning", "in_progress", "done", "failed", "skipped"]>;
-            phases: Schema.Array$<Schema.Struct<{
-                id: typeof Schema.String;
-                description: typeof Schema.String;
-                status: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-            }>>;
-            criteria: Schema.Array$<Schema.Struct<{
-                id: typeof Schema.String;
-                description: typeof Schema.String;
-                status: Schema.Literal<["pending", "passed", "failed"]>;
-                failureReason: Schema.optional<typeof Schema.String>;
-            }>>;
-            filesToModify: Schema.Array$<typeof Schema.String>;
-            attempts: typeof Schema.Number;
-            completionNotes: Schema.optional<typeof Schema.String>;
-        }>>;
-    }>;
-}>, Schema.TaggedStruct<"PlanUpdateFailed", {
-    operation: Schema.Literal<["create", "update"]>;
-    error: typeof Schema.String;
-    planId: Schema.optional<typeof Schema.String>;
-}>, Schema.TaggedStruct<"LearningRecorded", {
-    iteration: typeof Schema.Number;
-    content: typeof Schema.String;
-    category: Schema.optional<Schema.Literal<["success", "failure", "optimization"]>>;
-    timestamp: typeof Schema.Number;
-}>, Schema.TaggedStruct<"GuardrailAdded", {
-    id: typeof Schema.String;
-    iteration: typeof Schema.Number;
-    pattern: typeof Schema.String;
-    sign: typeof Schema.String;
-    avoidance: typeof Schema.String;
-    severity: Schema.Literal<["warning", "critical"]>;
-    timestamp: typeof Schema.Number;
-}>, Schema.TaggedStruct<"ProgressUpdated", {
-    sessionId: typeof Schema.String;
-    iteration: typeof Schema.Number;
-    taskId: typeof Schema.String;
-    action: Schema.Literal<["started", "completed", "failed", "learning"]>;
-    timestamp: typeof Schema.Number;
-}>, Schema.TaggedStruct<"WorktreeCreated", {
-    sessionId: typeof Schema.String;
-    worktreePath: typeof Schema.String;
-    branchName: typeof Schema.String;
-    timestamp: typeof Schema.Number;
-}>, Schema.TaggedStruct<"WorktreeRemoved", {
-    sessionId: typeof Schema.String;
-    timestamp: typeof Schema.Number;
-}>]>;
-/**
- * Explicit discriminated union type for proper TypeScript narrowing.
- */
-type DomainEvent = LoopStartedEvent | LoopCompletedEvent | LoopFailedEvent | DiscoveryStartedEvent | DiscoveryCompletedEvent | IterationStartedEvent | IterationCompletedEvent | LLMTextEvent | LLMToolStartEvent | LLMToolUseEvent | LLMToolEndEvent | TasksDefinedEvent | PhasesDefinedEvent | CriteriaDefinedEvent | PhaseStartedEvent | PhaseCompletedEvent | PhaseFailedEvent | CriterionPassedEvent | CriterionFailedEvent | CheckPassedEvent | CheckFailedEvent | ReviewCompleteEvent | TaskCompletedEvent | PlanCreatedEvent | PlanUpdatedEvent | PlanUpdateFailedEvent | LearningRecordedEvent | GuardrailAddedEvent | ProgressUpdatedEvent | WorktreeCreatedEvent | WorktreeRemovedEvent;
-/**
- * Type guard utilities for domain events.
- */
-declare const DomainEventUtils: {
-    readonly isLLMEvent: (e: DomainEvent) => e is LLMTextEvent | LLMToolStartEvent | LLMToolUseEvent | LLMToolEndEvent;
-    readonly isPhaseEvent: (e: DomainEvent) => e is PhaseStartedEvent | PhaseCompletedEvent | PhaseFailedEvent;
-    readonly isCriterionEvent: (e: DomainEvent) => e is CriterionPassedEvent | CriterionFailedEvent;
-    readonly isLoopEvent: (e: DomainEvent) => e is LoopStartedEvent | LoopCompletedEvent | LoopFailedEvent;
-    readonly isDiscoveryEvent: (e: DomainEvent) => e is DiscoveryStartedEvent | DiscoveryCompletedEvent;
-};
-
-/**
- * Severity levels for guardrails.
- */
-declare const GuardrailSeveritySchema: Schema.Literal<["warning", "critical"]>;
-type GuardrailSeverity = typeof GuardrailSeveritySchema.Type;
-/**
- * A guardrail represents a failure pattern to avoid.
- *
- * Guardrails are learned from previous iteration failures and
- * help prevent the LLM from repeating the same mistakes.
- */
-declare const GuardrailSchema: Schema.Struct<{
-    id: typeof Schema.String;
-    createdAt: typeof Schema.String;
-    iteration: typeof Schema.Number;
-    pattern: typeof Schema.String;
-    sign: typeof Schema.String;
-    avoidance: typeof Schema.String;
-    severity: Schema.Literal<["warning", "critical"]>;
-}>;
-type Guardrail = typeof GuardrailSchema.Type;
-/**
- * The complete guardrails file structure.
- *
- * Contains session metadata and an array of guardrails.
- * This is the structure persisted to `.ferix/plans/:sessionId/guardrails.md`.
- */
-declare const GuardrailsFileSchema: Schema.Struct<{
-    sessionId: typeof Schema.String;
-    createdAt: typeof Schema.String;
-    guardrails: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        createdAt: typeof Schema.String;
-        iteration: typeof Schema.Number;
-        pattern: typeof Schema.String;
-        sign: typeof Schema.String;
-        avoidance: typeof Schema.String;
-        severity: Schema.Literal<["warning", "critical"]>;
-    }>>;
-}>;
-type GuardrailsFile = typeof GuardrailsFileSchema.Type;
-/**
- * Decode helpers.
- */
-declare const decodeGuardrail: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
-    readonly iteration: number;
-    readonly id: string;
-    readonly createdAt: string;
-    readonly pattern: string;
-    readonly sign: string;
-    readonly avoidance: string;
-    readonly severity: "warning" | "critical";
-}, effect_ParseResult.ParseError, never>;
-declare const decodeGuardrailsFile: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
-    readonly sessionId: string;
-    readonly createdAt: string;
-    readonly guardrails: readonly {
-        readonly iteration: number;
-        readonly id: string;
-        readonly createdAt: string;
-        readonly pattern: string;
-        readonly sign: string;
-        readonly avoidance: string;
-        readonly severity: "warning" | "critical";
-    }[];
-}, effect_ParseResult.ParseError, never>;
-
-declare const TextEventSchema: Schema.TaggedStruct<"Text", {
-    text: typeof Schema.String;
-}>;
-declare const ToolStartEventSchema: Schema.TaggedStruct<"ToolStart", {
-    tool: typeof Schema.String;
-}>;
-declare const ToolUseEventSchema: Schema.TaggedStruct<"ToolUse", {
-    tool: typeof Schema.String;
-    input: typeof Schema.Unknown;
-}>;
-declare const ToolEndEventSchema: Schema.TaggedStruct<"ToolEnd", {
-    tool: typeof Schema.String;
-}>;
-declare const DoneEventSchema: Schema.TaggedStruct<"Done", {
-    output: typeof Schema.String;
-}>;
-declare const LLMEventSchema: Schema.Union<[Schema.TaggedStruct<"Text", {
-    text: typeof Schema.String;
-}>, Schema.TaggedStruct<"ToolStart", {
-    tool: typeof Schema.String;
-}>, Schema.TaggedStruct<"ToolUse", {
-    tool: typeof Schema.String;
-    input: typeof Schema.Unknown;
-}>, Schema.TaggedStruct<"ToolEnd", {
-    tool: typeof Schema.String;
-}>, Schema.TaggedStruct<"Done", {
-    output: typeof Schema.String;
-}>]>;
-type TextEvent = typeof TextEventSchema.Type;
-type ToolStartEvent = typeof ToolStartEventSchema.Type;
-type ToolUseEvent = typeof ToolUseEventSchema.Type;
-type ToolEndEvent = typeof ToolEndEventSchema.Type;
-type DoneEvent = typeof DoneEventSchema.Type;
-type LLMEvent = TextEvent | ToolStartEvent | ToolUseEvent | ToolEndEvent | DoneEvent;
-declare const decodeLLMEvent: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
-    readonly _tag: "Text";
-    readonly text: string;
-} | {
-    readonly _tag: "ToolStart";
-    readonly tool: string;
-} | {
-    readonly input: unknown;
-    readonly _tag: "ToolUse";
-    readonly tool: string;
-} | {
-    readonly _tag: "ToolEnd";
-    readonly tool: string;
-} | {
-    readonly _tag: "Done";
-    readonly output: string;
-}, effect_ParseResult.ParseError, never>;
-
-declare const LogLevelSchema: Schema.Literal<["debug", "info", "warn", "error"]>;
-type LogLevel = typeof LogLevelSchema.Type;
-declare const LogEntrySchema: Schema.Struct<{
-    level: Schema.Literal<["debug", "info", "warn", "error"]>;
-    message: typeof Schema.String;
-    timestamp: typeof Schema.String;
-    context: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
-}>;
-type LogEntry = typeof LogEntrySchema.Type;
-declare const ConsoleLoggerConfigSchema: Schema.Struct<{
-    level: Schema.optional<Schema.Literal<["debug", "info", "warn", "error"]>>;
-    colors: Schema.optional<typeof Schema.Boolean>;
-}>;
-type ConsoleLoggerConfig = typeof ConsoleLoggerConfigSchema.Type;
-declare const FileLoggerConfigSchema: Schema.Struct<{
-    path: Schema.optional<typeof Schema.String>;
-    level: Schema.optional<Schema.Literal<["debug", "info", "warn", "error"]>>;
-}>;
-type FileLoggerConfig = typeof FileLoggerConfigSchema.Type;
-
-/**
- * Branded PlanId type.
- */
-type PlanId = string & Brand.Brand<"PlanId">;
-declare const PlanId: Brand.Brand.Constructor<PlanId>;
-/**
- * Status schemas.
- */
-declare const TaskStatusSchema: Schema.Literal<["pending", "planning", "in_progress", "done", "failed", "skipped"]>;
-type TaskStatus = typeof TaskStatusSchema.Type;
-declare const PhaseStatusSchema: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-type PhaseStatus = typeof PhaseStatusSchema.Type;
-declare const CriterionStatusSchema: Schema.Literal<["pending", "passed", "failed"]>;
-type CriterionStatus = typeof CriterionStatusSchema.Type;
-/**
- * Phase schema.
- */
-declare const PhaseSchema: Schema.Struct<{
-    id: typeof Schema.String;
-    description: typeof Schema.String;
-    status: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-}>;
-type Phase = typeof PhaseSchema.Type;
-/**
- * Criterion schema.
- */
-declare const CriterionSchema: Schema.Struct<{
-    id: typeof Schema.String;
-    description: typeof Schema.String;
-    status: Schema.Literal<["pending", "passed", "failed"]>;
-    failureReason: Schema.optional<typeof Schema.String>;
-}>;
-type Criterion = typeof CriterionSchema.Type;
-/**
- * Task schema.
- */
-declare const TaskSchema: Schema.Struct<{
-    id: typeof Schema.String;
-    title: typeof Schema.String;
-    description: typeof Schema.String;
-    status: Schema.Literal<["pending", "planning", "in_progress", "done", "failed", "skipped"]>;
-    phases: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        description: typeof Schema.String;
-        status: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-    }>>;
-    criteria: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        description: typeof Schema.String;
-        status: Schema.Literal<["pending", "passed", "failed"]>;
-        failureReason: Schema.optional<typeof Schema.String>;
-    }>>;
-    filesToModify: Schema.Array$<typeof Schema.String>;
-    attempts: typeof Schema.Number;
-    completionNotes: Schema.optional<typeof Schema.String>;
-}>;
-type Task = typeof TaskSchema.Type;
-/**
- * Plan data schema (without id, for deserialization).
- */
-declare const PlanDataSchema: Schema.Struct<{
-    sessionId: typeof Schema.String;
-    createdAt: typeof Schema.String;
-    originalTask: typeof Schema.String;
-    context: Schema.optional<typeof Schema.String>;
-    tasks: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        title: typeof Schema.String;
-        description: typeof Schema.String;
-        status: Schema.Literal<["pending", "planning", "in_progress", "done", "failed", "skipped"]>;
-        phases: Schema.Array$<Schema.Struct<{
-            id: typeof Schema.String;
-            description: typeof Schema.String;
-            status: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-        }>>;
-        criteria: Schema.Array$<Schema.Struct<{
-            id: typeof Schema.String;
-            description: typeof Schema.String;
-            status: Schema.Literal<["pending", "passed", "failed"]>;
-            failureReason: Schema.optional<typeof Schema.String>;
-        }>>;
-        filesToModify: Schema.Array$<typeof Schema.String>;
-        attempts: typeof Schema.Number;
-        completionNotes: Schema.optional<typeof Schema.String>;
-    }>>;
-}>;
-type PlanData = typeof PlanDataSchema.Type;
-/**
- * Plan schema with id.
- */
-declare const PlanSchema: Schema.Struct<{
-    id: typeof Schema.String;
-    sessionId: typeof Schema.String;
-    createdAt: typeof Schema.String;
-    originalTask: typeof Schema.String;
-    context: Schema.optional<typeof Schema.String>;
-    tasks: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        title: typeof Schema.String;
-        description: typeof Schema.String;
-        status: Schema.Literal<["pending", "planning", "in_progress", "done", "failed", "skipped"]>;
-        phases: Schema.Array$<Schema.Struct<{
-            id: typeof Schema.String;
-            description: typeof Schema.String;
-            status: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-        }>>;
-        criteria: Schema.Array$<Schema.Struct<{
-            id: typeof Schema.String;
-            description: typeof Schema.String;
-            status: Schema.Literal<["pending", "passed", "failed"]>;
-            failureReason: Schema.optional<typeof Schema.String>;
-        }>>;
-        filesToModify: Schema.Array$<typeof Schema.String>;
-        attempts: typeof Schema.Number;
-        completionNotes: Schema.optional<typeof Schema.String>;
-    }>>;
-}>;
-type Plan = typeof PlanSchema.Type & {
-    readonly id: PlanId;
-};
-/**
- * Decode helpers.
- */
-declare const decodePlan: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
-    readonly sessionId: string;
-    readonly id: string;
-    readonly createdAt: string;
-    readonly originalTask: string;
-    readonly context?: string | undefined;
-    readonly tasks: readonly {
-        readonly phases: readonly {
-            readonly status: "pending" | "in_progress" | "done" | "failed";
-            readonly id: string;
-            readonly description: string;
-        }[];
-        readonly status: "planning" | "pending" | "in_progress" | "done" | "failed" | "skipped";
-        readonly id: string;
-        readonly description: string;
-        readonly title: string;
-        readonly criteria: readonly {
-            readonly status: "pending" | "failed" | "passed";
-            readonly id: string;
-            readonly description: string;
-            readonly failureReason?: string | undefined;
-        }[];
-        readonly filesToModify: readonly string[];
-        readonly attempts: number;
-        readonly completionNotes?: string | undefined;
-    }[];
-}, effect_ParseResult.ParseError, never>;
-declare const decodePlanData: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
-    readonly sessionId: string;
-    readonly createdAt: string;
-    readonly originalTask: string;
-    readonly context?: string | undefined;
-    readonly tasks: readonly {
-        readonly phases: readonly {
-            readonly status: "pending" | "in_progress" | "done" | "failed";
-            readonly id: string;
-            readonly description: string;
-        }[];
-        readonly status: "planning" | "pending" | "in_progress" | "done" | "failed" | "skipped";
-        readonly id: string;
-        readonly description: string;
-        readonly title: string;
-        readonly criteria: readonly {
-            readonly status: "pending" | "failed" | "passed";
-            readonly id: string;
-            readonly description: string;
-            readonly failureReason?: string | undefined;
-        }[];
-        readonly filesToModify: readonly string[];
-        readonly attempts: number;
-        readonly completionNotes?: string | undefined;
-    }[];
-}, effect_ParseResult.ParseError, never>;
-
-declare const ConsumerTypeSchema: Schema.Literal<["tui", "headless", "none"]>;
-type ConsumerType = typeof ConsumerTypeSchema.Type;
-declare const RunOptionsDataSchema: Schema.Struct<{
-    config: Schema.Struct<{
-        task: typeof Schema.String;
-        maxIterations: typeof Schema.Number;
-        verifyCommands: Schema.Array$<typeof Schema.String>;
-        sessionId: Schema.optional<typeof Schema.String>;
-        branch: Schema.optional<typeof Schema.String>;
-        push: Schema.optional<typeof Schema.Boolean>;
-        pr: Schema.optional<typeof Schema.Boolean>;
-        verbose: Schema.optional<typeof Schema.Boolean>;
-        prompts: Schema.optional<Schema.Struct<{
-            systemPrompt: Schema.optional<typeof Schema.String>;
-            phases: Schema.optional<Schema.Struct<{
-                breakdown: Schema.optional<typeof Schema.String>;
-                planning: Schema.optional<typeof Schema.String>;
-                execution: Schema.optional<typeof Schema.String>;
-                check: Schema.optional<typeof Schema.String>;
-                verify: Schema.optional<typeof Schema.String>;
-                review: Schema.optional<typeof Schema.String>;
-                completion: Schema.optional<typeof Schema.String>;
-            }>>;
-            additionalContext: Schema.optional<typeof Schema.String>;
-        }>>;
-    }>;
-    consumer: Schema.optional<Schema.Literal<["tui", "headless", "none"]>>;
-}>;
-type RunOptionsData = typeof RunOptionsDataSchema.Type;
-
-/**
- * Action types for progress entries.
- */
-declare const ProgressActionSchema: Schema.Literal<["started", "completed", "failed", "learning"]>;
-type ProgressAction = typeof ProgressActionSchema.Type;
-/**
- * A single progress entry for the append-only log.
- *
- * Each entry records what happened in an iteration, including:
- * - Which task was worked on
- * - What action was taken
- * - A summary of the work
- * - Any learnings discovered
- * - Files that were modified
- */
-declare const ProgressEntrySchema: Schema.Struct<{
-    iteration: typeof Schema.Number;
-    timestamp: typeof Schema.String;
-    taskId: typeof Schema.String;
-    action: Schema.Literal<["started", "completed", "failed", "learning"]>;
-    summary: typeof Schema.String;
-    learnings: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    filesModified: Schema.optional<Schema.Array$<typeof Schema.String>>;
-}>;
-type ProgressEntry = typeof ProgressEntrySchema.Type;
-/**
- * The complete progress file structure.
- *
- * Contains session metadata and an array of progress entries.
- * This is the structure persisted to `.ferix/plans/:sessionId/progress.md`.
- */
-declare const ProgressFileSchema: Schema.Struct<{
-    sessionId: typeof Schema.String;
-    createdAt: typeof Schema.String;
-    entries: Schema.Array$<Schema.Struct<{
-        iteration: typeof Schema.Number;
-        timestamp: typeof Schema.String;
-        taskId: typeof Schema.String;
-        action: Schema.Literal<["started", "completed", "failed", "learning"]>;
-        summary: typeof Schema.String;
-        learnings: Schema.optional<Schema.Array$<typeof Schema.String>>;
-        filesModified: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    }>>;
-}>;
-type ProgressFile = typeof ProgressFileSchema.Type;
-/**
- * Decode helpers.
- */
-declare const decodeProgressEntry: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
-    readonly iteration: number;
-    readonly taskId: string;
-    readonly summary: string;
-    readonly filesModified?: readonly string[] | undefined;
-    readonly timestamp: string;
-    readonly action: "failed" | "started" | "completed" | "learning";
-    readonly learnings?: readonly string[] | undefined;
-}, effect_ParseResult.ParseError, never>;
-declare const decodeProgressFile: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
-    readonly entries: readonly {
-        readonly iteration: number;
-        readonly taskId: string;
-        readonly summary: string;
-        readonly filesModified?: readonly string[] | undefined;
-        readonly timestamp: string;
-        readonly action: "failed" | "started" | "completed" | "learning";
-        readonly learnings?: readonly string[] | undefined;
-    }[];
-    readonly sessionId: string;
-    readonly createdAt: string;
-}, effect_ParseResult.ParseError, never>;
-
-/**
- * Session status schema.
- */
-declare const SessionStatusSchema: Schema.Literal<["active", "completed", "failed", "paused"]>;
-type SessionStatus = typeof SessionStatusSchema.Type;
-/**
- * Session schema.
- */
-declare const SessionSchema: Schema.Struct<{
-    id: typeof Schema.String;
-    createdAt: typeof Schema.String;
-    status: Schema.Literal<["active", "completed", "failed", "paused"]>;
-    originalTask: typeof Schema.String;
-    completedTasks: Schema.Array$<typeof Schema.String>;
-    currentTaskId: Schema.optional<typeof Schema.String>;
-    worktreePath: Schema.optional<typeof Schema.String>;
-    branchName: Schema.optional<typeof Schema.String>;
-}>;
-type Session = typeof SessionSchema.Type;
-/**
- * Decode helper.
- */
-declare const decodeSession: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
-    readonly status: "failed" | "completed" | "active" | "paused";
-    readonly completedTasks: readonly string[];
-    readonly id: string;
-    readonly createdAt: string;
-    readonly originalTask: string;
-    readonly worktreePath?: string | undefined;
-    readonly branchName?: string | undefined;
-    readonly currentTaskId?: string | undefined;
-}, effect_ParseResult.ParseError, never>;
-
-/**
- * Basic info schemas for tasks, phases, and criteria.
- */
-declare const TaskBasicInfoSchema: Schema.Struct<{
-    id: typeof Schema.String;
-    title: typeof Schema.String;
-    description: typeof Schema.String;
-}>;
-type TaskBasicInfo = typeof TaskBasicInfoSchema.Type;
-declare const PhaseBasicInfoSchema: Schema.Struct<{
-    id: typeof Schema.String;
-    description: typeof Schema.String;
-}>;
-type PhaseBasicInfo = typeof PhaseBasicInfoSchema.Type;
-declare const CriterionBasicInfoSchema: Schema.Struct<{
-    id: typeof Schema.String;
-    description: typeof Schema.String;
-}>;
-type CriterionBasicInfo = typeof CriterionBasicInfoSchema.Type;
-/**
- * Data schemas (base for signals, without _tag).
- */
-declare const TasksDefinedDataSchema: Schema.Struct<{
-    tasks: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        title: typeof Schema.String;
-        description: typeof Schema.String;
-    }>>;
-}>;
-type TasksDefinedData = typeof TasksDefinedDataSchema.Type;
-declare const PhasesDefinedDataSchema: Schema.Struct<{
-    taskId: typeof Schema.String;
-    phases: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        description: typeof Schema.String;
-    }>>;
-}>;
-type PhasesDefinedData = typeof PhasesDefinedDataSchema.Type;
-declare const CriteriaDefinedDataSchema: Schema.Struct<{
-    taskId: typeof Schema.String;
-    criteria: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        description: typeof Schema.String;
-    }>>;
-}>;
-type CriteriaDefinedData = typeof CriteriaDefinedDataSchema.Type;
-declare const PhaseIdDataSchema: Schema.Struct<{
-    phaseId: typeof Schema.String;
-}>;
-type PhaseIdData = typeof PhaseIdDataSchema.Type;
-declare const PhaseFailedDataSchema: Schema.Struct<{
-    phaseId: typeof Schema.String;
-    reason: typeof Schema.String;
-}>;
-type PhaseFailedData = typeof PhaseFailedDataSchema.Type;
-declare const CriterionIdDataSchema: Schema.Struct<{
-    criterionId: typeof Schema.String;
-}>;
-type CriterionIdData = typeof CriterionIdDataSchema.Type;
-declare const CriterionFailedDataSchema: Schema.Struct<{
-    criterionId: typeof Schema.String;
-    reason: typeof Schema.String;
-}>;
-type CriterionFailedData = typeof CriterionFailedDataSchema.Type;
-declare const ReviewCompleteDataSchema: Schema.Struct<{
-    changesMade: typeof Schema.Boolean;
-}>;
-type ReviewCompleteData = typeof ReviewCompleteDataSchema.Type;
-declare const TaskCompleteSignalDataSchema: Schema.Struct<{
-    taskId: typeof Schema.String;
-    summary: typeof Schema.String;
-    filesModified: Schema.Array$<typeof Schema.String>;
-    filesCreated: Schema.Array$<typeof Schema.String>;
-}>;
-type TaskCompleteSignalData = typeof TaskCompleteSignalDataSchema.Type;
-/**
- * TaskCompleteData without file arrays (used by events).
- */
-declare const TaskCompleteDataSchema: Schema.Struct<{
-    taskId: typeof Schema.String;
-    summary: typeof Schema.String;
-}>;
-type TaskCompleteData = typeof TaskCompleteDataSchema.Type;
-
-/**
- * Signal schemas.
- */
-declare const TasksDefinedSignalSchema: Schema.TaggedStruct<"TasksDefined", Readonly<{
-    tasks: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        title: typeof Schema.String;
-        description: typeof Schema.String;
-    }>>;
-}>>;
-type TasksDefinedSignal = typeof TasksDefinedSignalSchema.Type;
-declare const PhasesDefinedSignalSchema: Schema.TaggedStruct<"PhasesDefined", Readonly<{
-    taskId: typeof Schema.String;
-    phases: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        description: typeof Schema.String;
-    }>>;
-}>>;
-type PhasesDefinedSignal = typeof PhasesDefinedSignalSchema.Type;
-declare const CriteriaDefinedSignalSchema: Schema.TaggedStruct<"CriteriaDefined", Readonly<{
-    taskId: typeof Schema.String;
-    criteria: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        description: typeof Schema.String;
-    }>>;
-}>>;
-type CriteriaDefinedSignal = typeof CriteriaDefinedSignalSchema.Type;
-declare const PhaseStartedSignalSchema: Schema.TaggedStruct<"PhaseStarted", Readonly<{
-    phaseId: typeof Schema.String;
-}>>;
-type PhaseStartedSignal = typeof PhaseStartedSignalSchema.Type;
-declare const PhaseCompletedSignalSchema: Schema.TaggedStruct<"PhaseCompleted", Readonly<{
-    phaseId: typeof Schema.String;
-}>>;
-type PhaseCompletedSignal = typeof PhaseCompletedSignalSchema.Type;
-declare const PhaseFailedSignalSchema: Schema.TaggedStruct<"PhaseFailed", Readonly<{
-    phaseId: typeof Schema.String;
-    reason: typeof Schema.String;
-}>>;
-type PhaseFailedSignal = typeof PhaseFailedSignalSchema.Type;
-declare const CriterionPassedSignalSchema: Schema.TaggedStruct<"CriterionPassed", Readonly<{
-    criterionId: typeof Schema.String;
-}>>;
-type CriterionPassedSignal = typeof CriterionPassedSignalSchema.Type;
-declare const CriterionFailedSignalSchema: Schema.TaggedStruct<"CriterionFailed", Readonly<{
-    criterionId: typeof Schema.String;
-    reason: typeof Schema.String;
-}>>;
-type CriterionFailedSignal = typeof CriterionFailedSignalSchema.Type;
-declare const CheckPassedSignalSchema: Schema.TaggedStruct<"CheckPassed", {}>;
-type CheckPassedSignal = typeof CheckPassedSignalSchema.Type;
-declare const CheckFailedSignalSchema: Schema.TaggedStruct<"CheckFailed", {}>;
-type CheckFailedSignal = typeof CheckFailedSignalSchema.Type;
-declare const ReviewCompleteSignalSchema: Schema.TaggedStruct<"ReviewComplete", Readonly<{
-    changesMade: typeof Schema.Boolean;
-}>>;
-type ReviewCompleteSignal = typeof ReviewCompleteSignalSchema.Type;
-declare const TaskCompleteSignalSchema: Schema.TaggedStruct<"TaskComplete", Readonly<{
-    taskId: typeof Schema.String;
-    summary: typeof Schema.String;
-    filesModified: Schema.Array$<typeof Schema.String>;
-    filesCreated: Schema.Array$<typeof Schema.String>;
-}>>;
-type TaskCompleteSignal = typeof TaskCompleteSignalSchema.Type;
-declare const LoopCompleteSignalSchema: Schema.TaggedStruct<"LoopComplete", {}>;
-type LoopCompleteSignal = typeof LoopCompleteSignalSchema.Type;
-/**
- * Learning category types.
- */
-declare const LearningCategorySchema: Schema.Literal<["success", "failure", "optimization"]>;
-type LearningCategory = typeof LearningCategorySchema.Type;
-/**
- * Learning signal - records insights discovered during iteration.
- */
-declare const LearningSignalSchema: Schema.TaggedStruct<"Learning", {
-    content: typeof Schema.String;
-    category: Schema.optional<Schema.Literal<["success", "failure", "optimization"]>>;
-}>;
-type LearningSignal = typeof LearningSignalSchema.Type;
-/**
- * Guardrail signal - records failure patterns to avoid.
- */
-declare const GuardrailSignalSchema: Schema.TaggedStruct<"Guardrail", {
-    pattern: typeof Schema.String;
-    sign: typeof Schema.String;
-    avoidance: typeof Schema.String;
-    severity: Schema.Literal<["warning", "critical"]>;
-}>;
-type GuardrailSignal = typeof GuardrailSignalSchema.Type;
-/**
- * Union of all signals.
- */
-declare const SignalSchema: Schema.Union<[Schema.TaggedStruct<"TasksDefined", Readonly<{
-    tasks: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        title: typeof Schema.String;
-        description: typeof Schema.String;
-    }>>;
-}>>, Schema.TaggedStruct<"PhasesDefined", Readonly<{
-    taskId: typeof Schema.String;
-    phases: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        description: typeof Schema.String;
-    }>>;
-}>>, Schema.TaggedStruct<"CriteriaDefined", Readonly<{
-    taskId: typeof Schema.String;
-    criteria: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        description: typeof Schema.String;
-    }>>;
-}>>, Schema.TaggedStruct<"PhaseStarted", Readonly<{
-    phaseId: typeof Schema.String;
-}>>, Schema.TaggedStruct<"PhaseCompleted", Readonly<{
-    phaseId: typeof Schema.String;
-}>>, Schema.TaggedStruct<"PhaseFailed", Readonly<{
-    phaseId: typeof Schema.String;
-    reason: typeof Schema.String;
-}>>, Schema.TaggedStruct<"CriterionPassed", Readonly<{
-    criterionId: typeof Schema.String;
-}>>, Schema.TaggedStruct<"CriterionFailed", Readonly<{
-    criterionId: typeof Schema.String;
-    reason: typeof Schema.String;
-}>>, Schema.TaggedStruct<"CheckPassed", {}>, Schema.TaggedStruct<"CheckFailed", {}>, Schema.TaggedStruct<"ReviewComplete", Readonly<{
-    changesMade: typeof Schema.Boolean;
-}>>, Schema.TaggedStruct<"TaskComplete", Readonly<{
-    taskId: typeof Schema.String;
-    summary: typeof Schema.String;
-    filesModified: Schema.Array$<typeof Schema.String>;
-    filesCreated: Schema.Array$<typeof Schema.String>;
-}>>, Schema.TaggedStruct<"LoopComplete", {}>, Schema.TaggedStruct<"Learning", {
-    content: typeof Schema.String;
-    category: Schema.optional<Schema.Literal<["success", "failure", "optimization"]>>;
-}>, Schema.TaggedStruct<"Guardrail", {
-    pattern: typeof Schema.String;
-    sign: typeof Schema.String;
-    avoidance: typeof Schema.String;
-    severity: Schema.Literal<["warning", "critical"]>;
-}>]>;
-type Signal = typeof SignalSchema.Type;
-/**
- * Decode helpers.
- */
-declare const decodeSignal: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
-    readonly _tag: "CheckPassed";
-} | {
-    readonly _tag: "TasksDefined";
-    readonly tasks: readonly {
-        readonly id: string;
-        readonly description: string;
-        readonly title: string;
-    }[];
-} | {
-    readonly phases: readonly {
-        readonly id: string;
-        readonly description: string;
-    }[];
-    readonly _tag: "PhasesDefined";
-    readonly taskId: string;
-} | {
-    readonly _tag: "CriteriaDefined";
-    readonly criteria: readonly {
-        readonly id: string;
-        readonly description: string;
-    }[];
-    readonly taskId: string;
-} | {
-    readonly _tag: "PhaseStarted";
-    readonly phaseId: string;
-} | {
-    readonly _tag: "PhaseCompleted";
-    readonly phaseId: string;
-} | {
-    readonly _tag: "PhaseFailed";
-    readonly phaseId: string;
-    readonly reason: string;
-} | {
-    readonly _tag: "CriterionPassed";
-    readonly criterionId: string;
-} | {
-    readonly _tag: "CriterionFailed";
-    readonly reason: string;
-    readonly criterionId: string;
-} | {
-    readonly _tag: "CheckFailed";
-} | {
-    readonly _tag: "ReviewComplete";
-    readonly changesMade: boolean;
-} | {
-    readonly _tag: "TaskComplete";
-    readonly taskId: string;
-    readonly summary: string;
-    readonly filesModified: readonly string[];
-    readonly filesCreated: readonly string[];
-} | {
-    readonly _tag: "LoopComplete";
-} | {
-    readonly _tag: "Learning";
-    readonly content: string;
-    readonly category?: "success" | "failure" | "optimization" | undefined;
-} | {
-    readonly _tag: "Guardrail";
-    readonly pattern: string;
-    readonly sign: string;
-    readonly avoidance: string;
-    readonly severity: "warning" | "critical";
-}, effect_ParseResult.ParseError, never>;
-declare const decodeSignalSync: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => {
-    readonly _tag: "CheckPassed";
-} | {
-    readonly _tag: "TasksDefined";
-    readonly tasks: readonly {
-        readonly id: string;
-        readonly description: string;
-        readonly title: string;
-    }[];
-} | {
-    readonly phases: readonly {
-        readonly id: string;
-        readonly description: string;
-    }[];
-    readonly _tag: "PhasesDefined";
-    readonly taskId: string;
-} | {
-    readonly _tag: "CriteriaDefined";
-    readonly criteria: readonly {
-        readonly id: string;
-        readonly description: string;
-    }[];
-    readonly taskId: string;
-} | {
-    readonly _tag: "PhaseStarted";
-    readonly phaseId: string;
-} | {
-    readonly _tag: "PhaseCompleted";
-    readonly phaseId: string;
-} | {
-    readonly _tag: "PhaseFailed";
-    readonly phaseId: string;
-    readonly reason: string;
-} | {
-    readonly _tag: "CriterionPassed";
-    readonly criterionId: string;
-} | {
-    readonly _tag: "CriterionFailed";
-    readonly reason: string;
-    readonly criterionId: string;
-} | {
-    readonly _tag: "CheckFailed";
-} | {
-    readonly _tag: "ReviewComplete";
-    readonly changesMade: boolean;
-} | {
-    readonly _tag: "TaskComplete";
-    readonly taskId: string;
-    readonly summary: string;
-    readonly filesModified: readonly string[];
-    readonly filesCreated: readonly string[];
-} | {
-    readonly _tag: "LoopComplete";
-} | {
-    readonly _tag: "Learning";
-    readonly content: string;
-    readonly category?: "success" | "failure" | "optimization" | undefined;
-} | {
-    readonly _tag: "Guardrail";
-    readonly pattern: string;
-    readonly sign: string;
-    readonly avoidance: string;
-    readonly severity: "warning" | "critical";
-};
-
-/**
- * Status for generated tasks in tasks.md
- */
-declare const GeneratedTaskStatusSchema: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-type GeneratedTaskStatus = typeof GeneratedTaskStatusSchema.Type;
-/**
- * Single generated task entry schema
- */
-declare const GeneratedTaskSchema: Schema.Struct<{
-    id: typeof Schema.String;
-    title: typeof Schema.String;
-    status: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-}>;
-type GeneratedTask = typeof GeneratedTaskSchema.Type;
-/**
- * Array of generated tasks schema
- */
-declare const GeneratedTaskListSchema: Schema.Array$<Schema.Struct<{
-    id: typeof Schema.String;
-    title: typeof Schema.String;
-    status: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-}>>;
-type GeneratedTaskList = typeof GeneratedTaskListSchema.Type;
-/**
- * Format tasks to a human-readable markdown string
- */
-declare function formatTasksMd(tasks: GeneratedTaskList): string;
-/**
- * Parse markdown back to validated tasks
- */
-declare function parseTasksMd(content: string): GeneratedTaskList;
-
-declare const ViewModeSchema: Schema.Literal<["logs", "tasks", "detail"]>;
-type ViewMode = typeof ViewModeSchema.Type;
-declare const LoopStatusSchema: Schema.Literal<["idle", "running", "complete", "error"]>;
-type LoopStatus = typeof LoopStatusSchema.Type;
-declare const ExecutionModeSchema: Schema.Literal<["idle", "discovery", "breakdown", "planning", "working", "checking", "verifying", "reviewing"]>;
-type ExecutionMode = typeof ExecutionModeSchema.Type;
-declare const TUIPhaseStatusSchema: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-type TUIPhaseStatus = typeof TUIPhaseStatusSchema.Type;
-declare const TUICriterionStatusSchema: Schema.Literal<["pending", "passed", "failed"]>;
-type TUICriterionStatus = typeof TUICriterionStatusSchema.Type;
-declare const TUITaskStatusSchema: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-type TUITaskStatus = typeof TUITaskStatusSchema.Type;
-declare const TUIPhaseSchema: Schema.Struct<{
-    id: typeof Schema.String;
-    description: typeof Schema.String;
-    status: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-    startedAt: Schema.optional<typeof Schema.Number>;
-    completedAt: Schema.optional<typeof Schema.Number>;
-}>;
-type TUIPhase = typeof TUIPhaseSchema.Type;
-declare const TUICriterionSchema: Schema.Struct<{
-    id: typeof Schema.String;
-    description: typeof Schema.String;
-    status: Schema.Literal<["pending", "passed", "failed"]>;
-    failureReason: Schema.optional<typeof Schema.String>;
-}>;
-type TUICriterion = typeof TUICriterionSchema.Type;
-declare const TUITaskSchema: Schema.Struct<{
-    id: typeof Schema.String;
-    title: typeof Schema.String;
-    status: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-    phases: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        description: typeof Schema.String;
-        status: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-        startedAt: Schema.optional<typeof Schema.Number>;
-        completedAt: Schema.optional<typeof Schema.Number>;
-    }>>;
-    criteria: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        description: typeof Schema.String;
-        status: Schema.Literal<["pending", "passed", "failed"]>;
-        failureReason: Schema.optional<typeof Schema.String>;
-    }>>;
-    startedAt: Schema.optional<typeof Schema.Number>;
-    completedAt: Schema.optional<typeof Schema.Number>;
-}>;
-type TUITask = typeof TUITaskSchema.Type;
-declare const TUIStateSchema: Schema.Struct<{
-    task: typeof Schema.String;
-    iteration: typeof Schema.Number;
-    maxIterations: typeof Schema.Number;
-    status: Schema.Literal<["idle", "running", "complete", "error"]>;
-    startTime: typeof Schema.Number;
-    discoveryInProgress: typeof Schema.Boolean;
-    discoveryCompleted: typeof Schema.Boolean;
-    executionMode: Schema.Literal<["idle", "discovery", "breakdown", "planning", "working", "checking", "verifying", "reviewing"]>;
-    currentTool: Schema.optional<typeof Schema.String>;
-    currentTaskId: Schema.optional<typeof Schema.String>;
-    outputLines: Schema.Array$<typeof Schema.String>;
-    partialLine: typeof Schema.String;
-    tasks: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        title: typeof Schema.String;
-        status: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-        phases: Schema.Array$<Schema.Struct<{
-            id: typeof Schema.String;
-            description: typeof Schema.String;
-            status: Schema.Literal<["pending", "in_progress", "done", "failed"]>;
-            startedAt: Schema.optional<typeof Schema.Number>;
-            completedAt: Schema.optional<typeof Schema.Number>;
-        }>>;
-        criteria: Schema.Array$<Schema.Struct<{
-            id: typeof Schema.String;
-            description: typeof Schema.String;
-            status: Schema.Literal<["pending", "passed", "failed"]>;
-            failureReason: Schema.optional<typeof Schema.String>;
-        }>>;
-        startedAt: Schema.optional<typeof Schema.Number>;
-        completedAt: Schema.optional<typeof Schema.Number>;
-    }>>;
-    viewMode: Schema.Literal<["logs", "tasks", "detail"]>;
-    selectedTaskIndex: typeof Schema.Number;
-    scrollOffset: typeof Schema.Number;
-    userScrolled: typeof Schema.Boolean;
-    gitBranch: Schema.optional<typeof Schema.String>;
-    gitPushed: typeof Schema.Boolean;
-    prUrl: Schema.optional<typeof Schema.String>;
-}>;
-type TUIState = typeof TUIStateSchema.Type;
-
-/**
- * A consumer processes a stream of domain events.
- *
- * This is the ONLY interface between orchestrator and presentation.
- * Consumers are completely decoupled from the orchestrator.
- *
- * @example Creating a custom consumer
- * ```typescript
- * const myConsumer: Consumer = {
- *   consume: (events) =>
- *     events.pipe(
- *       Stream.runForEach((event) =>
- *         Effect.sync(() => console.log(event._tag))
- *       )
- *     ),
- * };
- * ```
- *
- * @example WebSocket consumer
- * ```typescript
- * const wsConsumer: Consumer = {
- *   consume: (events) =>
- *     events.pipe(
- *       Stream.runForEach((event) =>
- *         Effect.sync(() => ws.send(JSON.stringify(event)))
- *       )
- *     ),
- * };
- * ```
- */
-interface Consumer {
-    /**
-     * Consume a stream of events.
-     *
-     * The consumer handles its own lifecycle (setup, teardown).
-     * The returned Effect completes when the stream is exhausted
-     * or an error occurs.
-     *
-     * @param events - Stream of domain events to process
-     * @returns Effect that completes when consumption is done
-     */
-    readonly consume: (events: Stream.Stream<DomainEvent, unknown, never>) => Effect.Effect<void, unknown>;
-}
-
-/**
- * Creates a headless consumer that logs events to the console.
- *
- * This consumer is suitable for CI environments or piped output.
- * It formats events as colored log lines.
- *
- * @returns A Consumer that logs to stdout
- *
- * @example
- * ```typescript
- * const consumer = createHeadlessConsumer();
- * const events = runLoop(config).pipe(Stream.provideLayer(layers));
- * await consumer.consume(events).pipe(Effect.runPromise);
- * ```
- */
-declare function createHeadlessConsumer(): Consumer;
-
-/**
- * Creates a TUI consumer that renders events to a full-screen terminal interface.
- *
- * The TUI provides:
- * - Header with task and iteration info
- * - Status bar with current phase, tool, and progress
- * - Three view modes: logs, tasks list, task detail
- * - Scrollable output area with ferix tag styling
- * - Keyboard navigation (vim-style j/k, g/G)
- * - Mouse wheel support
- * - Context-sensitive footer with keyboard hints
- *
- * Uses ANSI escape codes for terminal control (alternate buffer, cursor hiding, etc).
- *
- * @returns A Consumer that renders to the terminal
- *
- * @example
- * ```typescript
- * const consumer = createTUIConsumer();
- * const events = runLoop(config).pipe(Stream.provideLayer(layers));
- * await consumer.consume(events).pipe(Effect.runPromise);
- * ```
- */
-declare function createTUIConsumer(): Consumer;
-
-/**
- * Options for LLM execution.
- */
-interface LLMExecuteOptions {
-    /**
-     * Working directory for the LLM process.
-     * Used when running in a worktree context.
-     */
-    readonly cwd?: string;
-}
-/**
- * Service interface for LLM execution.
- *
- * Implementations include:
- * - ClaudeCLI: Spawns `claude` CLI with stream-json output
- * - Mock: Returns predefined events for testing
- *
- * @example
- * ```typescript
- * const llm = yield* LLM;
- * const events = llm.execute("Fix the bug in main.ts");
- *
- * await events.pipe(
- *   Stream.runForEach((event) => console.log(event)),
- *   Effect.runPromise
- * );
- * ```
- */
-interface LLMService {
-    /**
-     * Execute a prompt and return a stream of events.
-     *
-     * The stream emits events in real-time as the LLM produces output.
-     * The final event will be a "Done" event containing the full output.
-     *
-     * @param prompt - The prompt to send to the LLM
-     * @param options - Optional execution options (e.g., cwd for worktree)
-     * @returns Stream of LLM events that can be consumed by any subscriber
-     */
-    readonly execute: (prompt: string, options?: LLMExecuteOptions) => Stream.Stream<LLMEvent, LLMError>;
-}
-declare const LLM_base: Context.TagClass<LLM, "@ferix/LLM", LLMService>;
-/**
- * Effect Tag for the LLM service.
- *
- * Use this tag to depend on an LLM implementation without coupling to a specific provider.
- *
- * @example
- * ```typescript
- * const program = Effect.gen(function* () {
- *   const llm = yield* LLM;
- *   return yield* llm.execute(prompt).pipe(Stream.runCollect);
- * });
- *
- * // Provide different implementations
- * program.pipe(Effect.provide(ClaudeCLI.Live));  // Production
- * program.pipe(Effect.provide(Mock.Live));       // Testing
- * ```
- */
-declare class LLM extends LLM_base {
-}
-
-/**
- * Schema for MockLLMConfig for runtime validation.
- */
-declare const MockLLMConfigSchema: Schema.Struct<{
-    events: Schema.Array$<Schema.Union<[Schema.TaggedStruct<"Text", {
-        text: typeof Schema.String;
-    }>, Schema.TaggedStruct<"ToolStart", {
-        tool: typeof Schema.String;
-    }>, Schema.TaggedStruct<"ToolUse", {
-        tool: typeof Schema.String;
-        input: typeof Schema.Unknown;
-    }>, Schema.TaggedStruct<"ToolEnd", {
-        tool: typeof Schema.String;
-    }>, Schema.TaggedStruct<"Done", {
-        output: typeof Schema.String;
-    }>]>>;
-    delayMs: Schema.optional<typeof Schema.Number>;
-}>;
-type MockLLMConfig = typeof MockLLMConfigSchema.Type;
-/**
- * Creates a mock LLM service that emits predefined events.
- *
- * Useful for testing without making real LLM calls.
- *
- * @param config - Configuration specifying events to emit
- * @returns An LLMService that emits the configured events
- *
- * @example
- * ```typescript
- * const mockLLM = createMockLLM({
- *   events: [
- *     { _tag: "Text", text: "Hello " },
- *     { _tag: "Text", text: "World!" },
- *     { _tag: "Done", output: "Hello World!" },
- *   ],
- * });
- * ```
- */
-declare function createMockLLM(config: MockLLMConfig): LLMService;
-/**
- * Creates a Layer with custom mock events.
- *
- * @param config - Configuration specifying events to emit
- * @returns A Layer providing the configured mock LLM
- *
- * @example
- * ```typescript
- * const customMockLayer = Mock.layer({
- *   events: [
- *     { _tag: "Text", text: "<ferix:tasks><task id=\"1\">Test</task></ferix:tasks>" },
- *     { _tag: "Done", output: "..." },
- *   ],
- * });
- * ```
- */
-declare function layer$5(config: MockLLMConfig): Layer.Layer<LLM>;
-/**
- * Mock namespace containing the Live layer and factory functions.
- */
-declare const Mock: {
-    readonly Live: Layer.Layer<LLM, never, never>;
-    readonly layer: typeof layer$5;
-    readonly createMockLLM: typeof createMockLLM;
-};
-
-/**
- * Branded type for worktree paths.
- */
-type WorktreePath = string & {
-    readonly _brand: "WorktreePath";
-};
-/**
- * Branded type for commit hashes.
- */
-type CommitHash = string & {
-    readonly _brand: "CommitHash";
-};
-/**
- * Branded type for PR URLs.
- */
-type PrUrl = string & {
-    readonly _brand: "PrUrl";
-};
-/**
- * Information about a worktree.
- */
-interface WorktreeInfo {
-    readonly path: WorktreePath;
-    readonly branch: string;
-    readonly sessionId: string;
-}
-/**
- * Service interface for git operations.
- *
- * Provides worktree management for isolated session execution.
- * Each session runs in its own worktree with a dedicated branch.
- *
- * @example
- * ```typescript
- * const git = yield* Git;
- *
- * // Create worktree for a session
- * const worktreePath = yield* git.createWorktree("calm-snails-dream-123");
- *
- * // Execute work in worktree...
- *
- * // Commit changes
- * yield* git.commitChanges("calm-snails-dream-123", "feat: complete task 1");
- *
- * // Cleanup when done
- * yield* git.removeWorktree("calm-snails-dream-123");
- * ```
- */
-interface GitService {
-    /**
-     * Create a new worktree for a session.
-     *
-     * Creates a worktree at `.ferix/worktrees/{sessionId}` with a new branch
-     * `ferix/{sessionId}` based on the current HEAD or specified base branch.
-     *
-     * @param sessionId - Session ID to create worktree for
-     * @param baseBranch - Optional branch to base the worktree on (defaults to HEAD)
-     * @returns Path to the created worktree
-     */
-    readonly createWorktree: (sessionId: string, baseBranch?: string) => Effect.Effect<WorktreePath, GitError>;
-    /**
-     * Remove a worktree for a session.
-     *
-     * Removes the worktree directory and cleans up git references.
-     *
-     * @param sessionId - Session ID whose worktree to remove
-     */
-    readonly removeWorktree: (sessionId: string) => Effect.Effect<void, GitError>;
-    /**
-     * Get the worktree path for a session if it exists.
-     *
-     * @param sessionId - Session ID to check
-     * @returns Worktree path if exists, undefined otherwise
-     */
-    readonly getWorktreePath: (sessionId: string) => Effect.Effect<WorktreePath | undefined, GitError>;
-    /**
-     * Commit all changes in a session's worktree.
-     *
-     * Stages all changes and creates a commit with the given message.
-     *
-     * @param sessionId - Session ID whose worktree to commit
-     * @param message - Commit message
-     * @returns The commit hash
-     */
-    readonly commitChanges: (sessionId: string, message: string) => Effect.Effect<CommitHash, GitError>;
-    /**
-     * Push the session's branch to the remote.
-     *
-     * @param sessionId - Session ID whose branch to push
-     */
-    readonly pushBranch: (sessionId: string) => Effect.Effect<void, GitError>;
-    /**
-     * Create a pull request for the session's branch.
-     *
-     * Uses `gh` CLI to create a PR.
-     *
-     * @param sessionId - Session ID whose branch to create PR for
-     * @param title - PR title
-     * @param body - PR body/description
-     * @returns URL of the created PR
-     */
-    readonly createPR: (sessionId: string, title: string, body: string) => Effect.Effect<PrUrl, GitError>;
-    /**
-     * Get the branch name for a session.
-     *
-     * @param sessionId - Session ID
-     * @returns Branch name (e.g., "ferix/calm-snails-dream-123")
-     */
-    readonly getBranchName: (sessionId: string) => string;
-}
-declare const Git_base: Context.TagClass<Git, "@ferix/Git", GitService>;
-/**
- * Effect Tag for the Git service.
- *
- * Use this tag to depend on git operations without coupling to a specific implementation.
- */
-declare class Git extends Git_base {
-}
-
-/**
- * FileSystemGit namespace containing the Live layer.
- */
-declare const FileSystemGit: {
-    readonly Live: Layer.Layer<Git, never, never>;
-};
-
-/**
- * Creates a Layer for an in-memory git service.
- *
- * Each call creates a new isolated store.
- *
- * @example
- * ```typescript
- * const testLayer = MemoryGit.layer();
- *
- * const program = Effect.gen(function* () {
- *   const git = yield* Git;
- *   const path = yield* git.createWorktree("test-session");
- *   return path;
- * });
- *
- * Effect.runPromise(program.pipe(Effect.provide(testLayer)));
- * ```
- */
-declare function layer$4(): Layer.Layer<Git>;
-/**
- * MemoryGit namespace containing the Live layer and factory.
- */
-declare const MemoryGit: {
-    readonly Live: Layer.Layer<Git, never, never>;
-    readonly layer: typeof layer$4;
-};
-
-/**
- * Service interface for guardrails persistence.
- *
- * Guardrails are stored at `.ferix/plans/:sessionId/guardrails.md`.
- * They represent failure patterns learned from previous iterations
- * that the LLM should avoid.
- *
- * Implementations include:
- * - FileSystem: Persists to `.ferix/plans/` directory
- * - Memory: In-memory storage for testing
- *
- * @example
- * ```typescript
- * const guardrailsStore = yield* GuardrailsStore;
- *
- * // Add a guardrail
- * yield* guardrailsStore.add(sessionId, {
- *   id: "gr-1",
- *   createdAt: new Date().toISOString(),
- *   iteration: 3,
- *   pattern: "Modifying package.json without running install",
- *   sign: "Build failures after dependency changes",
- *   avoidance: "Always run npm install after modifying package.json",
- *   severity: "critical",
- * });
- *
- * // Load all guardrails
- * const guardrails = yield* guardrailsStore.load(sessionId);
- *
- * // Get active guardrails for prompt
- * const active = yield* guardrailsStore.getActive(sessionId);
- * ```
- */
-interface GuardrailsStoreService {
-    /**
-     * Add a guardrail to the session's collection.
-     *
-     * @param sessionId - Session this guardrail belongs to
-     * @param guardrail - Guardrail to add
-     */
-    readonly add: (sessionId: string, guardrail: Guardrail) => Effect.Effect<void, GuardrailsStoreError>;
-    /**
-     * Load the complete guardrails file for a session.
-     *
-     * @param sessionId - Session to load guardrails for
-     * @returns The guardrails file with all entries
-     */
-    readonly load: (sessionId: string) => Effect.Effect<GuardrailsFile, GuardrailsStoreError>;
-    /**
-     * Get all active guardrails for a session.
-     *
-     * @param sessionId - Session to get guardrails for
-     * @returns Array of active guardrails
-     */
-    readonly getActive: (sessionId: string) => Effect.Effect<readonly Guardrail[], GuardrailsStoreError>;
-}
-declare const GuardrailsStore_base: Context.TagClass<GuardrailsStore, "@ferix/GuardrailsStore", GuardrailsStoreService>;
-/**
- * Effect Tag for the GuardrailsStore service.
- *
- * Use this tag to depend on guardrails storage without coupling to a specific backend.
- */
-declare class GuardrailsStore extends GuardrailsStore_base {
-}
-
-/**
- * FileSystemGuardrails namespace containing the Live layer.
- */
-declare const FileSystemGuardrails: {
-    readonly Live: Layer.Layer<GuardrailsStore, never, never>;
-};
-
-/**
- * Creates a Layer for an in-memory guardrails store.
- *
- * Each call creates a new isolated store.
- *
- * @example
- * ```typescript
- * const testLayer = MemoryGuardrails.layer();
- *
- * const program = Effect.gen(function* () {
- *   const guardrailsStore = yield* GuardrailsStore;
- *   yield* guardrailsStore.add(sessionId, guardrail);
- * });
- *
- * Effect.runPromise(program.pipe(Effect.provide(testLayer)));
- * ```
- */
-declare function layer$3(): Layer.Layer<GuardrailsStore>;
-/**
- * MemoryGuardrails namespace containing the Live layer and factory.
- */
-declare const MemoryGuardrails: {
-    readonly Live: Layer.Layer<GuardrailsStore, never, never>;
-    readonly layer: typeof layer$3;
-};
-
-/**
- * ClaudeCLI namespace containing the Live layer.
- */
-declare const ClaudeCLI: {
-    readonly Live: Layer.Layer<LLM, never, never>;
-};
-
-/**
- * Service interface for plan persistence.
- *
- * Plans are stored per session at `.ferix/plans/:sessionId/task-N.md`.
- * Each task gets its own file that is updated across iterations.
- *
- * Implementations include:
- * - FileSystem: Persists to `.ferix/plans/` directory
- * - Memory: In-memory storage for testing
- *
- * @example
- * ```typescript
- * const planStore = yield* PlanStore;
- *
- * // Create a new plan
- * const planId = yield* planStore.create(sessionId, plan);
- *
- * // Update after iteration
- * yield* planStore.update(planId, updatedPlan);
- *
- * // Load existing plan
- * const plan = yield* planStore.load(planId);
- * ```
- */
-interface PlanStoreService {
-    /**
-     * Create a new plan for a session.
-     *
-     * @param sessionId - Session this plan belongs to
-     * @param plan - Plan to persist
-     * @returns The generated plan ID
-     */
-    readonly create: (sessionId: string, plan: Omit<Plan, "id">) => Effect.Effect<PlanId, PlanStoreError>;
-    /**
-     * Load a plan by ID.
-     *
-     * @param planId - ID of the plan to load
-     * @param sessionId - Optional session ID for O(1) lookup. If not provided, searches all sessions.
-     * @returns The loaded plan
-     */
-    readonly load: (planId: PlanId, sessionId?: string) => Effect.Effect<Plan, PlanStoreError>;
-    /**
-     * Update an existing plan.
-     *
-     * @param planId - ID of the plan to update
-     * @param plan - Updated plan data
-     */
-    readonly update: (planId: PlanId, plan: Plan) => Effect.Effect<void, PlanStoreError>;
-    /**
-     * List all plans for a session.
-     *
-     * @param sessionId - Session to list plans for
-     * @returns Array of plan IDs
-     */
-    readonly list: (sessionId: string) => Effect.Effect<readonly PlanId[], PlanStoreError>;
-}
-declare const PlanStore_base: Context.TagClass<PlanStore, "@ferix/PlanStore", PlanStoreService>;
-/**
- * Effect Tag for the PlanStore service.
- *
- * Use this tag to depend on plan storage without coupling to a specific backend.
- */
-declare class PlanStore extends PlanStore_base {
-}
-
-/**
- * FileSystemPlan namespace containing the Live layer.
- */
-declare const FileSystemPlan: {
-    readonly Live: Layer.Layer<PlanStore, never, never>;
-};
-
-/**
- * Creates a Layer for an in-memory plan store.
- *
- * Each call creates a new isolated store.
- *
- * @example
- * ```typescript
- * const testLayer = MemoryPlan.layer();
- *
- * const program = Effect.gen(function* () {
- *   const planStore = yield* PlanStore;
- *   const planId = yield* planStore.create(sessionId, plan);
- *   return planId;
- * });
- *
- * Effect.runPromise(program.pipe(Effect.provide(testLayer)));
- * ```
- */
-declare function layer$2(): Layer.Layer<PlanStore>;
-/**
- * MemoryPlan namespace containing the Live layer and factory.
- */
-declare const MemoryPlan: {
-    readonly Live: Layer.Layer<PlanStore, never, never>;
-    readonly layer: typeof layer$2;
-};
-
-/**
- * Service interface for progress persistence.
- *
- * Progress is stored as an append-only log at `.ferix/plans/:sessionId/progress.md`.
- * Each iteration appends entries recording what happened.
- *
- * Implementations include:
- * - FileSystem: Persists to `.ferix/plans/` directory
- * - Memory: In-memory storage for testing
- *
- * @example
- * ```typescript
- * const progressStore = yield* ProgressStore;
- *
- * // Append a progress entry
- * yield* progressStore.append(sessionId, {
- *   iteration: 1,
- *   timestamp: new Date().toISOString(),
- *   taskId: "task-1",
- *   action: "started",
- *   summary: "Started implementing feature X",
- * });
- *
- * // Load all progress
- * const progress = yield* progressStore.load(sessionId);
- *
- * // Get recent entries
- * const recent = yield* progressStore.getRecent(sessionId, 5);
- * ```
- */
-interface ProgressStoreService {
-    /**
-     * Append a progress entry to the session's log.
-     *
-     * @param sessionId - Session this entry belongs to
-     * @param entry - Progress entry to append
-     */
-    readonly append: (sessionId: string, entry: ProgressEntry) => Effect.Effect<void, ProgressStoreError>;
-    /**
-     * Load the complete progress file for a session.
-     *
-     * @param sessionId - Session to load progress for
-     * @returns The progress file with all entries
-     */
-    readonly load: (sessionId: string) => Effect.Effect<ProgressFile, ProgressStoreError>;
-    /**
-     * Get the most recent progress entries for a session.
-     *
-     * @param sessionId - Session to get progress for
-     * @param count - Number of recent entries to return
-     * @returns Array of recent progress entries
-     */
-    readonly getRecent: (sessionId: string, count: number) => Effect.Effect<readonly ProgressEntry[], ProgressStoreError>;
-}
-declare const ProgressStore_base: Context.TagClass<ProgressStore, "@ferix/ProgressStore", ProgressStoreService>;
-/**
- * Effect Tag for the ProgressStore service.
- *
- * Use this tag to depend on progress storage without coupling to a specific backend.
- */
-declare class ProgressStore extends ProgressStore_base {
-}
-
-/**
- * FileSystemProgress namespace containing the Live layer.
- */
-declare const FileSystemProgress: {
-    readonly Live: Layer.Layer<ProgressStore, never, never>;
-};
-
-/**
- * Creates a Layer for an in-memory progress store.
- *
- * Each call creates a new isolated store.
- *
- * @example
- * ```typescript
- * const testLayer = MemoryProgress.layer();
- *
- * const program = Effect.gen(function* () {
- *   const progressStore = yield* ProgressStore;
- *   yield* progressStore.append(sessionId, entry);
- * });
- *
- * Effect.runPromise(program.pipe(Effect.provide(testLayer)));
- * ```
- */
-declare function layer$1(): Layer.Layer<ProgressStore>;
-/**
- * MemoryProgress namespace containing the Live layer and factory.
- */
-declare const MemoryProgress: {
-    readonly Live: Layer.Layer<ProgressStore, never, never>;
-    readonly layer: typeof layer$1;
-};
-
-/**
- * Service interface for session persistence.
- *
- * Sessions track execution state across runs, enabling:
- * - Resumption of interrupted loops
- * - Progress tracking across tasks
- * - Context building from completed work
- *
- * @example
- * ```typescript
- * const sessionStore = yield* SessionStore;
- *
- * // Start a new session
- * const session = yield* sessionStore.create("Implement auth feature");
- *
- * // Update progress
- * yield* sessionStore.update(session.id, {
- *   ...session,
- *   currentTaskId: "1",
- * });
- *
- * // Mark task complete
- * yield* sessionStore.update(session.id, {
- *   ...session,
- *   completedTasks: [...session.completedTasks, "1"],
- * });
- * ```
- */
-interface SessionStoreService {
-    /**
-     * Create a new session.
-     *
-     * @param originalTask - The task that initiated this session
-     * @returns The created session with a generated ID
-     */
-    readonly create: (originalTask: string) => Effect.Effect<Session, SessionStoreError>;
-    /**
-     * Get an existing session by ID.
-     *
-     * @param sessionId - ID of the session to retrieve
-     * @returns The session, or error if not found
-     */
-    readonly get: (sessionId: string) => Effect.Effect<Session, SessionStoreError>;
-    /**
-     * Update an existing session.
-     *
-     * @param sessionId - ID of the session to update
-     * @param session - Updated session data
-     */
-    readonly update: (sessionId: string, session: Session) => Effect.Effect<void, SessionStoreError>;
-}
-declare const SessionStore_base: Context.TagClass<SessionStore, "@ferix/SessionStore", SessionStoreService>;
-/**
- * Effect Tag for the SessionStore service.
- *
- * Use this tag to depend on session storage without coupling to a specific backend.
- */
-declare class SessionStore extends SessionStore_base {
-}
-
-/**
- * FileSystemSession namespace containing the Live layer.
- */
-declare const FileSystemSession: {
-    readonly Live: Layer.Layer<SessionStore, never, never>;
-};
-
-/**
- * Creates a Layer for an in-memory session store.
- *
- * Each call creates a new isolated store.
- *
- * @example
- * ```typescript
- * const testLayer = MemorySession.layer();
- *
- * const program = Effect.gen(function* () {
- *   const sessionStore = yield* SessionStore;
- *   const session = yield* sessionStore.create("Test task");
- *   return session;
- * });
- *
- * Effect.runPromise(program.pipe(Effect.provide(testLayer)));
- * ```
- */
-declare function layer(): Layer.Layer<SessionStore>;
-/**
- * MemorySession namespace containing the Live layer and factory.
- */
-declare const MemorySession: {
-    readonly Live: Layer.Layer<SessionStore, never, never>;
-    readonly layer: typeof layer;
-};
-
-/**
- * Accumulator for parsing signals across multiple text chunks.
- *
- * LLM output arrives in chunks, and signals may span multiple chunks.
- * The accumulator buffers text and extracts complete signals.
- */
-interface SignalAccumulator {
-    /**
-     * Feed a text chunk to the accumulator.
-     *
-     * @param text - Text chunk from LLM output
-     * @returns Array of complete signals found in the accumulated text
-     */
-    readonly feed: (text: string) => Effect.Effect<readonly Signal[], ParseError>;
-    /**
-     * Flush any remaining buffered text and extract final signals.
-     *
-     * Call this when the LLM stream ends to ensure no signals are lost.
-     *
-     * @returns Array of signals found in remaining buffer
-     */
-    readonly flush: () => Effect.Effect<readonly Signal[], ParseError>;
-}
-/**
- * Service interface for parsing signals from LLM output.
- *
- * Signals are structured XML-like tags embedded in LLM output:
- * - `<ferix:tasks>...</ferix:tasks>` - Task definitions
- * - `<ferix:phase-start id="1.1"/>` - Phase lifecycle
- * - `<ferix:criterion-passed id="1.c1"/>` - Criterion verification
- *
- * @example
- * ```typescript
- * const parser = yield* SignalParser;
- * const accumulator = yield* parser.createAccumulator();
- *
- * for (const chunk of textChunks) {
- *   const signals = yield* accumulator.feed(chunk);
- *   for (const signal of signals) {
- *     // Handle signal
- *   }
- * }
- *
- * const finalSignals = yield* accumulator.flush();
- * ```
- */
-interface SignalParserService {
-    /**
-     * Parse a complete text and extract all signals.
-     *
-     * Use this for parsing complete output. For streaming, use createAccumulator.
-     *
-     * @param text - Complete text to parse
-     * @returns Array of signals found in the text
-     */
-    readonly parse: (text: string) => Effect.Effect<readonly Signal[], ParseError>;
-    /**
-     * Create a stateful accumulator for streaming signal parsing.
-     *
-     * The accumulator handles partial signals that span multiple chunks.
-     *
-     * @returns An accumulator instance for incremental parsing
-     */
-    readonly createAccumulator: () => Effect.Effect<SignalAccumulator>;
-}
-declare const SignalParser_base: Context.TagClass<SignalParser, "@ferix/SignalParser", SignalParserService>;
-/**
- * Effect Tag for the SignalParser service.
- *
- * Use this tag to depend on signal parsing without coupling to a specific implementation.
- */
-declare class SignalParser extends SignalParser_base {
-}
-
-/**
- * FerixParser namespace containing the Live layer.
- */
-declare const FerixParser: {
-    readonly Live: Layer.Layer<SignalParser, never, never>;
-};
-
-/**
- * Production layer bundle.
- *
- * Uses real implementations:
- * - Claude CLI for LLM
- * - Ferix parser for signals
- * - File system for plan, session, progress, guardrails, and git storage
- *
- * @example
- * ```typescript
- * const program = runLoop(config);
- *
- * Effect.runPromise(
- *   program.pipe(
- *     Stream.runForEach(console.log),
- *     Effect.provide(ProductionLayers)
- *   )
- * );
- * ```
- */
-declare const ProductionLayers: Layer.Layer<Git | GuardrailsStore | LLM | PlanStore | ProgressStore | SessionStore | SignalParser, never, never>;
-/**
- * Test layer bundle.
- *
- * Uses mock/in-memory implementations:
- * - Mock LLM (configurable events)
- * - Ferix parser (real implementation - pure)
- * - In-memory plan, session, progress, guardrails, and git storage
- *
- * @example
- * ```typescript
- * const testProgram = runLoop(config);
- *
- * const result = await Effect.runPromise(
- *   testProgram.pipe(
- *     Stream.runCollect,
- *     Effect.provide(TestLayers)
- *   )
- * );
- *
- * expect(result).toContainEqual({ _tag: "LoopCompleted", ... });
- * ```
- */
-declare const TestLayers: Layer.Layer<Git | GuardrailsStore | LLM | PlanStore | ProgressStore | SessionStore | SignalParser, never, never>;
-/**
- * Creates a test layer bundle with custom mock LLM events.
- *
- * @param events - Events to emit from the mock LLM
- * @returns A layer bundle for testing with the specified events
- *
- * @example
- * ```typescript
- * const customTestLayers = createTestLayers([
- *   { _tag: "Text", text: "<ferix:tasks>...</ferix:tasks>" },
- *   { _tag: "Done", output: "..." },
- * ]);
- *
- * Effect.runPromise(program.pipe(Effect.provide(customTestLayers)));
- * ```
- */
-declare function createTestLayers(events: Parameters<typeof Mock.layer>[0]["events"]): Layer.Layer<Git | GuardrailsStore | LLM | PlanStore | ProgressStore | SessionStore | SignalParser, never, never>;
-
-/**
- * Required services for the orchestrator.
- * Now includes ProgressStore, GuardrailsStore, and Git for worktree support.
- */
-type OrchestratorServices = LLM | SignalParser | PlanStore | SessionStore | ProgressStore | GuardrailsStore | Git;
-/**
- * Run the ralph loop.
- *
- * Returns a Stream of DomainEvents that ANY consumer can subscribe to.
- * The orchestrator has NO knowledge of how events are consumed.
- *
- * @param config - Loop configuration
- * @returns Stream of domain events
- *
- * @example TUI consumption
- * ```typescript
- * const events = runLoop(config);
- * await events.pipe(
- *   Stream.runForEach((event) => tui.render(event)),
- *   Effect.provide(ProductionLayers),
- *   Effect.runPromise
- * );
- * ```
- *
- * @example Web consumption
- * ```typescript
- * const events = runLoop(config);
- * await events.pipe(
- *   Stream.runForEach((event) => websocket.send(JSON.stringify(event))),
- *   Effect.provide(ProductionLayers),
- *   Effect.runPromise
- * );
- * ```
- *
- * @example Collecting events for testing
- * ```typescript
- * const events = runLoop(config);
- * const collected = await events.pipe(
- *   Stream.runCollect,
- *   Effect.provide(TestLayers),
- *   Effect.runPromise
- * );
- * expect(collected).toContainEqual({ _tag: "LoopStarted", ... });
- * ```
- */
-declare function runLoop(config: LoopConfig): Stream.Stream<DomainEvent, never, OrchestratorServices>;
-
-/**
- * Builds the iteration prompt with context and instructions.
- *
- * @param config - Loop configuration
- * @param iteration - Current iteration number
- * @param plan - Current plan state (if available)
- * @returns The complete prompt for this iteration
- */
-declare function buildPrompt(config: LoopConfig, iteration: number, plan?: Plan): string;
-
-/**
- * Options for running the ralph loop program.
- */
-interface RunOptions {
-    /**
-     * Loop configuration.
-     */
-    readonly config: LoopConfig;
-    /**
-     * Consumer type for output.
-     * - "tui": Full-screen terminal UI
-     * - "headless": Simple console logging
-     * - "none": No output (for programmatic use)
-     *
-     * @default "headless"
-     */
-    readonly consumer?: ConsumerType;
-    /**
-     * Optional callback for each domain event.
-     * Called in addition to the selected consumer.
-     */
-    readonly onEvent?: (event: DomainEvent) => void;
-}
-/**
- * Run the ralph loop with production layers.
- *
- * This is the main entry point for running a ralph loop.
- * It composes all services and consumers into a single Effect program.
- *
- * @param options - Run options including config and consumer type
- * @returns Effect that completes when the loop finishes
- *
- * @example Basic usage
- * ```typescript
- * await run({
- *   config: {
- *     task: "Implement the feature",
- *     maxIterations: 3,
- *     verifyCommands: ["bun test"],
- *   },
- *   consumer: "tui",
- * }).pipe(Effect.runPromise);
- * ```
- *
- * @example With event callback
- * ```typescript
- * await run({
- *   config: { task: "Fix the bug", maxIterations: 1, verifyCommands: [] },
- *   consumer: "headless",
- *   onEvent: (event) => {
- *     if (event._tag === "TaskCompleted") {
- *       console.log("Task done:", event.taskId);
- *     }
- *   },
- * }).pipe(Effect.runPromise);
- * ```
- */
-declare function run(options: RunOptions): Effect.Effect<void, unknown, never>;
-/**
- * Run the ralph loop with test layers.
- *
- * Uses mock LLM and in-memory storage for testing.
- *
- * @param options - Run options including config
- * @param mockEvents - Optional custom mock events
- * @returns Effect that completes when the loop finishes
- *
- * @example
- * ```typescript
- * const mockEvents: LLMEvent[] = [
- *   { _tag: "Text", text: "<ferix:tasks><task id=\"1\">Test</task></ferix:tasks>" },
- *   { _tag: "Done", output: "..." },
- * ];
- *
- * await runTest(
- *   { config: { task: "test", maxIterations: 1, verifyCommands: [] } },
- *   mockEvents
- * ).pipe(Effect.runPromise);
- * ```
- */
-declare function runTest(options: Omit<RunOptions, "consumer">, mockEvents?: readonly LLMEvent[]): Effect.Effect<void, unknown, never>;
-/**
- * Collect all events from a ralph loop run.
- *
- * Useful for testing to get all emitted events.
- *
- * @param config - Loop configuration
- * @param mockEvents - Optional custom mock events
- * @returns Array of all domain events emitted
- *
- * @example
- * ```typescript
- * const events = await collectEvents(config, mockEvents).pipe(Effect.runPromise);
- * expect(events).toContainEqual({ _tag: "LoopStarted", ... });
- * ```
- */
-declare function collectEvents(config: LoopConfig, mockEvents?: readonly LLMEvent[]): Effect.Effect<readonly DomainEvent[], unknown, never>;
-/**
- * Main CLI entry point.
- *
- * Automatically selects TUI for TTY, headless otherwise.
- *
- * @param config - Loop configuration
- * @returns Promise that resolves when the loop completes
- */
-declare function main(config: LoopConfig): Promise<void>;
-
-export { type CheckFailedEvent, CheckFailedEventSchema, type CheckFailedSignal, CheckFailedSignalSchema, type CheckPassedEvent, CheckPassedEventSchema, type CheckPassedSignal, CheckPassedSignalSchema, ClaudeCLI, type CommitHash, type ConsoleLoggerConfig, ConsoleLoggerConfigSchema, type Consumer, type ConsumerType, ConsumerTypeSchema, type CriteriaDefinedData, CriteriaDefinedDataSchema, type CriteriaDefinedEvent, CriteriaDefinedEventSchema, type CriteriaDefinedSignal, CriteriaDefinedSignalSchema, type Criterion, type CriterionBasicInfo, CriterionBasicInfoSchema, type CriterionFailedData, CriterionFailedDataSchema, type CriterionFailedEvent, CriterionFailedEventSchema, type CriterionFailedSignal, CriterionFailedSignalSchema, type CriterionIdData, CriterionIdDataSchema, type CriterionPassedEvent, CriterionPassedEventSchema, type CriterionPassedSignal, CriterionPassedSignalSchema, CriterionSchema, type CriterionStatus, CriterionStatusSchema, type DiscoveryCompletedEvent, DiscoveryCompletedEventSchema, type DiscoveryStartedEvent, DiscoveryStartedEventSchema, type DomainEvent, DomainEventSchema, DomainEventUtils, type DoneEvent, DoneEventSchema, type ExecutionMode, ExecutionModeSchema, type FerixError, FerixParser, type FileLoggerConfig, FileLoggerConfigSchema, FileSystemGit, FileSystemGuardrails, FileSystemPlan, FileSystemProgress, FileSystemSession, type GeneratedTask, type GeneratedTaskList, GeneratedTaskListSchema, GeneratedTaskSchema, type GeneratedTaskStatus, GeneratedTaskStatusSchema, Git, GitError, type GitService, type Guardrail, type GuardrailAddedEvent, GuardrailAddedEventSchema, GuardrailSchema, type GuardrailSeverity, GuardrailSeveritySchema, type GuardrailSignal, GuardrailSignalSchema, type GuardrailsFile, GuardrailsFileSchema, GuardrailsStore, GuardrailsStoreError, type GuardrailsStoreService, type IterationCompletedEvent, IterationCompletedEventSchema, type IterationStartedEvent, IterationStartedEventSchema, LLM, LLMError, type LLMEvent, LLMEventSchema, type LLMExecuteOptions, type LLMService, type LLMTextEvent, LLMTextEventSchema, type LLMToolEndEvent, LLMToolEndEventSchema, type LLMToolStartEvent, LLMToolStartEventSchema, type LLMToolUseEvent, LLMToolUseEventSchema, type LearningCategory, LearningCategorySchema, type LearningRecordedEvent, LearningRecordedEventSchema, type LearningSignal, LearningSignalSchema, type LogEntry, LogEntrySchema, type LogLevel, LogLevelSchema, type LoopCompleteSignal, LoopCompleteSignalSchema, type LoopCompletedEvent, LoopCompletedEventSchema, type LoopConfig, LoopConfigSchema, type LoopError, LoopErrorSchema, type LoopFailedEvent, LoopFailedEventSchema, type LoopStartedEvent, LoopStartedEventSchema, type LoopStatus, LoopStatusSchema, type LoopSummary, LoopSummarySchema, MemoryGit, MemoryGuardrails, MemoryPlan, MemoryProgress, MemorySession, Mock, Mock as MockLLM, OrchestratorError, type OrchestratorServices, ParseError, type Phase, type PhaseBasicInfo, PhaseBasicInfoSchema, type PhaseCompletedEvent, PhaseCompletedEventSchema, type PhaseCompletedSignal, PhaseCompletedSignalSchema, type PhaseFailedData, PhaseFailedDataSchema, type PhaseFailedEvent, PhaseFailedEventSchema, type PhaseFailedSignal, PhaseFailedSignalSchema, type PhaseIdData, PhaseIdDataSchema, type PhasePromptOverrides, PhasePromptOverridesSchema, PhaseSchema, type PhaseStartedEvent, PhaseStartedEventSchema, type PhaseStartedSignal, PhaseStartedSignalSchema, type PhaseStatus, PhaseStatusSchema, type PhasesDefinedData, PhasesDefinedDataSchema, type PhasesDefinedEvent, PhasesDefinedEventSchema, type PhasesDefinedSignal, PhasesDefinedSignalSchema, type Plan, type PlanCreatedEvent, PlanCreatedEventSchema, type PlanData, PlanDataSchema, PlanId, PlanSchema, PlanStore, PlanStoreError, type PlanStoreService, type PlanUpdateFailedEvent, PlanUpdateFailedEventSchema, type PlanUpdatedEvent, PlanUpdatedEventSchema, type PrUrl, ProductionLayers, type ProgressAction, ProgressActionSchema, type ProgressEntry, ProgressEntrySchema, type ProgressFile, ProgressFileSchema, ProgressStore, ProgressStoreError, type ProgressStoreService, type ProgressUpdatedEvent, ProgressUpdatedEventSchema, type PromptConfig, PromptConfigSchema, type ReviewCompleteData, ReviewCompleteDataSchema, type ReviewCompleteEvent, ReviewCompleteEventSchema, type ReviewCompleteSignal, ReviewCompleteSignalSchema, type RunOptions, type RunOptionsData, RunOptionsDataSchema, type Session, SessionSchema, type SessionStatus, SessionStatusSchema, SessionStore, SessionStoreError, type SessionStoreService, type Signal, type SignalAccumulator, SignalParser, type SignalParserService, SignalSchema, type TUICriterion, TUICriterionSchema, type TUICriterionStatus, TUICriterionStatusSchema, type TUIPhase, TUIPhaseSchema, type TUIPhaseStatus, TUIPhaseStatusSchema, type TUIState, TUIStateSchema, type TUITask, TUITaskSchema, type TUITaskStatus, TUITaskStatusSchema, type Task, type TaskBasicInfo, TaskBasicInfoSchema, type TaskCompleteData, TaskCompleteDataSchema, type TaskCompleteSignal, type TaskCompleteSignalData, TaskCompleteSignalDataSchema, TaskCompleteSignalSchema, type TaskCompletedEvent, TaskCompletedEventSchema, TaskSchema, type TaskStatus, TaskStatusSchema, type TasksDefinedData, TasksDefinedDataSchema, type TasksDefinedEvent, TasksDefinedEventSchema, type TasksDefinedSignal, TasksDefinedSignalSchema, TestLayers, type TextEvent, TextEventSchema, type ToolEndEvent, ToolEndEventSchema, type ToolStartEvent, ToolStartEventSchema, type ToolUseEvent, ToolUseEventSchema, type ViewMode, ViewModeSchema, type WorktreeCreatedEvent, WorktreeCreatedEventSchema, type WorktreeInfo, type WorktreePath, type WorktreeRemovedEvent, WorktreeRemovedEventSchema, buildPrompt, collectEvents, createHeadlessConsumer, createTUIConsumer, createTestLayers, decodeGuardrail, decodeGuardrailsFile, decodeLLMEvent, decodeLoopConfig, decodePlan, decodePlanData, decodeProgressEntry, decodeProgressFile, decodeSession, decodeSignal, decodeSignalSync, formatTasksMd, main, parseTasksMd, run, runLoop, runTest };
+export {  }