ferix-code 0.0.2-beta.0 → 0.0.2-beta.10

package/dist/index.d.ts

@@ -51,6 +51,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,10 +87,22 @@ 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" | "commit" | "push" | "createPR" | "status";
+    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;
 
 declare const PhasePromptOverridesSchema: Schema.Struct<{
     breakdown: Schema.optional<typeof Schema.String>;
@@ -393,6 +429,58 @@ 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;
 /**
  * Union of all domain events.
  */
@@ -550,11 +638,38 @@ 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;
 }>]>;
 /**
  * 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;
 /**
  * Type guard utilities for domain events.
  */
@@ -566,6 +681,73 @@ 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>;
+
 declare const TextEventSchema: Schema.TaggedStruct<"Text", {
     text: typeof Schema.String;
 }>;
@@ -769,18 +951,18 @@ 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 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[];
@@ -795,18 +977,18 @@ 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 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[];
@@ -845,6 +1027,77 @@ declare const RunOptionsDataSchema: Schema.Struct<{
 }>;
 type RunOptionsData = typeof RunOptionsDataSchema.Type;
 
+/**
+ * Action types for progress entries.
+ */
+declare const ProgressActionSchema: Schema.Literal<["started", "completed", "failed", "learning"]>;
+type ProgressAction = typeof ProgressActionSchema.Type;
+/**
+ * A single progress entry for the append-only log.
+ *
+ * Each entry records what happened in an iteration, including:
+ * - Which task was worked on
+ * - What action was taken
+ * - A summary of the work
+ * - Any learnings discovered
+ * - Files that were modified
+ */
+declare const ProgressEntrySchema: Schema.Struct<{
+    iteration: typeof Schema.Number;
+    timestamp: typeof Schema.String;
+    taskId: typeof Schema.String;
+    action: Schema.Literal<["started", "completed", "failed", "learning"]>;
+    summary: typeof Schema.String;
+    learnings: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    filesModified: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>;
+type ProgressEntry = typeof ProgressEntrySchema.Type;
+/**
+ * The complete progress file structure.
+ *
+ * Contains session metadata and an array of progress entries.
+ * This is the structure persisted to `.ferix/plans/:sessionId/progress.md`.
+ */
+declare const ProgressFileSchema: Schema.Struct<{
+    sessionId: typeof Schema.String;
+    createdAt: typeof Schema.String;
+    entries: Schema.Array$<Schema.Struct<{
+        iteration: typeof Schema.Number;
+        timestamp: typeof Schema.String;
+        taskId: typeof Schema.String;
+        action: Schema.Literal<["started", "completed", "failed", "learning"]>;
+        summary: typeof Schema.String;
+        learnings: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        filesModified: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    }>>;
+}>;
+type ProgressFile = typeof ProgressFileSchema.Type;
+/**
+ * Decode helpers.
+ */
+declare const decodeProgressEntry: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
+    readonly iteration: number;
+    readonly taskId: string;
+    readonly summary: string;
+    readonly filesModified?: readonly string[] | undefined;
+    readonly timestamp: string;
+    readonly action: "failed" | "started" | "completed" | "learning";
+    readonly learnings?: readonly string[] | undefined;
+}, effect_ParseResult.ParseError, never>;
+declare const decodeProgressFile: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
+    readonly entries: readonly {
+        readonly iteration: number;
+        readonly taskId: string;
+        readonly summary: string;
+        readonly filesModified?: readonly string[] | undefined;
+        readonly timestamp: string;
+        readonly action: "failed" | "started" | "completed" | "learning";
+        readonly learnings?: readonly string[] | undefined;
+    }[];
+    readonly sessionId: string;
+    readonly createdAt: string;
+}, effect_ParseResult.ParseError, never>;
+
 /**
  * Session status schema.
  */
@@ -860,17 +1113,21 @@ 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>;
 }>;
 type Session = typeof SessionSchema.Type;
 /**
  * Decode helper.
  */
 declare const decodeSession: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
+    readonly status: "failed" | "completed" | "active" | "paused";
     readonly completedTasks: readonly string[];
     readonly id: string;
