ferix-code 0.0.2-beta.2 → 0.0.2-beta.20

package/dist/index.d.ts

@@ -1,9 +1,10 @@
-import { Schema, Brand, Stream, Effect, Context, Layer } from 'effect';
+import { Schema, Either, Brand, ParseResult, 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';
+import * as effect_Layer from 'effect/Layer';
 
 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";
@@ -51,6 +52,30 @@ declare class SessionStoreError extends SessionStoreError_base<{
     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>;
@@ -63,11 +88,605 @@ declare class OrchestratorError extends OrchestratorError_base<{
     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" | "removeWorktreeKeepBranch" | "commit" | "push" | "createPR" | "renameBranch" | "branchLookup" | "getCurrentBranch" | "status";
+    readonly cause?: unknown;
+}> {
+}
+declare const TokenBudgetError_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: "TokenBudgetError";
+} & Readonly<A>;
+/**
+ * Error that occurs when token budget is exceeded.
+ */
+declare class TokenBudgetError extends TokenBudgetError_base<{
+    readonly message: string;
+    /** Total tokens used */
+    readonly budgetUsed: number;
+    /** Maximum tokens available */
+    readonly budgetMax: number;
+    /** Sections that couldn't fit */
+    readonly overflowSections: readonly string[];
+}> {
+}
+declare const RetryExhaustedError_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: "RetryExhaustedError";
+} & Readonly<A>;
+/**
+ * Error that occurs when all retry attempts are exhausted.
+ */
+declare class RetryExhaustedError extends RetryExhaustedError_base<{
+    readonly message: string;
+    /** Number of attempts made */
+    readonly attempts: number;
+    /** The final error that caused failure */
+    readonly finalError: string;
+    /** Iteration where retries were exhausted */
+    readonly iteration: number;
+}> {
+}
+declare const MetricsError_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: "MetricsError";
+} & Readonly<A>;
+/**
+ * Error that occurs during metrics operations.
+ */
+declare class MetricsError extends MetricsError_base<{
+    readonly message: string;
+    readonly operation: "record" | "get" | "clear";
+    readonly cause?: unknown;
+}> {
+}
 /**
  * Union of all possible errors in the system.
  */
-type FerixError = LLMError | ParseError | PlanStoreError | SessionStoreError | OrchestratorError;
+type FerixError = LLMError | ParseError | PlanStoreError | SessionStoreError | ProgressStoreError | GuardrailsStoreError | OrchestratorError | GitError | TokenBudgetError | RetryExhaustedError | MetricsError;
 
