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

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>;
@@ -66,7 +90,7 @@ declare class OrchestratorError extends OrchestratorError_base<{
 /**
  * Union of all possible errors in the system.
  */
-type FerixError = LLMError | ParseError | PlanStoreError | SessionStoreError | OrchestratorError;
+type FerixError = LLMError | ParseError | PlanStoreError | SessionStoreError | ProgressStoreError | GuardrailsStoreError | OrchestratorError;
 
 declare const PhasePromptOverridesSchema: Schema.Struct<{
     breakdown: Schema.optional<typeof Schema.String>;
@@ -393,6 +417,40 @@ 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;
 /**
  * Union of all domain events.
  */
@@ -550,11 +608,30 @@ 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;
 }>]>;
 /**
  * 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;
 /**
  * Type guard utilities for domain events.
  */
@@ -566,6 +643,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;
 }>;
@@ -845,6 +989,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.
  */
@@ -868,7 +1083,7 @@ type Session = typeof SessionSchema.Type;
 declare const decodeSession: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
     readonly completedTasks: readonly string[];
     readonly id: string;
-    readonly status: "failed" | "active" | "completed" | "paused";
+    readonly status: "failed" | "completed" | "active" | "paused";
     readonly createdAt: string;
     readonly originalTask: string;
     readonly currentTaskId?: string | undefined;
@@ -1024,6 +1239,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 +1302,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 +1368,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 +1432,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";
 };
 
 /**
@@ -1493,16 +1759,114 @@ declare function createMockLLM(config: MockLLMConfig): LLMService;
  * });
  * ```
  */
-declare function layer$2(config: MockLLMConfig): Layer.Layer<LLM>;
+declare function layer$4(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$4;
     readonly createMockLLM: typeof createMockLLM;
 };
 
+/**
+ * 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 +1964,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 +2250,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, and guardrails storage
  *
  * @example
  * ```typescript
@@ -1804,14 +2264,14 @@ declare const FerixParser: {
  * );
  * ```
  */
-declare const ProductionLayers: Layer.Layer<LLM | PlanStore | SessionStore | SignalParser, never, never>;
+declare const ProductionLayers: Layer.Layer<LLM | SignalParser | PlanStore | SessionStore | ProgressStore | GuardrailsStore, 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, and guardrails storage
  *
  * @example
  * ```typescript
@@ -1827,7 +2287,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<LLM | SignalParser | PlanStore | SessionStore | ProgressStore | GuardrailsStore, never, never>;
 /**
  * Creates a test layer bundle with custom mock LLM events.
  *
@@ -1844,12 +2304,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<LLM | SignalParser | PlanStore | SessionStore | ProgressStore | GuardrailsStore, never, never>;
 
 /**
  * Required services for the orchestrator.
+ * Now includes ProgressStore and GuardrailsStore for RALPH pattern support.
  */
-type OrchestratorServices = LLM | SignalParser | PlanStore | SessionStore;
+type OrchestratorServices = LLM | SignalParser | PlanStore | SessionStore | ProgressStore | GuardrailsStore;
 /**
  * Run the ralph loop.
  *
@@ -2009,4 +2470,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 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, FileSystemGuardrails, FileSystemPlan, FileSystemProgress, FileSystemSession, type GeneratedTask, type GeneratedTaskList, GeneratedTaskListSchema, GeneratedTaskSchema, type GeneratedTaskStatus, GeneratedTaskStatusSchema, 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 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, 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, 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, buildPrompt, collectEvents, createHeadlessConsumer, createTUIConsumer, createTestLayers, decodeGuardrail, decodeGuardrailsFile, decodeLLMEvent, decodeLoopConfig, decodePlan, decodePlanData, decodeProgressEntry, decodeProgressFile, decodeSession, decodeSignal, decodeSignalSync, formatTasksMd, main, parseTasksMd, run, runLoop, runTest };