-    readonly status: "failed" | "active" | "completed" | "paused";
     readonly createdAt: string;
     readonly originalTask: string;
+    readonly worktreePath?: string | undefined;
+    readonly branchName?: string | undefined;
     readonly currentTaskId?: string | undefined;
 }, effect_ParseResult.ParseError, never>;
 
@@ -1024,6 +1281,29 @@ declare const TaskCompleteSignalSchema: Schema.TaggedStruct<"TaskComplete", Read
 type TaskCompleteSignal = typeof TaskCompleteSignalSchema.Type;
 declare const LoopCompleteSignalSchema: Schema.TaggedStruct<"LoopComplete", {}>;
 type LoopCompleteSignal = typeof LoopCompleteSignalSchema.Type;
+/**
+ * Learning category types.
+ */
+declare const LearningCategorySchema: Schema.Literal<["success", "failure", "optimization"]>;
+type LearningCategory = typeof LearningCategorySchema.Type;
+/**
+ * Learning signal - records insights discovered during iteration.
+ */
+declare const LearningSignalSchema: Schema.TaggedStruct<"Learning", {
+    content: typeof Schema.String;
+    category: Schema.optional<Schema.Literal<["success", "failure", "optimization"]>>;
+}>;
+type LearningSignal = typeof LearningSignalSchema.Type;
+/**
+ * Guardrail signal - records failure patterns to avoid.
+ */
+declare const GuardrailSignalSchema: Schema.TaggedStruct<"Guardrail", {
+    pattern: typeof Schema.String;
+    sign: typeof Schema.String;
+    avoidance: typeof Schema.String;
+    severity: Schema.Literal<["warning", "critical"]>;
+}>;
+type GuardrailSignal = typeof GuardrailSignalSchema.Type;
 /**
  * Union of all signals.
  */