+/**
+ * Text delta event - streamed text content.
+ */
+declare const TextDeltaSchema: Schema.Struct<{
+    type: Schema.Literal<["text_delta"]>;
+    text: typeof Schema.String;
+}>;
+type TextDelta = typeof TextDeltaSchema.Type;
+/**
+ * Input JSON delta - partial tool input being streamed.
+ */
+declare const InputJsonDeltaSchema: Schema.Struct<{
+    type: Schema.Literal<["input_json_delta"]>;
+    partial_json: typeof Schema.String;
+}>;
+type InputJsonDelta = typeof InputJsonDeltaSchema.Type;
+/**
+ * Delta union - either text or input JSON delta.
+ */
+declare const DeltaSchema: Schema.Union<[Schema.Struct<{
+    type: Schema.Literal<["text_delta"]>;
+    text: typeof Schema.String;
+}>, Schema.Struct<{
+    type: Schema.Literal<["input_json_delta"]>;
+    partial_json: typeof Schema.String;
+}>]>;
+type Delta = typeof DeltaSchema.Type;
+/**
+ * Text content block in an assistant message.
+ */
+declare const TextContentBlockSchema: Schema.Struct<{
+    type: Schema.Literal<["text"]>;
+    text: typeof Schema.String;
+}>;
+type TextContentBlock = typeof TextContentBlockSchema.Type;
+/**
+ * Tool use content block with name and input.
+ */
+declare const ToolUseContentBlockSchema: Schema.Struct<{
+    type: Schema.Literal<["tool_use"]>;
+    id: Schema.optional<typeof Schema.String>;
+    name: typeof Schema.String;
+    input: typeof Schema.Unknown;
+}>;
+type ToolUseContentBlock = typeof ToolUseContentBlockSchema.Type;
+/**
+ * Content block union for assistant messages.
+ */
+declare const ContentBlockSchema: Schema.Union<[Schema.Struct<{
+    type: Schema.Literal<["text"]>;
+    text: typeof Schema.String;
+}>, Schema.Struct<{
+    type: Schema.Literal<["tool_use"]>;
+    id: Schema.optional<typeof Schema.String>;
+    name: typeof Schema.String;
+    input: typeof Schema.Unknown;
+}>]>;
+type ContentBlock = typeof ContentBlockSchema.Type;
+/**
+ * Content block start event - beginning of a content block.
+ */
+declare const ContentBlockStartSchema: Schema.Struct<{
+    type: Schema.Literal<["content_block_start"]>;
+    index: Schema.optional<typeof Schema.Number>;
+    content_block: Schema.Union<[Schema.Struct<{
+        type: Schema.Literal<["text"]>;
+        text: Schema.optional<typeof Schema.String>;
+    }>, Schema.Struct<{
+        type: Schema.Literal<["tool_use"]>;
+        id: Schema.optional<typeof Schema.String>;
+        name: typeof Schema.String;
+        input: Schema.optional<typeof Schema.Unknown>;
+    }>]>;
+}>;
+type ContentBlockStart = typeof ContentBlockStartSchema.Type;
+/**
+ * Content block delta event - incremental update to a content block.
+ */
+declare const ContentBlockDeltaSchema: Schema.Struct<{
+    type: Schema.Literal<["content_block_delta"]>;
+    index: Schema.optional<typeof Schema.Number>;
+    delta: Schema.Union<[Schema.Struct<{
+        type: Schema.Literal<["text_delta"]>;
+        text: typeof Schema.String;
+    }>, Schema.Struct<{
+        type: Schema.Literal<["input_json_delta"]>;
+        partial_json: typeof Schema.String;
+    }>]>;
+}>;
+type ContentBlockDelta = typeof ContentBlockDeltaSchema.Type;
+/**
+ * Content block stop event - end of a content block.
+ */
+declare const ContentBlockStopSchema: Schema.Struct<{
+    type: Schema.Literal<["content_block_stop"]>;
+    index: Schema.optional<typeof Schema.Number>;
+}>;
+type ContentBlockStop = typeof ContentBlockStopSchema.Type;
+/**
+ * Assistant message event with full content.
+ */
+declare const AssistantMessageSchema: Schema.Struct<{
+    type: Schema.Literal<["assistant"]>;
+    message: Schema.Struct<{
+        content: Schema.Array$<Schema.Union<[Schema.Struct<{
+            type: Schema.Literal<["text"]>;
+            text: typeof Schema.String;
+        }>, Schema.Struct<{
+            type: Schema.Literal<["tool_use"]>;
+            id: Schema.optional<typeof Schema.String>;
+            name: typeof Schema.String;
+            input: typeof Schema.Unknown;
+        }>]>>;
+    }>;
+}>;
+type AssistantMessage = typeof AssistantMessageSchema.Type;
+/**
+ * Stream event envelope - CLI wraps streaming events in this format.
+ */
+declare const StreamEventEnvelopeSchema: Schema.Struct<{
+    type: Schema.Literal<["stream_event"]>;
+    event: typeof Schema.Unknown;
+}>;
+type StreamEventEnvelope = typeof StreamEventEnvelopeSchema.Type;
+/**
+ * Union of all Claude/Cursor CLI streaming events.
+ */
+declare const ClaudeCliEventSchema: Schema.Union<[Schema.Struct<{
+    type: Schema.Literal<["content_block_start"]>;
+    index: Schema.optional<typeof Schema.Number>;
+    content_block: Schema.Union<[Schema.Struct<{
+        type: Schema.Literal<["text"]>;
+        text: Schema.optional<typeof Schema.String>;
+    }>, Schema.Struct<{
+        type: Schema.Literal<["tool_use"]>;
+        id: Schema.optional<typeof Schema.String>;
+        name: typeof Schema.String;
+        input: Schema.optional<typeof Schema.Unknown>;
+    }>]>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["content_block_delta"]>;
+    index: Schema.optional<typeof Schema.Number>;
+    delta: Schema.Union<[Schema.Struct<{
+        type: Schema.Literal<["text_delta"]>;
+        text: typeof Schema.String;
+    }>, Schema.Struct<{
+        type: Schema.Literal<["input_json_delta"]>;
+        partial_json: typeof Schema.String;
+    }>]>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["content_block_stop"]>;
+    index: Schema.optional<typeof Schema.Number>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["assistant"]>;
+    message: Schema.Struct<{
+        content: Schema.Array$<Schema.Union<[Schema.Struct<{
+            type: Schema.Literal<["text"]>;
+            text: typeof Schema.String;
+        }>, Schema.Struct<{
+            type: Schema.Literal<["tool_use"]>;
+            id: Schema.optional<typeof Schema.String>;
+            name: typeof Schema.String;
+            input: typeof Schema.Unknown;
+        }>]>>;
+    }>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["stream_event"]>;
+    event: typeof Schema.Unknown;
+}>]>;
+type ClaudeCliEvent = typeof ClaudeCliEventSchema.Type;
+/**
+ * Type guards using Effect Schema.
+ */
+declare const isContentBlockStart: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly type: "content_block_start";
+    readonly index?: number | undefined;
+    readonly content_block: {
+        readonly type: "text";
+        readonly text?: string | undefined;
+    } | {
+        readonly type: "tool_use";
+        readonly input?: unknown;
+        readonly id?: string | undefined;
+        readonly name: string;
+    };
+};
+declare const isContentBlockDelta: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly type: "content_block_delta";
+    readonly index?: number | undefined;
+    readonly delta: {
+        readonly type: "text_delta";
+        readonly text: string;
+    } | {
+        readonly type: "input_json_delta";
+        readonly partial_json: string;
+    };
+};
+declare const isContentBlockStop: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly type: "content_block_stop";
+    readonly index?: number | undefined;
+};
+declare const isAssistantMessage: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly type: "assistant";
+    readonly message: {
+        readonly content: readonly ({
+            readonly type: "text";
+            readonly text: string;
+        } | {
+            readonly type: "tool_use";
+            readonly input: unknown;
+            readonly id?: string | undefined;
+            readonly name: string;
+        })[];
+    };
+};
+declare const isStreamEventEnvelope: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly type: "stream_event";
+    readonly event: unknown;
+};
+declare const isTextDelta: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly type: "text_delta";
+    readonly text: string;
+};
+declare const isInputJsonDelta: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly type: "input_json_delta";
+    readonly partial_json: string;
+};
+declare const isToolUseContentBlock: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly type: "tool_use";
+    readonly input: unknown;
+    readonly id?: string | undefined;
+    readonly name: string;
+};
+declare const isTextContentBlock: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly type: "text";
+    readonly text: string;
+};
+/**
+ * Decode helpers.
+ */
+declare const decodeClaudeCliEvent: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
+    readonly type: "content_block_start";
+    readonly index?: number | undefined;
+    readonly content_block: {
+        readonly type: "text";
+        readonly text?: string | undefined;
+    } | {
+        readonly type: "tool_use";
+        readonly input?: unknown;
+        readonly id?: string | undefined;
+        readonly name: string;
+    };
+} | {
+    readonly type: "content_block_delta";
+    readonly index?: number | undefined;
+    readonly delta: {
+        readonly type: "text_delta";
+        readonly text: string;
+    } | {
+        readonly type: "input_json_delta";
+        readonly partial_json: string;
+    };
+} | {
+    readonly type: "content_block_stop";
+    readonly index?: number | undefined;
+} | {
+    readonly type: "assistant";
+    readonly message: {
+        readonly content: readonly ({
+            readonly type: "text";
+            readonly text: string;
+        } | {
+            readonly type: "tool_use";
+            readonly input: unknown;
+            readonly id?: string | undefined;
+            readonly name: string;
+        })[];
+    };
+} | {
+    readonly type: "stream_event";
+    readonly event: unknown;
+}, effect_ParseResult.ParseError, never>;
+declare const decodeClaudeCliEventSync: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => {
+    readonly type: "content_block_start";
+    readonly index?: number | undefined;
+    readonly content_block: {
+        readonly type: "text";
+        readonly text?: string | undefined;
+    } | {
+        readonly type: "tool_use";
+        readonly input?: unknown;
+        readonly id?: string | undefined;
+        readonly name: string;
+    };
+} | {
+    readonly type: "content_block_delta";
+    readonly index?: number | undefined;
+    readonly delta: {
+        readonly type: "text_delta";
+        readonly text: string;
+    } | {
+        readonly type: "input_json_delta";
+        readonly partial_json: string;
+    };
+} | {
+    readonly type: "content_block_stop";
+    readonly index?: number | undefined;
+} | {
+    readonly type: "assistant";
+    readonly message: {
+        readonly content: readonly ({
+            readonly type: "text";
+            readonly text: string;
+        } | {
+            readonly type: "tool_use";
+            readonly input: unknown;
+            readonly id?: string | undefined;
+            readonly name: string;
+        })[];
+    };
+} | {
+    readonly type: "stream_event";
+    readonly event: unknown;
+};
+
+/**
+ * Text content event from OpenCode.
+ */
+declare const OpenCodeTextEventSchema: Schema.Struct<{
+    type: Schema.Literal<["text"]>;
+    text: typeof Schema.String;
+}>;
+type OpenCodeTextEvent = typeof OpenCodeTextEventSchema.Type;
+/**
+ * Tool state within a tool_use event.
+ */
+declare const OpenCodeToolStateSchema: Schema.Struct<{
+    status: typeof Schema.String;
+    input: typeof Schema.Unknown;
+    output: Schema.optional<typeof Schema.String>;
+}>;
+type OpenCodeToolState = typeof OpenCodeToolStateSchema.Type;
+/**
+ * Tool part within a tool_use event.
+ */
+declare const OpenCodeToolPartSchema: Schema.Struct<{
+    tool: typeof Schema.String;
+    callID: typeof Schema.String;
+    state: Schema.Struct<{
+        status: typeof Schema.String;
+        input: typeof Schema.Unknown;
+        output: Schema.optional<typeof Schema.String>;
+    }>;
+}>;
+type OpenCodeToolPart = typeof OpenCodeToolPartSchema.Type;
+/**
+ * Tool use event from OpenCode - complete tool invocation with input/output.
+ */
+declare const OpenCodeToolUseEventSchema: Schema.Struct<{
+    type: Schema.Literal<["tool_use"]>;
+    part: Schema.Struct<{
+        tool: typeof Schema.String;
+        callID: typeof Schema.String;
+        state: Schema.Struct<{
+            status: typeof Schema.String;
+            input: typeof Schema.Unknown;
+            output: Schema.optional<typeof Schema.String>;
+        }>;
+    }>;
+}>;
+type OpenCodeToolUseEvent = typeof OpenCodeToolUseEventSchema.Type;
+/**
+ * Part information in step_start events.
+ */
+declare const OpenCodeStepPartSchema: Schema.extend<Schema.Struct<{}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+type OpenCodeStepPart = typeof OpenCodeStepPartSchema.Type;
+/**
+ * Step start event from OpenCode.
+ */
+declare const OpenCodeStepStartSchema: Schema.Struct<{
+    type: Schema.Literal<["step_start"]>;
+    timestamp: typeof Schema.Number;
+    sessionID: typeof Schema.String;
+    part: Schema.optional<Schema.extend<Schema.Struct<{}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>>;
+}>;
+type OpenCodeStepStart = typeof OpenCodeStepStartSchema.Type;
+/**
+ * Token information in step_finish events.
+ */
+declare const OpenCodeTokensSchema: Schema.extend<Schema.Struct<{}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+type OpenCodeTokens = typeof OpenCodeTokensSchema.Type;
+/**
+ * Cost information in step_finish events.
+ */
+declare const OpenCodeCostSchema: Schema.extend<Schema.Struct<{}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+type OpenCodeCost = typeof OpenCodeCostSchema.Type;
+/**
+ * Step finish event from OpenCode.
+ */
+declare const OpenCodeStepFinishSchema: Schema.Struct<{
+    type: Schema.Literal<["step_finish"]>;
+    tokens: Schema.optional<Schema.extend<Schema.Struct<{}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>>;
+    cost: Schema.optional<Schema.extend<Schema.Struct<{}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>>;
+}>;
+type OpenCodeStepFinish = typeof OpenCodeStepFinishSchema.Type;
+/**
+ * Union of all OpenCode CLI streaming events.
+ */
+declare const OpenCodeCliEventSchema: Schema.Union<[Schema.Struct<{
+    type: Schema.Literal<["text"]>;
+    text: typeof Schema.String;
+}>, Schema.Struct<{
+    type: Schema.Literal<["tool_use"]>;
+    part: Schema.Struct<{
+        tool: typeof Schema.String;
+        callID: typeof Schema.String;
+        state: Schema.Struct<{
+            status: typeof Schema.String;
+            input: typeof Schema.Unknown;
+            output: Schema.optional<typeof Schema.String>;
+        }>;
+    }>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["step_start"]>;
+    timestamp: typeof Schema.Number;
+    sessionID: typeof Schema.String;
+    part: Schema.optional<Schema.extend<Schema.Struct<{}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["step_finish"]>;
+    tokens: Schema.optional<Schema.extend<Schema.Struct<{}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>>;
+    cost: Schema.optional<Schema.extend<Schema.Struct<{}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>>;
+}>]>;
+type OpenCodeCliEvent = typeof OpenCodeCliEventSchema.Type;
+/**
+ * Type guards using Effect Schema.
+ */
+declare const isOpenCodeTextEvent: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly type: "text";
+    readonly text: string;
+};
+declare const isOpenCodeToolUseEvent: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly type: "tool_use";
+    readonly part: {
+        readonly tool: string;
+        readonly callID: string;
+        readonly state: {
+            readonly input: unknown;
+            readonly status: string;
+            readonly output?: string | undefined;
+        };
+    };
+};
+declare const isOpenCodeStepStart: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly type: "step_start";
+    readonly part?: ({} & {
+        readonly [x: string]: unknown;
+    }) | undefined;
+    readonly timestamp: number;
+    readonly sessionID: string;
+};
+declare const isOpenCodeStepFinish: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly type: "step_finish";
+    readonly tokens?: ({} & {
+        readonly [x: string]: unknown;
+    }) | undefined;
+    readonly cost?: ({} & {
+        readonly [x: string]: unknown;
+    }) | undefined;
+};
+/**
+ * Decode helpers.
+ */
+declare const decodeOpenCodeCliEvent: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "tool_use";
+    readonly part: {
+        readonly tool: string;
+        readonly callID: string;
+        readonly state: {
+            readonly input: unknown;
+            readonly status: string;
+            readonly output?: string | undefined;
+        };
+    };
+} | {
+    readonly type: "step_start";
+    readonly part?: ({} & {
+        readonly [x: string]: unknown;
+    }) | undefined;
+    readonly timestamp: number;
+    readonly sessionID: string;
+} | {
+    readonly type: "step_finish";
+    readonly tokens?: ({} & {
+        readonly [x: string]: unknown;
+    }) | undefined;
+    readonly cost?: ({} & {
+        readonly [x: string]: unknown;
+    }) | undefined;
+}, effect_ParseResult.ParseError, never>;
+declare const decodeOpenCodeCliEventSync: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "tool_use";
+    readonly part: {
+        readonly tool: string;
+        readonly callID: string;
+        readonly state: {
+            readonly input: unknown;
+            readonly status: string;
+            readonly output?: string | undefined;
+        };
+    };
+} | {
+    readonly type: "step_start";
+    readonly part?: ({} & {
+        readonly [x: string]: unknown;
+    }) | undefined;
+    readonly timestamp: number;
+    readonly sessionID: string;
+} | {
+    readonly type: "step_finish";
+    readonly tokens?: ({} & {
+        readonly [x: string]: unknown;
+    }) | undefined;
+    readonly cost?: ({} & {
+        readonly [x: string]: unknown;
+    }) | undefined;
+};
+
+/**
+ * Supported LLM provider names.
+ */
+declare const ProviderNameSchema: Schema.Literal<["claude", "cursor", "opencode"]>;
+type ProviderName = typeof ProviderNameSchema.Type;
 declare const PhasePromptOverridesSchema: Schema.Struct<{
     breakdown: Schema.optional<typeof Schema.String>;
     planning: Schema.optional<typeof Schema.String>;
@@ -114,6 +733,8 @@ declare const LoopConfigSchema: Schema.Struct<{
         }>>;
         additionalContext: Schema.optional<typeof Schema.String>;
     }>>;
+    /** LLM provider to use. Defaults to "claude". */
+    provider: Schema.optional<Schema.Literal<["claude", "cursor", "opencode"]>>;
 }>;
 type LoopConfig = typeof LoopConfigSchema.Type;
 declare const LoopSummarySchema: Schema.Struct<{
@@ -122,6 +743,8 @@ declare const LoopSummarySchema: Schema.Struct<{
     sessionId: typeof Schema.String;
     completedTasks: Schema.Array$<typeof Schema.String>;
     durationMs: typeof Schema.Number;
+    branchPushed: Schema.optional<typeof Schema.Boolean>;
+    prUrl: Schema.optional<typeof Schema.String>;
 }>;
 type LoopSummary = typeof LoopSummarySchema.Type;
 declare const LoopErrorSchema: Schema.Struct<{
@@ -152,6 +775,7 @@ declare const decodeLoopConfig: (u: unknown, overrideOptions?: effect_SchemaAST.
         } | undefined;
         readonly additionalContext?: string | undefined;
     } | undefined;
+    readonly provider?: "claude" | "cursor" | "opencode" | undefined;
 }, effect_ParseResult.ParseError, never>;
 
 /**
@@ -180,6 +804,7 @@ declare const LoopStartedEventSchema: Schema.TaggedStruct<"LoopStarted", {
             }>>;
             additionalContext: Schema.optional<typeof Schema.String>;
         }>>;
+        provider: Schema.optional<Schema.Literal<["claude", "cursor", "opencode"]>>;
     }>;
     timestamp: typeof Schema.Number;
 }>;
@@ -191,6 +816,8 @@ declare const LoopCompletedEventSchema: Schema.TaggedStruct<"LoopCompleted", {
         sessionId: typeof Schema.String;
         completedTasks: Schema.Array$<typeof Schema.String>;
         durationMs: typeof Schema.Number;
+        branchPushed: Schema.optional<typeof Schema.Boolean>;
+        prUrl: Schema.optional<typeof Schema.String>;
     }>;
 }>;
 type LoopCompletedEvent = typeof LoopCompletedEventSchema.Type;
@@ -393,6 +1020,88 @@ declare const PlanUpdateFailedEventSchema: Schema.TaggedStruct<"PlanUpdateFailed
     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;
+/**
+ * Branch pushed event - signals that a branch was pushed to origin.
+ */
+declare const BranchPushedEventSchema: Schema.TaggedStruct<"BranchPushed", {
+    sessionId: typeof Schema.String;
+    branchName: typeof Schema.String;
+    timestamp: typeof Schema.Number;
+}>;
+type BranchPushedEvent = typeof BranchPushedEventSchema.Type;
+/**
+ * PR created event - signals that a pull request was created.
+ */
+declare const PRCreatedEventSchema: Schema.TaggedStruct<"PRCreated", {
+    sessionId: typeof Schema.String;
+    prUrl: typeof Schema.String;
+    title: typeof Schema.String;
+    timestamp: typeof Schema.Number;
+}>;
+type PRCreatedEvent = typeof PRCreatedEventSchema.Type;
+/**
+ * Session name generated event - signals that the LLM generated a descriptive name for the session.
+ * Emitted during the discovery phase after the session name signal is parsed.
+ */
+declare const SessionNameGeneratedEventSchema: Schema.TaggedStruct<"SessionNameGenerated", {
+    sessionId: typeof Schema.String;
+    /** Task-based descriptive name (kebab-case slug, e.g., "add-dark-mode-toggle") */
+    displayName: typeof Schema.String;
+    timestamp: typeof Schema.Number;
+}>;
+type SessionNameGeneratedEvent = typeof SessionNameGeneratedEventSchema.Type;
 /**
  * Union of all domain events.
  */