@@ -1064,7 +1344,15 @@ 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"]>;
+}>]>;
 type Signal = typeof SignalSchema.Type;
 /**
  * Decode helpers.
@@ -1122,6 +1410,16 @@ declare const decodeSignal: (u: unknown, overrideOptions?: effect_SchemaAST.Pars
     readonly filesCreated: readonly string[];
 } | {
     readonly _tag: "LoopComplete";
+} | {
+    readonly _tag: "Learning";
+    readonly content: string;
+    readonly category?: "success" | "failure" | "optimization" | undefined;
+} | {
+    readonly _tag: "Guardrail";
+    readonly pattern: string;
+    readonly sign: string;
+    readonly avoidance: string;
+    readonly severity: "warning" | "critical";
 }, effect_ParseResult.ParseError, never>;
 declare const decodeSignalSync: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => {
     readonly _tag: "CheckPassed";
@@ -1176,6 +1474,16 @@ declare const decodeSignalSync: (u: unknown, overrideOptions?: effect_SchemaAST.
     readonly filesCreated: readonly string[];
 } | {
     readonly _tag: "LoopComplete";
+} | {
+    readonly _tag: "Learning";
+    readonly content: string;
+    readonly category?: "success" | "failure" | "optimization" | undefined;
+} | {
+    readonly _tag: "Guardrail";
+    readonly pattern: string;
+    readonly sign: string;
+    readonly avoidance: string;
+    readonly severity: "warning" | "critical";
 };
 
 /**
@@ -1387,6 +1695,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 +1731,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,16 +1812,267 @@ 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
+     * @returns URL of the created PR
+     */
+    readonly createPR: (sessionId: string, title: string, body: string) => Effect.Effect<PrUrl, GitError>;
+    /**
+     * Get the branch name for a session.
+     *
+     * @param sessionId - Session ID
+     * @returns Branch name (e.g., "ferix/calm-snails-dream-123")
+     */
+    readonly getBranchName: (sessionId: string) => string;
+}
+declare const Git_base: Context.TagClass<Git, "@ferix/Git", GitService>;
+/**
+ * Effect Tag for the Git service.
+ *
+ * Use this tag to depend on git operations without coupling to a specific implementation.
+ */
+declare class Git extends Git_base {
+}
+
+/**
+ * FileSystemGit namespace containing the Live layer.
+ */
+declare const FileSystemGit: {
+    readonly Live: Layer.Layer<Git, never, never>;
+};
+
+/**
+ * Creates a Layer for an in-memory git service.
+ *
+ * Each call creates a new isolated store.
+ *
+ * @example
+ * ```typescript
+ * const testLayer = MemoryGit.layer();
+ *
+ * const program = Effect.gen(function* () {
+ *   const git = yield* Git;
+ *   const path = yield* git.createWorktree("test-session");
+ *   return path;
+ * });
+ *
+ * Effect.runPromise(program.pipe(Effect.provide(testLayer)));
+ * ```
+ */
+declare function layer$4(): Layer.Layer<Git>;
+/**
+ * MemoryGit namespace containing the Live layer and factory.
+ */
+declare const MemoryGit: {
+    readonly Live: Layer.Layer<Git, never, never>;
+    readonly layer: typeof layer$4;
+};
+
+/**
+ * Service interface for guardrails persistence.
+ *
+ * Guardrails are stored at `.ferix/plans/:sessionId/guardrails.md`.
+ * They represent failure patterns learned from previous iterations
+ * that the LLM should avoid.
+ *
+ * Implementations include:
+ * - FileSystem: Persists to `.ferix/plans/` directory
+ * - Memory: In-memory storage for testing
+ *
+ * @example
+ * ```typescript
+ * const guardrailsStore = yield* GuardrailsStore;
+ *
+ * // Add a guardrail
+ * yield* guardrailsStore.add(sessionId, {
+ *   id: "gr-1",
+ *   createdAt: new Date().toISOString(),
+ *   iteration: 3,
+ *   pattern: "Modifying package.json without running install",
+ *   sign: "Build failures after dependency changes",
+ *   avoidance: "Always run npm install after modifying package.json",
+ *   severity: "critical",
+ * });
+ *
+ * // Load all guardrails
+ * const guardrails = yield* guardrailsStore.load(sessionId);
+ *
+ * // Get active guardrails for prompt
+ * const active = yield* guardrailsStore.getActive(sessionId);
+ * ```
+ */
+interface GuardrailsStoreService {
+    /**
+     * Add a guardrail to the session's collection.
+     *
+     * @param sessionId - Session this guardrail belongs to
+     * @param guardrail - Guardrail to add
+     */
+    readonly add: (sessionId: string, guardrail: Guardrail) => Effect.Effect<void, GuardrailsStoreError>;
+    /**
+     * Load the complete guardrails file for a session.
+     *
+     * @param sessionId - Session to load guardrails for
+     * @returns The guardrails file with all entries
+     */
+    readonly load: (sessionId: string) => Effect.Effect<GuardrailsFile, GuardrailsStoreError>;
+    /**
+     * Get all active guardrails for a session.
+     *
+     * @param sessionId - Session to get guardrails for
+     * @returns Array of active guardrails
+     */
+    readonly getActive: (sessionId: string) => Effect.Effect<readonly Guardrail[], GuardrailsStoreError>;
+}
+declare const GuardrailsStore_base: Context.TagClass<GuardrailsStore, "@ferix/GuardrailsStore", GuardrailsStoreService>;
+/**
+ * Effect Tag for the GuardrailsStore service.
+ *
+ * Use this tag to depend on guardrails storage without coupling to a specific backend.
+ */
+declare class GuardrailsStore extends GuardrailsStore_base {
+}
+
+/**
+ * FileSystemGuardrails namespace containing the Live layer.
+ */
+declare const FileSystemGuardrails: {
+    readonly Live: Layer.Layer<GuardrailsStore, never, never>;
+};
+
+/**
+ * Creates a Layer for an in-memory guardrails store.
+ *
+ * Each call creates a new isolated store.
+ *
+ * @example
+ * ```typescript
+ * const testLayer = MemoryGuardrails.layer();
+ *
+ * const program = Effect.gen(function* () {
+ *   const guardrailsStore = yield* GuardrailsStore;
+ *   yield* guardrailsStore.add(sessionId, guardrail);
+ * });
+ *
+ * Effect.runPromise(program.pipe(Effect.provide(testLayer)));
+ * ```
+ */
+declare function layer$3(): Layer.Layer<GuardrailsStore>;
+/**
+ * MemoryGuardrails namespace containing the Live layer and factory.
+ */
+declare const MemoryGuardrails: {
+    readonly Live: Layer.Layer<GuardrailsStore, never, never>;
+    readonly layer: typeof layer$3;
+};
+
 /**
  * ClaudeCLI namespace containing the Live layer.
  */