@@ -419,6 +1128,7 @@ declare const DomainEventSchema: Schema.Union<[Schema.TaggedStruct<"LoopStarted"
             }>>;
             additionalContext: Schema.optional<typeof Schema.String>;
         }>>;
+        provider: Schema.optional<Schema.Literal<["claude", "cursor", "opencode"]>>;
     }>;
     timestamp: typeof Schema.Number;
 }>, Schema.TaggedStruct<"LoopCompleted", {
@@ -428,6 +1138,8 @@ declare const DomainEventSchema: Schema.Union<[Schema.TaggedStruct<"LoopStarted"
         sessionId: typeof Schema.String;
         completedTasks: Schema.Array$<typeof Schema.String>;
         durationMs: typeof Schema.Number;
+        branchPushed: Schema.optional<typeof Schema.Boolean>;
+        prUrl: Schema.optional<typeof Schema.String>;
     }>;
 }>, Schema.TaggedStruct<"LoopFailed", {
     error: Schema.Struct<{
@@ -550,11 +1262,52 @@ declare const DomainEventSchema: Schema.Union<[Schema.TaggedStruct<"LoopStarted"
     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;
+}>, Schema.TaggedStruct<"BranchPushed", {
+    sessionId: typeof Schema.String;
+    branchName: typeof Schema.String;
+    timestamp: typeof Schema.Number;
+}>, Schema.TaggedStruct<"PRCreated", {
+    sessionId: typeof Schema.String;
+    prUrl: typeof Schema.String;
+    title: typeof Schema.String;
+    timestamp: typeof Schema.Number;
+}>, Schema.TaggedStruct<"SessionNameGenerated", {
+    sessionId: typeof Schema.String;
+    /** Task-based descriptive name (kebab-case slug, e.g., "add-dark-mode-toggle") */
+    displayName: 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;
+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 | BranchPushedEvent | PRCreatedEvent | SessionNameGeneratedEvent;
 /**
  * Type guard utilities for domain events.
  */
@@ -566,16 +1319,382 @@ declare const DomainEventUtils: {
     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>;
+
+/**
+ * Read tool input schema.
+ */
+declare const ReadToolInputSchema: Schema.extend<Schema.Struct<{
+    file_path: typeof Schema.String;
+    offset: Schema.optional<typeof Schema.Number>;
+    limit: Schema.optional<typeof Schema.Number>;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+type ReadToolInput = typeof ReadToolInputSchema.Type;
+/**
+ * Edit tool input schema.
+ */
+declare const EditToolInputSchema: Schema.extend<Schema.Struct<{
+    file_path: typeof Schema.String;
+    old_string: typeof Schema.String;
+    new_string: typeof Schema.String;
+    replace_all: Schema.optional<typeof Schema.Boolean>;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+type EditToolInput = typeof EditToolInputSchema.Type;
+/**
+ * Write tool input schema.
+ */
+declare const WriteToolInputSchema: Schema.extend<Schema.Struct<{
+    file_path: typeof Schema.String;
+    content: typeof Schema.String;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+type WriteToolInput = typeof WriteToolInputSchema.Type;
+/**
+ * Bash tool input schema.
+ */
+declare const BashToolInputSchema: Schema.extend<Schema.Struct<{
+    command: typeof Schema.String;
+    description: Schema.optional<typeof Schema.String>;
+    timeout: Schema.optional<typeof Schema.Number>;
+    run_in_background: Schema.optional<typeof Schema.Boolean>;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+type BashToolInput = typeof BashToolInputSchema.Type;
+/**
+ * Glob tool input schema.
+ */
+declare const GlobToolInputSchema: Schema.extend<Schema.Struct<{
+    pattern: typeof Schema.String;
+    path: Schema.optional<typeof Schema.String>;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+type GlobToolInput = typeof GlobToolInputSchema.Type;
+/**
+ * Grep tool input schema.
+ */
+declare const GrepToolInputSchema: Schema.extend<Schema.Struct<{
+    pattern: typeof Schema.String;
+    path: Schema.optional<typeof Schema.String>;
+    glob: Schema.optional<typeof Schema.String>;
+    type: Schema.optional<typeof Schema.String>;
+    output_mode: Schema.optional<Schema.Literal<["content", "files_with_matches", "count"]>>;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+type GrepToolInput = typeof GrepToolInputSchema.Type;
+/**
+ * Task tool input schema.
+ */
+declare const TaskToolInputSchema: Schema.extend<Schema.Struct<{
+    description: typeof Schema.String;
+    prompt: Schema.optional<typeof Schema.String>;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+type TaskToolInput = typeof TaskToolInputSchema.Type;
+/**
+ * WebFetch tool input schema.
+ */
+declare const WebFetchToolInputSchema: Schema.extend<Schema.Struct<{
+    url: typeof Schema.String;
+    prompt: Schema.optional<typeof Schema.String>;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+type WebFetchToolInput = typeof WebFetchToolInputSchema.Type;
+/**
+ * WebSearch tool input schema.
+ */
+declare const WebSearchToolInputSchema: Schema.extend<Schema.Struct<{
+    query: typeof Schema.String;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+type WebSearchToolInput = typeof WebSearchToolInputSchema.Type;
+/**
+ * Registry of tool input schemas.
+ */
+declare const ToolInputSchemaRegistry: {
+    readonly read: Schema.extend<Schema.Struct<{
+        file_path: typeof Schema.String;
+        offset: Schema.optional<typeof Schema.Number>;
+        limit: Schema.optional<typeof Schema.Number>;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly edit: Schema.extend<Schema.Struct<{
+        file_path: typeof Schema.String;
+        old_string: typeof Schema.String;
+        new_string: typeof Schema.String;
+        replace_all: Schema.optional<typeof Schema.Boolean>;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly write: Schema.extend<Schema.Struct<{
+        file_path: typeof Schema.String;
+        content: typeof Schema.String;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly bash: Schema.extend<Schema.Struct<{
+        command: typeof Schema.String;
+        description: Schema.optional<typeof Schema.String>;
+        timeout: Schema.optional<typeof Schema.Number>;
+        run_in_background: Schema.optional<typeof Schema.Boolean>;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly glob: Schema.extend<Schema.Struct<{
+        pattern: typeof Schema.String;
+        path: Schema.optional<typeof Schema.String>;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly grep: Schema.extend<Schema.Struct<{
+        pattern: typeof Schema.String;
+        path: Schema.optional<typeof Schema.String>;
+        glob: Schema.optional<typeof Schema.String>;
+        type: Schema.optional<typeof Schema.String>;
+        output_mode: Schema.optional<Schema.Literal<["content", "files_with_matches", "count"]>>;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly task: Schema.extend<Schema.Struct<{
+        description: typeof Schema.String;
+        prompt: Schema.optional<typeof Schema.String>;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly webfetch: Schema.extend<Schema.Struct<{
+        url: typeof Schema.String;
+        prompt: Schema.optional<typeof Schema.String>;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly websearch: Schema.extend<Schema.Struct<{
+        query: typeof Schema.String;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+};
+/**
+ * Known tool names.
+ */
+type KnownToolName = keyof typeof ToolInputSchemaRegistry;
+/**
+ * Get the input schema for a tool.
+ *
+ * @param tool - Tool name (case-insensitive)
+ * @returns Schema for the tool or undefined if not found
+ */
+declare function getToolInputSchema(tool: string): Schema.Schema<AnyToolInput, AnyToolInput, never> | undefined;
+/**
+ * Union of all known tool inputs.
+ */
+declare const AnyToolInputSchema: Schema.Union<[Schema.extend<Schema.Struct<{
+    file_path: typeof Schema.String;
+    offset: Schema.optional<typeof Schema.Number>;
+    limit: Schema.optional<typeof Schema.Number>;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, Schema.extend<Schema.Struct<{
+    file_path: typeof Schema.String;
+    old_string: typeof Schema.String;
+    new_string: typeof Schema.String;
+    replace_all: Schema.optional<typeof Schema.Boolean>;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, Schema.extend<Schema.Struct<{
+    file_path: typeof Schema.String;
+    content: typeof Schema.String;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, Schema.extend<Schema.Struct<{
+    command: typeof Schema.String;
+    description: Schema.optional<typeof Schema.String>;
+    timeout: Schema.optional<typeof Schema.Number>;
+    run_in_background: Schema.optional<typeof Schema.Boolean>;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, Schema.extend<Schema.Struct<{
+    pattern: typeof Schema.String;
+    path: Schema.optional<typeof Schema.String>;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, Schema.extend<Schema.Struct<{
+    pattern: typeof Schema.String;
+    path: Schema.optional<typeof Schema.String>;
+    glob: Schema.optional<typeof Schema.String>;
+    type: Schema.optional<typeof Schema.String>;
+    output_mode: Schema.optional<Schema.Literal<["content", "files_with_matches", "count"]>>;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, Schema.extend<Schema.Struct<{
+    description: typeof Schema.String;
+    prompt: Schema.optional<typeof Schema.String>;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, Schema.extend<Schema.Struct<{
+    url: typeof Schema.String;
+    prompt: Schema.optional<typeof Schema.String>;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, Schema.extend<Schema.Struct<{
+    query: typeof Schema.String;
+}>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>]>;
+type AnyToolInput = typeof AnyToolInputSchema.Type;
+/**
+ * Validate a tool input against its schema.
+ *
+ * @param tool - Tool name
+ * @param input - Input to validate
+ * @returns Either with validated input or parse error
+ */
+declare function validateToolInput(tool: string, input: unknown): Either.Either<AnyToolInput, unknown>;
+/**
+ * Type guards for specific tool inputs.
+ */
+declare const isReadToolInput: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly file_path: string;
+    readonly offset?: number | undefined;
+    readonly limit?: number | undefined;
+} & {
+    readonly [x: string]: unknown;
+};
+declare const isEditToolInput: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly file_path: string;
+    readonly old_string: string;
+    readonly new_string: string;
+    readonly replace_all?: boolean | undefined;
+} & {
+    readonly [x: string]: unknown;
+};
+declare const isWriteToolInput: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly content: string;
+    readonly file_path: string;
+} & {
+    readonly [x: string]: unknown;
+};
+declare const isBashToolInput: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly description?: string | undefined;
+    readonly command: string;
+    readonly timeout?: number | undefined;
+    readonly run_in_background?: boolean | undefined;
+} & {
+    readonly [x: string]: unknown;
+};
+declare const isGlobToolInput: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly pattern: string;
+    readonly path?: string | undefined;
+} & {
+    readonly [x: string]: unknown;
+};
+declare const isGrepToolInput: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly type?: string | undefined;
+    readonly pattern: string;
+    readonly path?: string | undefined;
+    readonly glob?: string | undefined;
+    readonly output_mode?: "content" | "files_with_matches" | "count" | undefined;
+} & {
+    readonly [x: string]: unknown;
+};
+declare const isTaskToolInput: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly description: string;
+    readonly prompt?: string | undefined;
+} & {
+    readonly [x: string]: unknown;
+};
+declare const isWebFetchToolInput: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly prompt?: string | undefined;
+    readonly url: string;
+} & {
+    readonly [x: string]: unknown;
+};
+declare const isWebSearchToolInput: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
+    readonly query: string;
+} & {
+    readonly [x: string]: unknown;
+};
+
 declare const TextEventSchema: Schema.TaggedStruct<"Text", {
     text: typeof Schema.String;
 }>;
 declare const ToolStartEventSchema: Schema.TaggedStruct<"ToolStart", {
     tool: typeof Schema.String;
 }>;
+/**
+ * Tool use event schema.
+ *
+ * The input field uses AnyToolInputSchema for known tools,
+ * but falls back to S.Unknown for forward compatibility with
+ * unknown tools or new tool versions.
+ */
 declare const ToolUseEventSchema: Schema.TaggedStruct<"ToolUse", {
     tool: typeof Schema.String;
     input: typeof Schema.Unknown;
 }>;
+/**
+ * Validated tool use event schema - validates input against known tool schemas.
+ * Use this when you want strict validation of tool inputs.
+ */
+declare const ValidatedToolUseEventSchema: Schema.TaggedStruct<"ToolUse", {
+    tool: typeof Schema.String;
+    input: Schema.Union<[Schema.extend<Schema.Struct<{
+        file_path: typeof Schema.String;
+        offset: Schema.optional<typeof Schema.Number>;
+        limit: Schema.optional<typeof Schema.Number>;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, Schema.extend<Schema.Struct<{
+        file_path: typeof Schema.String;
+        old_string: typeof Schema.String;
+        new_string: typeof Schema.String;
+        replace_all: Schema.optional<typeof Schema.Boolean>;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, Schema.extend<Schema.Struct<{
+        file_path: typeof Schema.String;
+        content: typeof Schema.String;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, Schema.extend<Schema.Struct<{
+        command: typeof Schema.String;
+        description: Schema.optional<typeof Schema.String>;
+        timeout: Schema.optional<typeof Schema.Number>;
+        run_in_background: Schema.optional<typeof Schema.Boolean>;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, Schema.extend<Schema.Struct<{
+        pattern: typeof Schema.String;
+        path: Schema.optional<typeof Schema.String>;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, Schema.extend<Schema.Struct<{
+        pattern: typeof Schema.String;
+        path: Schema.optional<typeof Schema.String>;
+        glob: Schema.optional<typeof Schema.String>;
+        type: Schema.optional<typeof Schema.String>;
+        output_mode: Schema.optional<Schema.Literal<["content", "files_with_matches", "count"]>>;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, Schema.extend<Schema.Struct<{
+        description: typeof Schema.String;
+        prompt: Schema.optional<typeof Schema.String>;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, Schema.extend<Schema.Struct<{
+        url: typeof Schema.String;
+        prompt: Schema.optional<typeof Schema.String>;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, Schema.extend<Schema.Struct<{
+        query: typeof Schema.String;
+    }>, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>]>;
+}>;
 declare const ToolEndEventSchema: Schema.TaggedStruct<"ToolEnd", {
     tool: typeof Schema.String;
 }>;
@@ -600,6 +1719,14 @@ type ToolUseEvent = typeof ToolUseEventSchema.Type;
 type ToolEndEvent = typeof ToolEndEventSchema.Type;
 type DoneEvent = typeof DoneEventSchema.Type;
 type LLMEvent = TextEvent | ToolStartEvent | ToolUseEvent | ToolEndEvent | DoneEvent;
+/**
+ * Validated tool use event type with typed input.
+ */
+interface ValidatedToolUseEvent {
+    readonly _tag: "ToolUse";
+    readonly tool: string;
+    readonly input: AnyToolInput;
+}
 declare const decodeLLMEvent: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
     readonly _tag: "Text";
     readonly text: string;
@@ -617,6 +1744,13 @@ declare const decodeLLMEvent: (u: unknown, overrideOptions?: effect_SchemaAST.Pa
     readonly _tag: "Done";
     readonly output: string;
 }, effect_ParseResult.ParseError, never>;
+/**
+ * Create a validated ToolUseEvent by validating the input against the tool's schema.
+ *
+ * @param event - ToolUseEvent with unknown input
+ * @returns Either with validated event or parse error
+ */
+declare function validateToolUseEvent(event: ToolUseEvent): Either.Either<ToolUseEvent, unknown>;
 
 declare const LogLevelSchema: Schema.Literal<["debug", "info", "warn", "error"]>;
 type LogLevel = typeof LogLevelSchema.Type;
@@ -769,22 +1903,22 @@ declare const decodePlan: (u: unknown, overrideOptions?: effect_SchemaAST.ParseO
     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: "pending" | "in_progress" | "done" | "failed";
         }[];
+        readonly status: "planning" | "pending" | "in_progress" | "done" | "failed" | "skipped";
+        readonly attempts: number;
         readonly id: string;
         readonly description: string;
-        readonly status: "planning" | "pending" | "in_progress" | "done" | "failed" | "skipped";
         readonly title: string;
         readonly criteria: readonly {
+            readonly status: "pending" | "failed" | "passed";
             readonly id: string;
             readonly description: string;
-            readonly status: "pending" | "failed" | "passed";
             readonly failureReason?: string | undefined;
         }[];
         readonly filesToModify: readonly string[];
-        readonly attempts: number;
         readonly completionNotes?: string | undefined;
     }[];
 }, effect_ParseResult.ParseError, never>;
@@ -795,22 +1929,22 @@ declare const decodePlanData: (u: unknown, overrideOptions?: effect_SchemaAST.Pa
     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: "pending" | "in_progress" | "done" | "failed";
         }[];
+        readonly status: "planning" | "pending" | "in_progress" | "done" | "failed" | "skipped";
+        readonly attempts: number;
         readonly id: string;
         readonly description: string;
-        readonly status: "planning" | "pending" | "in_progress" | "done" | "failed" | "skipped";
         readonly title: string;
         readonly criteria: readonly {
+            readonly status: "pending" | "failed" | "passed";
             readonly id: string;
             readonly description: string;
-            readonly status: "pending" | "failed" | "passed";
             readonly failureReason?: string | undefined;
         }[];
         readonly filesToModify: readonly string[];
-        readonly attempts: number;
         readonly completionNotes?: string | undefined;
     }[];
 }, effect_ParseResult.ParseError, never>;
@@ -840,11 +1974,83 @@ declare const RunOptionsDataSchema: Schema.Struct<{
             }>>;
             additionalContext: Schema.optional<typeof Schema.String>;
         }>>;
+        provider: Schema.optional<Schema.Literal<["claude", "cursor", "opencode"]>>;
     }>;
     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 timestamp: string;
+    readonly taskId: string;
+    readonly summary: string;
+    readonly filesModified?: readonly string[] | undefined;
+    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 timestamp: string;
+        readonly taskId: string;
+        readonly summary: string;
+        readonly filesModified?: readonly string[] | undefined;
+        readonly action: "failed" | "started" | "completed" | "learning";
+        readonly learnings?: readonly string[] | undefined;
+    }[];
+    readonly sessionId: string;
+    readonly createdAt: string;
+}, effect_ParseResult.ParseError, never>;
+
 /**
  * Session status schema.
  */
@@ -860,18 +2066,28 @@ declare const SessionSchema: Schema.Struct<{
     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>;
+    /** Task-based descriptive name (kebab-case slug, e.g., "add-dark-mode-toggle") */
+    displayName: Schema.optional<typeof Schema.String>;
+    /** The branch ferix was started from - used as PR base branch */
+    baseBranch: 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 completedTasks: readonly string[];
+    readonly status: "failed" | "completed" | "active" | "paused";
     readonly id: string;
-    readonly status: "failed" | "active" | "completed" | "paused";
+    readonly completedTasks: readonly string[];
     readonly createdAt: string;
     readonly originalTask: string;
+    readonly worktreePath?: string | undefined;
+    readonly branchName?: string | undefined;
+    readonly displayName?: string | undefined;
     readonly currentTaskId?: string | undefined;
+    readonly baseBranch?: string | undefined;
 }, effect_ParseResult.ParseError, never>;
 
 /**
@@ -1024,6 +2240,38 @@ declare const TaskCompleteSignalSchema: Schema.TaggedStruct<"TaskComplete", Read
 type TaskCompleteSignal = typeof TaskCompleteSignalSchema.Type;
 declare const LoopCompleteSignalSchema: Schema.TaggedStruct<"LoopComplete", {}>;
 type LoopCompleteSignal = typeof LoopCompleteSignalSchema.Type;
+/**
+ * Session name signal - defines a task-based descriptive name for the session.
+ * Generated during discovery phase.
+ */
+declare const SessionNameDefinedSignalSchema: Schema.TaggedStruct<"SessionNameDefined", {
+    /** Kebab-case slug, e.g., "add-dark-mode-toggle" */
+    name: typeof Schema.String;
+}>;
+type SessionNameDefinedSignal = typeof SessionNameDefinedSignalSchema.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.
  */
@@ -1064,7 +2312,18 @@ declare const SignalSchema: Schema.Union<[Schema.TaggedStruct<"TasksDefined", Re
     summary: typeof Schema.String;
     filesModified: Schema.Array$<typeof Schema.String>;
     filesCreated: Schema.Array$<typeof Schema.String>;
-}>>, Schema.TaggedStruct<"LoopComplete", {}>]>;
+}>>, 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"]>;
+}>, Schema.TaggedStruct<"SessionNameDefined", {
+    /** Kebab-case slug, e.g., "add-dark-mode-toggle" */
+    name: typeof Schema.String;
+}>]>;
 type Signal = typeof SignalSchema.Type;
 /**
  * Decode helpers.
@@ -1122,6 +2381,19 @@ declare const decodeSignal: (u: unknown, overrideOptions?: effect_SchemaAST.Pars
     readonly filesCreated: readonly string[];
 } | {
     readonly _tag: "LoopComplete";
+} | {
+    readonly _tag: "SessionNameDefined";
+    readonly name: string;
+} | {
+    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";
@@ -1176,8 +2448,130 @@ declare const decodeSignalSync: (u: unknown, overrideOptions?: effect_SchemaAST.
     readonly filesCreated: readonly string[];
 } | {
     readonly _tag: "LoopComplete";
+} | {
+    readonly _tag: "SessionNameDefined";
+    readonly name: string;
+} | {
+    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";
 };
 
+/**
+ * Factory functions for creating signals with proper typing.
+ *
+ * These factories provide type-safe signal construction by adding
+ * the _tag field automatically. Returns Effect Either for validation.
+ */
+
+/**
+ * Create a TasksDefined signal.
+ */
+declare function createTasksDefinedSignal(input: {
+    tasks: readonly TaskBasicInfo[];
+}): Either.Either<TasksDefinedSignal, ParseResult.ParseError>;
+/**
+ * Create a PhasesDefinedSignal.
+ */
+declare function createPhasesDefinedSignal(input: {
+    taskId: string;
+    phases: readonly PhaseBasicInfo[];
+}): Either.Either<PhasesDefinedSignal, ParseResult.ParseError>;
+/**
+ * Create a CriteriaDefinedSignal.
+ */
+declare function createCriteriaDefinedSignal(input: {
+    taskId: string;
+    criteria: readonly CriterionBasicInfo[];
+}): Either.Either<CriteriaDefinedSignal, ParseResult.ParseError>;
+/**
+ * Create a PhaseStartedSignal.
+ */
+declare function createPhaseStartedSignal(input: {
+    phaseId: string;
+}): Either.Either<PhaseStartedSignal, ParseResult.ParseError>;
+/**
+ * Create a PhaseCompletedSignal.
+ */
+declare function createPhaseCompletedSignal(input: {
+    phaseId: string;
+}): Either.Either<PhaseCompletedSignal, ParseResult.ParseError>;
+/**
+ * Create a PhaseFailedSignal.
+ */
+declare function createPhaseFailedSignal(input: {
+    phaseId: string;
+    reason: string;
+}): Either.Either<PhaseFailedSignal, ParseResult.ParseError>;
+/**
+ * Create a CriterionPassedSignal.
+ */
+declare function createCriterionPassedSignal(input: {
+    criterionId: string;
+}): Either.Either<CriterionPassedSignal, ParseResult.ParseError>;
+/**
+ * Create a CriterionFailedSignal.
+ */
+declare function createCriterionFailedSignal(input: {
+    criterionId: string;
+    reason: string;
+}): Either.Either<CriterionFailedSignal, ParseResult.ParseError>;
+/**
+ * Create a CheckPassedSignal.
+ */
+declare function createCheckPassedSignal(_input: Record<string, never>): Either.Either<CheckPassedSignal, ParseResult.ParseError>;
+/**
+ * Create a CheckFailedSignal.
+ */
+declare function createCheckFailedSignal(_input: Record<string, never>): Either.Either<CheckFailedSignal, ParseResult.ParseError>;
+/**
+ * Create a ReviewCompleteSignal.
+ */
+declare function createReviewCompleteSignal(input: {
+    changesMade: boolean;
+}): Either.Either<ReviewCompleteSignal, ParseResult.ParseError>;
+/**
+ * Create a TaskCompleteSignal.
+ */
+declare function createTaskCompleteSignal(input: {
+    taskId: string;
+    summary: string;
+    filesModified: readonly string[];
+    filesCreated: readonly string[];
+}): Either.Either<TaskCompleteSignal, ParseResult.ParseError>;
+/**
+ * Create a LoopCompleteSignal.
+ */
+declare function createLoopCompleteSignal(_input: Record<string, never>): Either.Either<LoopCompleteSignal, ParseResult.ParseError>;
+/**
+ * Create a LearningSignal.
+ */
+declare function createLearningSignal(input: {
+    content: string;
+    category?: LearningCategory;
+}): Either.Either<LearningSignal, ParseResult.ParseError>;
+/**
+ * Create a GuardrailSignal.
+ */
+declare function createGuardrailSignal(input: {
+    pattern: string;
+    sign: string;
+    avoidance: string;
+    severity: "warning" | "critical";
+}): Either.Either<GuardrailSignal, ParseResult.ParseError>;
+/**
+ * Create a SessionNameDefinedSignal.
+ */
+declare function createSessionNameDefinedSignal(input: {
+    name: string;
+}): Either.Either<SessionNameDefinedSignal, ParseResult.ParseError>;
+
 /**
  * Status for generated tasks in tasks.md
  */
@@ -1387,6 +2781,16 @@ declare function createHeadlessConsumer(): Consumer;
  */
 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.
  *
@@ -1413,9 +2817,10 @@ interface LLMService {
      * 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) => Stream.Stream<LLMEvent, LLMError>;
+    readonly execute: (prompt: string, options?: LLMExecuteOptions) => Stream.Stream<LLMEvent, LLMError>;
 }
 declare const LLM_base: Context.TagClass<LLM, "@ferix/LLM", LLMService>;
 /**
@@ -1493,23 +2898,365 @@ declare function createMockLLM(config: MockLLMConfig): LLMService;
  * });
  * ```
  */
-declare function layer$2(config: MockLLMConfig): Layer.Layer<LLM>;
+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$2;
+    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
+     * @param baseBranch - Optional base branch for the PR (defaults to repo default)
+     * @returns URL of the created PR
+     */
+    readonly createPR: (sessionId: string, title: string, body: string, baseBranch?: string) => Effect.Effect<PrUrl, GitError>;
+    /**
+     * Get the current branch name of the main repository.
+     *
+     * Used to capture the base branch when starting a session.
+     *
+     * @returns The current branch name
+     */
+    readonly getCurrentBranch: () => Effect.Effect<string, 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;
+    /**
+     * Remove a worktree but keep its branch.
+     *
+     * Removes the worktree directory and cleans up git worktree references,
+     * but preserves the branch for user review and merge.
+     *
+     * @param sessionId - Session ID whose worktree to remove
+     */
+    readonly removeWorktreeKeepBranch: (sessionId: string) => Effect.Effect<void, GitError>;
+    /**
+     * Rename a session's branch to use a descriptive display name.
+     *
+     * This is called after discovery phase when the LLM generates a
+     * task-based name for the session.
+     *
+     * @param sessionId - Session ID whose branch to rename
+     * @param displayName - New display name for the branch (kebab-case)
+     * @returns The new branch name (e.g., "ferix/add-dark-mode")
+     */
+    readonly renameBranch: (sessionId: string, displayName: string) => Effect.Effect<string, GitError>;
+}
+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;
+};
+
+/**
+ * Provider configuration schema with runtime validation.
+ */
+declare const ProviderConfigSchema: Schema.Struct<{
+    /** Provider name */
+    name: Schema.Literal<["claude", "cursor", "opencode"]>;
+    /** CLI command to execute */
+    cliCommand: typeof Schema.String;
+    /** Default arguments for the CLI */
+    args: Schema.Array$<typeof Schema.String>;
+    /** Environment variables to pass */
+    env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+    /** Permission mode for the CLI */
+    permissions: Schema.optional<Schema.Literal<["acceptEdits", "yolo", "prompt"]>>;
+    /** URL for installation instructions */
+    installUrl: typeof Schema.String;
+}>;
+/**
+ * Configuration for a provider.
+ */
+type ProviderConfig = typeof ProviderConfigSchema.Type;
+/**
+ * Provider interface that all LLM implementations must satisfy.
+ *
+ * This interface abstracts the execution of prompts across different
+ * AI CLI tools (Claude, Cursor, etc.).
+ */
+interface Provider {
+    /** Provider name for identification */
+    readonly name: ProviderName;
+    /**
+     * Execute a prompt and return a stream of events.
+     *
+     * @param prompt - The prompt to send to the LLM
+     * @param options - Optional execution options
+     * @returns Stream of LLM events
+     */
+    readonly execute: (prompt: string, options?: LLMExecuteOptions) => Stream.Stream<LLMEvent, LLMError>;
+}
+/**
+ * Default provider configurations.
+ * Validated at module load time using Effect Schema.
+ */
+declare const PROVIDER_CONFIGS: Readonly<Record<ProviderName, ProviderConfig>>;
+
 /**
  * ClaudeCLI namespace containing the Live layer.
  */
 declare const ClaudeCLI: {
-    readonly Live: Layer.Layer<LLM, never, never>;
+    readonly Live: effect_Layer.Layer<LLM, never, never>;
+    readonly Provider: Provider;
 };
 
+/**
+ * CursorCLI namespace containing the Live layer.
+ */
+declare const CursorCLI: {
+    readonly Live: effect_Layer.Layer<LLM, never, never>;
+    readonly Provider: Provider;
+};
+
+/**
+ * Creates a Layer for the specified provider.
+ *
+ * @param name - The provider name
+ * @returns Layer providing the LLM service
+ */
+declare function createProviderLayer(name: ProviderName): Layer.Layer<LLM>;
+
 /**
  * Service interface for plan persistence.
  *
@@ -1600,12 +3347,108 @@ declare const FileSystemPlan: {
  * Effect.runPromise(program.pipe(Effect.provide(testLayer)));
  * ```
  */
-declare function layer$1(): Layer.Layer<PlanStore>;
+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;
 };
 
@@ -1788,9 +3631,9 @@ declare const FerixParser: {
  * Production layer bundle.
  *
  * Uses real implementations:
- * - Claude CLI for LLM
+ * - Claude CLI for LLM (default)
  * - Ferix parser for signals
- * - File system for plan and session storage
+ * - File system for plan, session, progress, guardrails, and git storage
  *
  * @example
  * ```typescript
@@ -1804,14 +3647,34 @@ declare const FerixParser: {
  * );
  * ```
  */
-declare const ProductionLayers: Layer.Layer<LLM | PlanStore | SessionStore | SignalParser, never, never>;
+declare const ProductionLayers: Layer.Layer<Git | GuardrailsStore | LLM | PlanStore | ProgressStore | SessionStore | SignalParser, never, never>;
+/**
+ * Creates production layers with a specific LLM provider.
+ *
+ * @param provider - The provider name to use (defaults to "claude")
+ * @returns A layer bundle with the specified provider
+ *
+ * @example
+ * ```typescript
+ * // Use Cursor instead of Claude
+ * const layers = createProductionLayers("cursor");
+ *
+ * Effect.runPromise(
+ *   program.pipe(
+ *     Stream.runForEach(console.log),
+ *     Effect.provide(layers)
+ *   )
+ * );
+ * ```
+ */
+declare function createProductionLayers(provider?: ProviderName): 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 and session storage
+ * - In-memory plan, session, progress, guardrails, and git storage
  *
  * @example
  * ```typescript
@@ -1827,7 +3690,7 @@ declare const ProductionLayers: Layer.Layer<LLM | PlanStore | SessionStore | Sig
  * expect(result).toContainEqual({ _tag: "LoopCompleted", ... });
  * ```
  */
-declare const TestLayers: Layer.Layer<LLM | PlanStore | SessionStore | SignalParser, never, never>;
+declare const TestLayers: Layer.Layer<Git | GuardrailsStore | LLM | PlanStore | ProgressStore | SessionStore | SignalParser, never, never>;
 /**
  * Creates a test layer bundle with custom mock LLM events.
  *
@@ -1844,12 +3707,13 @@ declare const TestLayers: Layer.Layer<LLM | PlanStore | SessionStore | SignalPar
  * Effect.runPromise(program.pipe(Effect.provide(customTestLayers)));
  * ```
  */
-declare function createTestLayers(events: Parameters<typeof Mock.layer>[0]["events"]): Layer.Layer<LLM | PlanStore | SessionStore | SignalParser, never, never>;
+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;
+type OrchestratorServices = LLM | SignalParser | PlanStore | SessionStore | ProgressStore | GuardrailsStore | Git;
 /**
  * Run the ralph loop.
  *
@@ -2009,4 +3873,4 @@ declare function collectEvents(config: LoopConfig, mockEvents?: readonly LLMEven
  */
 declare function main(config: LoopConfig): Promise<void>;
 
-export { type CheckFailedEvent, CheckFailedEventSchema, type CheckFailedSignal, CheckFailedSignalSchema, type CheckPassedEvent, CheckPassedEventSchema, type CheckPassedSignal, CheckPassedSignalSchema, ClaudeCLI, 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, FileSystemPlan, FileSystemSession, type GeneratedTask, type GeneratedTaskList, GeneratedTaskListSchema, GeneratedTaskSchema, type GeneratedTaskStatus, GeneratedTaskStatusSchema, type IterationCompletedEvent, IterationCompletedEventSchema, type IterationStartedEvent, IterationStartedEventSchema, LLM, LLMError, type LLMEvent, LLMEventSchema, type LLMService, type LLMTextEvent, LLMTextEventSchema, type LLMToolEndEvent, LLMToolEndEventSchema, type LLMToolStartEvent, LLMToolStartEventSchema, type LLMToolUseEvent, LLMToolUseEventSchema, 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, MemoryPlan, 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, ProductionLayers, 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, buildPrompt, collectEvents, createHeadlessConsumer, createTUIConsumer, createTestLayers, decodeLLMEvent, decodeLoopConfig, decodePlan, decodePlanData, decodeSession, decodeSignal, decodeSignalSync, formatTasksMd, main, parseTasksMd, run, runLoop, runTest };
+export { type AnyToolInput, AnyToolInputSchema, type AssistantMessage, AssistantMessageSchema, type BashToolInput, BashToolInputSchema, type BranchPushedEvent, BranchPushedEventSchema, type CheckFailedEvent, CheckFailedEventSchema, type CheckFailedSignal, CheckFailedSignalSchema, type CheckPassedEvent, CheckPassedEventSchema, type CheckPassedSignal, CheckPassedSignalSchema, ClaudeCLI, type ClaudeCliEvent, ClaudeCliEventSchema, type CommitHash, type ConsoleLoggerConfig, ConsoleLoggerConfigSchema, type Consumer, type ConsumerType, ConsumerTypeSchema, type ContentBlock, type ContentBlockDelta, ContentBlockDeltaSchema, ContentBlockSchema, type ContentBlockStart, ContentBlockStartSchema, type ContentBlockStop, ContentBlockStopSchema, 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, CursorCLI, type Delta, DeltaSchema, type DiscoveryCompletedEvent, DiscoveryCompletedEventSchema, type DiscoveryStartedEvent, DiscoveryStartedEventSchema, type DomainEvent, DomainEventSchema, DomainEventUtils, type DoneEvent, DoneEventSchema, type EditToolInput, EditToolInputSchema, 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 GlobToolInput, GlobToolInputSchema, type GrepToolInput, GrepToolInputSchema, type Guardrail, type GuardrailAddedEvent, GuardrailAddedEventSchema, GuardrailSchema, type GuardrailSeverity, GuardrailSeveritySchema, type GuardrailSignal, GuardrailSignalSchema, type GuardrailsFile, GuardrailsFileSchema, GuardrailsStore, GuardrailsStoreError, type GuardrailsStoreService, type InputJsonDelta, InputJsonDeltaSchema, type IterationCompletedEvent, IterationCompletedEventSchema, type IterationStartedEvent, IterationStartedEventSchema, type KnownToolName, 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, MetricsError, Mock, Mock as MockLLM, type OpenCodeCliEvent, OpenCodeCliEventSchema, type OpenCodeCost, OpenCodeCostSchema, type OpenCodeStepFinish, OpenCodeStepFinishSchema, type OpenCodeStepPart, OpenCodeStepPartSchema, type OpenCodeStepStart, OpenCodeStepStartSchema, type OpenCodeTextEvent, OpenCodeTextEventSchema, type OpenCodeTokens, OpenCodeTokensSchema, type OpenCodeToolPart, OpenCodeToolPartSchema, type OpenCodeToolState, OpenCodeToolStateSchema, type OpenCodeToolUseEvent, OpenCodeToolUseEventSchema, OrchestratorError, type OrchestratorServices, type PRCreatedEvent, PRCreatedEventSchema, PROVIDER_CONFIGS, 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 Provider, type ProviderConfig, type ProviderName, ProviderNameSchema, type ReadToolInput, ReadToolInputSchema, RetryExhaustedError, type ReviewCompleteData, ReviewCompleteDataSchema, type ReviewCompleteEvent, ReviewCompleteEventSchema, type ReviewCompleteSignal, ReviewCompleteSignalSchema, type RunOptions, type RunOptionsData, RunOptionsDataSchema, type Session, type SessionNameDefinedSignal, SessionNameDefinedSignalSchema, type SessionNameGeneratedEvent, SessionNameGeneratedEventSchema, SessionSchema, type SessionStatus, SessionStatusSchema, SessionStore, SessionStoreError, type SessionStoreService, type Signal, type SignalAccumulator, SignalParser, type SignalParserService, SignalSchema, type StreamEventEnvelope, StreamEventEnvelopeSchema, 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 TaskToolInput, TaskToolInputSchema, type TasksDefinedData, TasksDefinedDataSchema, type TasksDefinedEvent, TasksDefinedEventSchema, type TasksDefinedSignal, TasksDefinedSignalSchema, TestLayers, type TextContentBlock, TextContentBlockSchema, type TextDelta, TextDeltaSchema, type TextEvent, TextEventSchema, TokenBudgetError, type ToolEndEvent, ToolEndEventSchema, ToolInputSchemaRegistry, type ToolStartEvent, ToolStartEventSchema, type ToolUseContentBlock, ToolUseContentBlockSchema, type ToolUseEvent, ToolUseEventSchema, type ValidatedToolUseEvent, ValidatedToolUseEventSchema, type ViewMode, ViewModeSchema, type WebFetchToolInput, WebFetchToolInputSchema, type WebSearchToolInput, WebSearchToolInputSchema, type WorktreeCreatedEvent, WorktreeCreatedEventSchema, type WorktreeInfo, type WorktreePath, type WorktreeRemovedEvent, WorktreeRemovedEventSchema, type WriteToolInput, WriteToolInputSchema, buildPrompt, collectEvents, createCheckFailedSignal, createCheckPassedSignal, createCriteriaDefinedSignal, createCriterionFailedSignal, createCriterionPassedSignal, createGuardrailSignal, createHeadlessConsumer, createLearningSignal, createLoopCompleteSignal, createPhaseCompletedSignal, createPhaseFailedSignal, createPhaseStartedSignal, createPhasesDefinedSignal, createProductionLayers, createProviderLayer, createReviewCompleteSignal, createSessionNameDefinedSignal, createTUIConsumer, createTaskCompleteSignal, createTasksDefinedSignal, createTestLayers, decodeClaudeCliEvent, decodeClaudeCliEventSync, decodeGuardrail, decodeGuardrailsFile, decodeLLMEvent, decodeLoopConfig, decodeOpenCodeCliEvent, decodeOpenCodeCliEventSync, decodePlan, decodePlanData, decodeProgressEntry, decodeProgressFile, decodeSession, decodeSignal, decodeSignalSync, formatTasksMd, getToolInputSchema, isAssistantMessage, isBashToolInput, isContentBlockDelta, isContentBlockStart, isContentBlockStop, isEditToolInput, isGlobToolInput, isGrepToolInput, isInputJsonDelta, isOpenCodeStepFinish, isOpenCodeStepStart, isOpenCodeTextEvent, isOpenCodeToolUseEvent, isReadToolInput, isStreamEventEnvelope, isTaskToolInput, isTextContentBlock, isTextDelta, isToolUseContentBlock, isWebFetchToolInput, isWebSearchToolInput, isWriteToolInput, main, parseTasksMd, run, runLoop, runTest, validateToolInput, validateToolUseEvent };