@@ -1600,12 +2170,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;
 };
 
@@ -1790,7 +2456,7 @@ declare const FerixParser: {
  * Uses real implementations:
  * - Claude CLI for LLM
  * - 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 +2470,14 @@ 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>;
 /**
  * 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 +2493,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 +2510,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 +2676,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 CheckFailedEvent, CheckFailedEventSchema, type CheckFailedSignal, CheckFailedSignalSchema, type CheckPassedEvent, CheckPassedEventSchema, type CheckPassedSignal, CheckPassedSignalSchema, ClaudeCLI, type CommitHash, type ConsoleLoggerConfig, ConsoleLoggerConfigSchema, type Consumer, type ConsumerType, ConsumerTypeSchema, type CriteriaDefinedData, CriteriaDefinedDataSchema, type CriteriaDefinedEvent, CriteriaDefinedEventSchema, type CriteriaDefinedSignal, CriteriaDefinedSignalSchema, type Criterion, type CriterionBasicInfo, CriterionBasicInfoSchema, type CriterionFailedData, CriterionFailedDataSchema, type CriterionFailedEvent, CriterionFailedEventSchema, type CriterionFailedSignal, CriterionFailedSignalSchema, type CriterionIdData, CriterionIdDataSchema, type CriterionPassedEvent, CriterionPassedEventSchema, type CriterionPassedSignal, CriterionPassedSignalSchema, CriterionSchema, type CriterionStatus, CriterionStatusSchema, type DiscoveryCompletedEvent, DiscoveryCompletedEventSchema, type DiscoveryStartedEvent, DiscoveryStartedEventSchema, type DomainEvent, DomainEventSchema, DomainEventUtils, type DoneEvent, DoneEventSchema, type ExecutionMode, ExecutionModeSchema, type FerixError, FerixParser, type FileLoggerConfig, FileLoggerConfigSchema, FileSystemGit, FileSystemGuardrails, FileSystemPlan, FileSystemProgress, FileSystemSession, type GeneratedTask, type GeneratedTaskList, GeneratedTaskListSchema, GeneratedTaskSchema, type GeneratedTaskStatus, GeneratedTaskStatusSchema, Git, GitError, type GitService, type Guardrail, type GuardrailAddedEvent, GuardrailAddedEventSchema, GuardrailSchema, type GuardrailSeverity, GuardrailSeveritySchema, type GuardrailSignal, GuardrailSignalSchema, type GuardrailsFile, GuardrailsFileSchema, GuardrailsStore, GuardrailsStoreError, type GuardrailsStoreService, type IterationCompletedEvent, IterationCompletedEventSchema, type IterationStartedEvent, IterationStartedEventSchema, LLM, LLMError, type LLMEvent, LLMEventSchema, type LLMExecuteOptions, type LLMService, type LLMTextEvent, LLMTextEventSchema, type LLMToolEndEvent, LLMToolEndEventSchema, type LLMToolStartEvent, LLMToolStartEventSchema, type LLMToolUseEvent, LLMToolUseEventSchema, type LearningCategory, LearningCategorySchema, type LearningRecordedEvent, LearningRecordedEventSchema, type LearningSignal, LearningSignalSchema, type LogEntry, LogEntrySchema, type LogLevel, LogLevelSchema, type LoopCompleteSignal, LoopCompleteSignalSchema, type LoopCompletedEvent, LoopCompletedEventSchema, type LoopConfig, LoopConfigSchema, type LoopError, LoopErrorSchema, type LoopFailedEvent, LoopFailedEventSchema, type LoopStartedEvent, LoopStartedEventSchema, type LoopStatus, LoopStatusSchema, type LoopSummary, LoopSummarySchema, MemoryGit, MemoryGuardrails, MemoryPlan, MemoryProgress, MemorySession, Mock, Mock as MockLLM, OrchestratorError, type OrchestratorServices, ParseError, type Phase, type PhaseBasicInfo, PhaseBasicInfoSchema, type PhaseCompletedEvent, PhaseCompletedEventSchema, type PhaseCompletedSignal, PhaseCompletedSignalSchema, type PhaseFailedData, PhaseFailedDataSchema, type PhaseFailedEvent, PhaseFailedEventSchema, type PhaseFailedSignal, PhaseFailedSignalSchema, type PhaseIdData, PhaseIdDataSchema, type PhasePromptOverrides, PhasePromptOverridesSchema, PhaseSchema, type PhaseStartedEvent, PhaseStartedEventSchema, type PhaseStartedSignal, PhaseStartedSignalSchema, type PhaseStatus, PhaseStatusSchema, type PhasesDefinedData, PhasesDefinedDataSchema, type PhasesDefinedEvent, PhasesDefinedEventSchema, type PhasesDefinedSignal, PhasesDefinedSignalSchema, type Plan, type PlanCreatedEvent, PlanCreatedEventSchema, type PlanData, PlanDataSchema, PlanId, PlanSchema, PlanStore, PlanStoreError, type PlanStoreService, type PlanUpdateFailedEvent, PlanUpdateFailedEventSchema, type PlanUpdatedEvent, PlanUpdatedEventSchema, type PrUrl, ProductionLayers, type ProgressAction, ProgressActionSchema, type ProgressEntry, ProgressEntrySchema, type ProgressFile, ProgressFileSchema, ProgressStore, ProgressStoreError, type ProgressStoreService, type ProgressUpdatedEvent, ProgressUpdatedEventSchema, type PromptConfig, PromptConfigSchema, type ReviewCompleteData, ReviewCompleteDataSchema, type ReviewCompleteEvent, ReviewCompleteEventSchema, type ReviewCompleteSignal, ReviewCompleteSignalSchema, type RunOptions, type RunOptionsData, RunOptionsDataSchema, type Session, SessionSchema, type SessionStatus, SessionStatusSchema, SessionStore, SessionStoreError, type SessionStoreService, type Signal, type SignalAccumulator, SignalParser, type SignalParserService, SignalSchema, type TUICriterion, TUICriterionSchema, type TUICriterionStatus, TUICriterionStatusSchema, type TUIPhase, TUIPhaseSchema, type TUIPhaseStatus, TUIPhaseStatusSchema, type TUIState, TUIStateSchema, type TUITask, TUITaskSchema, type TUITaskStatus, TUITaskStatusSchema, type Task, type TaskBasicInfo, TaskBasicInfoSchema, type TaskCompleteData, TaskCompleteDataSchema, type TaskCompleteSignal, type TaskCompleteSignalData, TaskCompleteSignalDataSchema, TaskCompleteSignalSchema, type TaskCompletedEvent, TaskCompletedEventSchema, TaskSchema, type TaskStatus, TaskStatusSchema, type TasksDefinedData, TasksDefinedDataSchema, type TasksDefinedEvent, TasksDefinedEventSchema, type TasksDefinedSignal, TasksDefinedSignalSchema, TestLayers, type TextEvent, TextEventSchema, type ToolEndEvent, ToolEndEventSchema, type ToolStartEvent, ToolStartEventSchema, type ToolUseEvent, ToolUseEventSchema, type ViewMode, ViewModeSchema, type WorktreeCreatedEvent, WorktreeCreatedEventSchema, type WorktreeInfo, type WorktreePath, type WorktreeRemovedEvent, WorktreeRemovedEventSchema, buildPrompt, collectEvents, createHeadlessConsumer, createTUIConsumer, createTestLayers, decodeGuardrail, decodeGuardrailsFile, decodeLLMEvent, decodeLoopConfig, decodePlan, decodePlanData, decodeProgressEntry, decodeProgressFile, decodeSession, decodeSignal, decodeSignalSync, formatTasksMd, main, parseTasksMd, run, runLoop, runTest };