ferix-code 0.0.2-beta.13 → 0.0.2-beta.15

package/dist/index.js

@@ -71,7 +71,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "ferix-code",
-  version: "0.0.2-beta.13",
+  version: "0.0.2-beta.15",
   description: "Composable RALPH loops for AI coding agents - v2 with Effect",
   type: "module",
   bin: {
@@ -118,7 +118,7 @@ var package_default = {
 
 // src/program.ts
 init_esm_shims();
-import { Effect as Effect25, Stream as Stream11 } from "effect";
+import { Effect as Effect24, Stream as Stream10 } from "effect";
 
 // src/consumers/index.ts
 init_esm_shims();
@@ -2376,7 +2376,7 @@ ${errorText}
 
 // src/layers/index.ts
 init_esm_shims();
-import { Layer as Layer15 } from "effect";
+import { Layer as Layer14 } from "effect";
 
 // src/layers/git/file-system.ts
 init_esm_shims();
@@ -2770,7 +2770,7 @@ init_esm_shims();
 // src/domain/schemas/config.ts
 init_esm_shims();
 import { Schema as S } from "effect";
-var ProviderNameSchema = S.Literal("claude", "cursor");
+var ProviderNameSchema = S.Literal("claude", "cursor", "opencode");
 var PhasePromptOverridesSchema = S.Struct({
   breakdown: S.optional(S.String),
   planning: S.optional(S.String),
@@ -3718,20 +3718,84 @@ var Mock = {
 
 // src/layers/llm/providers/index.ts
 init_esm_shims();
-import { Effect as Effect12 } from "effect";
+import { Effect as Effect11 } from "effect";
+
+// src/layers/llm/types.ts
+init_esm_shims();
+var PROVIDER_CONFIGS = {
+  claude: {
+    name: "claude",
+    cliCommand: "claude",
+    args: [
+      "--permission-mode",
+      "acceptEdits",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--include-partial-messages"
+    ],
+    permissions: "acceptEdits",
+    installUrl: "https://docs.anthropic.com/claude-code"
+  },
+  cursor: {
+    name: "cursor",
+    cliCommand: "cursor-agent",
+    args: ["--print", "--force", "--output-format", "stream-json"],
+    permissions: "acceptEdits",
+    installUrl: "https://cursor.sh/agent"
+  },
+  opencode: {
+    name: "opencode",
+    cliCommand: "opencode",
+    args: ["run", "--format", "json"],
+    installUrl: "https://opencode.ai/docs/"
+  }
+};
 
 // src/layers/llm/providers/claude.ts
 init_esm_shims();
+
+// src/layers/llm/provider-factory.ts
+init_esm_shims();
 import { spawn } from "child_process";
-import { Effect as Effect10, Layer as Layer6, Stream as Stream6 } from "effect";
+import { Effect as Effect9, Layer as Layer6, Stream as Stream5 } from "effect";
+function createProvider(name, createStream, checkAvailable) {
+  const config = PROVIDER_CONFIGS[name];
+  return {
+    name,
+    execute: (prompt, options) => {
+      return Stream5.unwrap(
+        checkAvailable(name).pipe(
+          Effect9.map(() => {
+            const args = name === "opencode" ? [...config.args, prompt] : [...config.args, "-p", prompt];
+            const child = spawn(config.cliCommand, args, {
+              stdio: ["inherit", "pipe", "pipe"],
+              cwd: options?.cwd,
+              env: {
+                ...process.env,
+                FORCE_COLOR: "1",
+                ...config.env
+              }
+            });
+            return createStream(child);
+          })
+        )
+      );
+    }
+  };
+}
+function createProviderLayer(provider) {
+  return Layer6.succeed(LLM, provider);
+}
 
 // src/layers/llm/stream.ts
 init_esm_shims();
-import { createInterface } from "readline";
-import { Effect as Effect9, Stream as Stream5 } from "effect";
 
 // src/layers/llm/providers/parsers/claude.ts
 init_esm_shims();
+
+// src/layers/llm/providers/parsers/stream-json.ts
+init_esm_shims();
 function parseJsonLine(line) {
   if (!line.startsWith("{")) {
     return null;
@@ -3809,7 +3873,10 @@ function unwrapStreamEvent(json) {
   return json;
 }
 
-// src/layers/llm/stream.ts
+// src/layers/llm/stream-factory.ts
+init_esm_shims();
+import { createInterface } from "readline";
+import { Effect as Effect10, Stream as Stream6 } from "effect";
 function handleToolEvent(toolInfo, toolState, emit) {
   if (toolInfo.type === "start") {
     toolState.currentTool = toolInfo.name;
@@ -3832,21 +3899,8 @@ function handleToolEvent(toolInfo, toolState, emit) {
     toolState.inputChunks.length = 0;
   }
 }
-function processJsonLine(json, outputChunks, toolState, emit) {
-  const event = unwrapStreamEvent(json);
-  const text = extractText(event);
-  if (text) {
-    outputChunks.push(text);
-    emit.single({ _tag: "Text", text });
-    return;
-  }
-  const toolInfo = extractToolInfo(event);
-  if (toolInfo) {
-    handleToolEvent(toolInfo, toolState, emit);
-  }
-}
-function createEventStream(child) {
-  return Stream5.async((emit) => {
+function createLLMEventStream(child, parser, providerName) {
+  return Stream6.async((emit) => {
     const outputChunks = [];
     const toolState = { currentTool: "", inputChunks: [] };
     const stdout = child.stdout;
@@ -3854,16 +3908,16 @@ function createEventStream(child) {
       emit.fail(
         new LLMError({ message: "Failed to get stdout from child process" })
       );
-      return Effect9.void;
+      return Effect10.void;
     }
     const rl = createInterface({
       input: stdout,
       crlfDelay: Number.POSITIVE_INFINITY
     });
     rl.on("line", (line) => {
-      const json = parseJsonLine(line);
+      const json = parser.parseJsonLine(line);
       if (json) {
-        processJsonLine(json, outputChunks, toolState, emit);
+        parser.processEvent(json, outputChunks, toolState, emit);
       }
     });
     child.stderr?.on("data", (data) => {
@@ -3876,7 +3930,7 @@ function createEventStream(child) {
       if (exitCode !== 0) {
         emit.fail(
           new LLMError({
-            message: `Claude CLI exited with code ${exitCode}`
+            message: `${providerName} CLI exited with code ${exitCode}`
           })
         );
       } else {
@@ -3893,46 +3947,41 @@ function createEventStream(child) {
         })
       );
     });
-    return Effect9.sync(() => {
+    return Effect10.sync(() => {
       child.kill("SIGTERM");
     });
   });
 }
 
-// src/layers/llm/providers/claude.ts
-var ClaudeProvider = {
-  name: "claude",
-  execute: (prompt, options) => {
-    return Stream6.unwrap(
-      Effect10.sync(() => {
-        const child = spawn(
-          "claude",
-          [
-            "--permission-mode",
-            "acceptEdits",
-            "--output-format",
-            "stream-json",
-            "--verbose",
-            "--include-partial-messages",
-            "-p",
-            prompt
-          ],
-          {
-            stdio: ["inherit", "pipe", "pipe"],
-            cwd: options?.cwd,
-            env: {
-              ...process.env,
-              FORCE_COLOR: "1"
-            }
-          }
-        );
-        return createEventStream(child);
-      })
-    );
+// src/layers/llm/stream.ts
+function processJsonLine(json, outputChunks, toolState, emit) {
+  const event = unwrapStreamEvent(json);
+  const text = extractText(event);
+  if (text) {
+    outputChunks.push(text);
+    emit.single({ _tag: "Text", text });
+    return;
   }
+  const toolInfo = extractToolInfo(event);
+  if (toolInfo) {
+    handleToolEvent(toolInfo, toolState, emit);
+  }
+}
+var streamJsonParser = {
+  parseJsonLine,
+  processEvent: processJsonLine
 };
-var make3 = ClaudeProvider;
-var Live6 = Layer6.succeed(LLM, make3);
+function createEventStream(child, providerName = "LLM") {
+  return createLLMEventStream(child, streamJsonParser, providerName);
+}
+
+// src/layers/llm/providers/claude.ts
+var ClaudeProvider = createProvider(
+  "claude",
+  (child) => createEventStream(child, "Claude"),
+  checkProviderAvailable
+);
+var Live6 = createProviderLayer(ClaudeProvider);
 var ClaudeCLI = {
   Live: Live6,
   Provider: ClaudeProvider
@@ -3940,51 +3989,161 @@ var ClaudeCLI = {
 
 // src/layers/llm/providers/cursor.ts
 init_esm_shims();
-import { spawn as spawn2 } from "child_process";
-import { Effect as Effect11, Layer as Layer7, Stream as Stream7 } from "effect";
-var CursorProvider = {
-  name: "cursor",
-  execute: (prompt, options) => {
-    return Stream7.unwrap(
-      Effect11.sync(() => {
-        const child = spawn2(
-          "cursor-agent",
-          [
-            "--print",
-            "--force",
-            "--output-format",
-            "stream-json",
-            "-p",
-            prompt
-          ],
-          {
-            stdio: ["inherit", "pipe", "pipe"],
-            cwd: options?.cwd,
-            env: {
-              ...process.env,
-              FORCE_COLOR: "1"
-            }
-          }
-        );
-        return createEventStream(child);
-      })
-    );
-  }
-};
-var make4 = CursorProvider;
-var Live7 = Layer7.succeed(LLM, make4);
+var CursorProvider = createProvider(
+  "cursor",
+  (child) => createEventStream(child, "Cursor"),
+  checkProviderAvailable
+);
+var Live7 = createProviderLayer(CursorProvider);
 var CursorCLI = {
   Live: Live7,
   Provider: CursorProvider
 };
 
+// src/layers/llm/providers/opencode.ts
+init_esm_shims();
+
+// src/layers/llm/stream-opencode.ts
+init_esm_shims();
+
+// src/layers/llm/providers/parsers/opencode.ts
+init_esm_shims();
+function parseJsonLine2(line) {
+  if (!line.startsWith("{")) {
+    return null;
+  }
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function isTextContent2(json) {
+  return typeof json === "object" && json !== null && "type" in json && json.type === "text" && "text" in json && typeof json.text === "string";
+}
+function isStepFinish(json) {
+  return typeof json === "object" && json !== null && "type" in json && json.type === "step_finish";
+}
+function isToolUse2(json) {
+  if (typeof json !== "object" || json === null) {
+    return false;
+  }
+  const obj = json;
+  if (obj.type !== "tool_use") {
+    return false;
+  }
+  if (typeof obj.part !== "object" || obj.part === null) {
+    return false;
+  }
+  const part = obj.part;
+  if (typeof part.tool !== "string") {
+    return false;
+  }
+  if (typeof part.state !== "object" || part.state === null) {
+    return false;
+  }
+  return true;
+}
+function extractText2(json) {
+  if (isTextContent2(json)) {
+    return json.text;
+  }
+  return null;
+}
+function extractToolInfo2(json) {
+  if (isToolUse2(json)) {
+    return {
+      type: "complete",
+      name: json.part.tool,
+      partialJson: JSON.stringify(json.part.state.input)
+    };
+  }
+  return null;
+}
+
+// src/layers/llm/stream-opencode.ts
+function processOpenCodeEvent(json, outputChunks, _toolState, emit) {
+  const text = extractText2(json);
+  if (text) {
+    outputChunks.push(text);
+    emit.single({ _tag: "Text", text });
+    return;
+  }
+  const toolInfo = extractToolInfo2(json);
+  if (toolInfo && toolInfo.type === "complete") {
+    emit.single({ _tag: "ToolStart", tool: toolInfo.name });
+    if (toolInfo.partialJson) {
+      const input = safeParseJson(toolInfo.partialJson);
+      if (input !== null) {
+        emit.single({ _tag: "ToolUse", tool: toolInfo.name, input });
+      }
+    }
+    emit.single({ _tag: "ToolEnd", tool: toolInfo.name });
+    return;
+  }
+  if (isStepFinish(json)) {
+    return;
+  }
+}
+var openCodeParser = {
+  parseJsonLine: parseJsonLine2,
+  processEvent: processOpenCodeEvent
+};
+function createOpenCodeEventStream(child, providerName = "OpenCode") {
+  return createLLMEventStream(child, openCodeParser, providerName);
+}
+
+// src/layers/llm/providers/opencode.ts
+var OpenCodeProvider = createProvider(
+  "opencode",
+  (child) => createOpenCodeEventStream(child, "OpenCode"),
+  checkProviderAvailable
+);
+var Live8 = createProviderLayer(OpenCodeProvider);
+var OpenCodeCLI = {
+  Live: Live8,
+  Provider: OpenCodeProvider
+};
+
 // src/layers/llm/providers/index.ts
-function createProviderLayer(name) {
+var OpenCodeCLI2 = OpenCodeCLI;
+function isCommandAvailable(command) {
+  return Effect11.tryPromise({
+    try: async () => {
+      const { execSync } = await import("child_process");
+      try {
+        execSync(`which ${command}`, { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    catch: () => false
+  }).pipe(Effect11.orElseSucceed(() => false));
+}
+function checkProviderAvailable(name) {
+  const config = PROVIDER_CONFIGS[name];
+  return isCommandAvailable(config.cliCommand).pipe(
+    Effect11.flatMap(
+      (available) => available ? Effect11.void : Effect11.fail(
+        new LLMError({
+          message: `Provider "${name}" is not available. The CLI command "${config.cliCommand}" was not found.
+
+To use this provider, install it first:
+  ${config.installUrl}`
+        })
+      )
+    )
+  );
+}
+function createProviderLayer2(name) {
   switch (name) {
     case "claude":
       return ClaudeCLI.Live;
     case "cursor":
       return CursorCLI.Live;
+    case "opencode":
+      return OpenCodeCLI2.Live;
     default: {
       const _exhaustive = name;
       return _exhaustive;
@@ -3996,7 +4155,7 @@ function createProviderLayer(name) {
 init_esm_shims();
 import { access as access2, mkdir as mkdir3, readdir, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { join as join3 } from "path";
-import { Effect as Effect13, Layer as Layer8 } from "effect";
+import { Effect as Effect12, Layer as Layer7 } from "effect";
 
 // src/services/plan-store.ts
 init_esm_shims();
@@ -4007,14 +4166,14 @@ var PlanStore = class extends Context4.Tag("@ferix/PlanStore")() {
 // src/layers/plan/file-system.ts
 var PLANS_DIR2 = ".ferix/plans";
 function ensureDir2(dirPath) {
-  return Effect13.tryPromise({
+  return Effect12.tryPromise({
     try: () => mkdir3(dirPath, { recursive: true }),
     catch: (error) => new PlanStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "create",
       cause: error
     })
-  }).pipe(Effect13.asVoid);
+  }).pipe(Effect12.asVoid);
 }
 function getSessionDir2(sessionId) {
   return join3(process.cwd(), PLANS_DIR2, sessionId);
@@ -4029,8 +4188,8 @@ function serializePlan(plan) {
   return JSON.stringify(plan, null, 2);
 }
 function deserializePlan(json, planId) {
-  return Effect13.gen(function* () {
-    const parsed = yield* Effect13.try({
+  return Effect12.gen(function* () {
+    const parsed = yield* Effect12.try({
       try: () => JSON.parse(json),
       catch: (error) => new PlanStoreError({
         message: `Invalid JSON in plan file: ${String(error)}`,
@@ -4039,7 +4198,7 @@ function deserializePlan(json, planId) {
       })
     });
     const validated = yield* decodePlanData(parsed).pipe(
-      Effect13.mapError(
+      Effect12.mapError(
         (error) => new PlanStoreError({
           message: `Plan validation failed: ${String(error)}`,
           operation: "load",
@@ -4053,11 +4212,11 @@ function deserializePlan(json, planId) {
     };
   });
 }
-var make5 = {
-  create: (sessionId, plan) => Effect13.gen(function* () {
+var make3 = {
+  create: (sessionId, plan) => Effect12.gen(function* () {
     const sessionDir = getSessionDir2(sessionId);
     yield* ensureDir2(sessionDir);
-    const existingPlans = yield* Effect13.tryPromise({
+    const existingPlans = yield* Effect12.tryPromise({
       try: async () => {
         try {
           const files = await readdir(sessionDir);
@@ -4074,7 +4233,7 @@ var make5 = {
     const planId = generatePlanId(existingPlans + 1);
     const planPath = getPlanPath(sessionId, planId);
     const fullPlan = { ...plan, id: planId };
-    yield* Effect13.tryPromise({
+    yield* Effect12.tryPromise({
       try: () => writeFile2(planPath, serializePlan(fullPlan), "utf-8"),
       catch: (error) => new PlanStoreError({
         message: `Failed to write plan file: ${planPath}`,
@@ -4084,10 +4243,10 @@ var make5 = {
     });
     return planId;
   }),
-  load: (planId, sessionId) => Effect13.gen(function* () {
+  load: (planId, sessionId) => Effect12.gen(function* () {
     if (sessionId) {
       const planPath = getPlanPath(sessionId, planId);
-      const content = yield* Effect13.tryPromise({
+      const content = yield* Effect12.tryPromise({
         try: () => readFile2(planPath, "utf-8"),
         catch: (error) => new PlanStoreError({
           message: `Failed to read plan file: ${planPath}`,
@@ -4097,7 +4256,7 @@ var make5 = {
       });
       return yield* deserializePlan(content, planId);
     }
-    const sessionDirs = yield* Effect13.tryPromise({
+    const sessionDirs = yield* Effect12.tryPromise({
       try: async () => {
         const plansDir = join3(process.cwd(), PLANS_DIR2);
         const dirs = await readdir(plansDir);
@@ -4111,7 +4270,7 @@ var make5 = {
     });
     for (const sid of sessionDirs) {
       const planPath = getPlanPath(sid, planId);
-      const exists = yield* Effect13.tryPromise({
+      const exists = yield* Effect12.tryPromise({
         try: async () => {
           await access2(planPath);
           return true;
@@ -4120,9 +4279,9 @@ var make5 = {
           message: "File not found",
           operation: "load"
         })
-      }).pipe(Effect13.orElseSucceed(() => false));
+      }).pipe(Effect12.orElseSucceed(() => false));
       if (exists) {
-        const content = yield* Effect13.tryPromise({
+        const content = yield* Effect12.tryPromise({
           try: () => readFile2(planPath, "utf-8"),
           catch: (error) => new PlanStoreError({
             message: `Failed to read plan file: ${planPath}`,
@@ -4133,16 +4292,16 @@ var make5 = {
         return yield* deserializePlan(content, planId);
       }
     }
-    return yield* Effect13.fail(
+    return yield* Effect12.fail(
       new PlanStoreError({
         message: `Plan not found: ${planId}`,
         operation: "load"
       })
     );
   }),
-  update: (planId, plan) => Effect13.gen(function* () {
+  update: (planId, plan) => Effect12.gen(function* () {
     const planPath = getPlanPath(plan.sessionId, planId);
-    yield* Effect13.tryPromise({
+    yield* Effect12.tryPromise({
       try: () => writeFile2(planPath, serializePlan(plan), "utf-8"),
       catch: (error) => new PlanStoreError({
         message: `Failed to update plan file: ${planPath}`,
@@ -4151,9 +4310,9 @@ var make5 = {
       })
     });
   }),
-  list: (sessionId) => Effect13.gen(function* () {
+  list: (sessionId) => Effect12.gen(function* () {
     const sessionDir = getSessionDir2(sessionId);
-    const files = yield* Effect13.tryPromise({
+    const files = yield* Effect12.tryPromise({
       try: async () => {
         try {
           return await readdir(sessionDir);
@@ -4170,17 +4329,17 @@ var make5 = {
     return files.filter((f) => f.endsWith(".json")).map((f) => PlanId(f.replace(".json", "")));
   })
 };
-var Live8 = Layer8.succeed(PlanStore, make5);
+var Live9 = Layer7.succeed(PlanStore, make3);
 var FileSystemPlan = {
-  Live: Live8
+  Live: Live9
 };
 
 // src/layers/plan/memory.ts
 init_esm_shims();
-import { Effect as Effect14, Layer as Layer9, Ref as Ref5 } from "effect";
+import { Effect as Effect13, Layer as Layer8, Ref as Ref5 } from "effect";
 function createMemoryPlanStore(stateRef) {
   return {
-    create: (sessionId, plan) => Effect14.gen(function* () {
+    create: (sessionId, plan) => Effect13.gen(function* () {
       const state = yield* Ref5.get(stateRef);
       if (!state.has(sessionId)) {
         state.set(sessionId, /* @__PURE__ */ new Map());
@@ -4195,7 +4354,7 @@ function createMemoryPlanStore(stateRef) {
       yield* Ref5.set(stateRef, state);
       return planId;
     }),
-    load: (planId, sessionId) => Effect14.gen(function* () {
+    load: (planId, sessionId) => Effect13.gen(function* () {
       const state = yield* Ref5.get(stateRef);
       if (sessionId) {
         const sessionPlans = state.get(sessionId);
@@ -4203,7 +4362,7 @@ function createMemoryPlanStore(stateRef) {
         if (plan) {
           return plan;
         }
-        return yield* Effect14.fail(
+        return yield* Effect13.fail(
           new PlanStoreError({
             message: `Plan not found: ${planId}`,
             operation: "load"
@@ -4216,18 +4375,18 @@ function createMemoryPlanStore(stateRef) {
           return plan;
         }
       }
-      return yield* Effect14.fail(
+      return yield* Effect13.fail(
         new PlanStoreError({
           message: `Plan not found: ${planId}`,
           operation: "load"
         })
       );
     }),
-    update: (planId, plan) => Effect14.gen(function* () {
+    update: (planId, plan) => Effect13.gen(function* () {
       const state = yield* Ref5.get(stateRef);
       const sessionPlans = state.get(plan.sessionId);
       if (!sessionPlans) {
-        return yield* Effect14.fail(
+        return yield* Effect13.fail(
           new PlanStoreError({
             message: `Session not found: ${plan.sessionId}`,
             operation: "update"
@@ -4237,7 +4396,7 @@ function createMemoryPlanStore(stateRef) {
       sessionPlans.set(planId, plan);
       yield* Ref5.set(stateRef, state);
     }),
-    list: (sessionId) => Effect14.gen(function* () {
+    list: (sessionId) => Effect13.gen(function* () {
       const state = yield* Ref5.get(stateRef);
       const sessionPlans = state.get(sessionId);
       if (!sessionPlans) {
@@ -4248,17 +4407,17 @@ function createMemoryPlanStore(stateRef) {
   };
 }
 function layer4() {
-  return Layer9.effect(
+  return Layer8.effect(
     PlanStore,
-    Effect14.gen(function* () {
+    Effect13.gen(function* () {
       const stateRef = yield* Ref5.make(/* @__PURE__ */ new Map());
       return createMemoryPlanStore(stateRef);
     })
   );
 }
-var Live9 = layer4();
+var Live10 = layer4();
 var MemoryPlan = {
-  Live: Live9,
+  Live: Live10,
   layer: layer4
 };
 
@@ -4266,7 +4425,7 @@ var MemoryPlan = {
 init_esm_shims();
 import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { join as join4 } from "path";
-import { DateTime as DateTime3, Effect as Effect15, Layer as Layer10 } from "effect";
+import { DateTime as DateTime3, Effect as Effect14, Layer as Layer9 } from "effect";
 
 // src/services/progress-store.ts
 init_esm_shims();
@@ -4277,14 +4436,14 @@ var ProgressStore = class extends Context5.Tag("@ferix/ProgressStore")() {
 // src/layers/progress/file-system.ts
 var PLANS_DIR3 = ".ferix/plans";
 function ensureDir3(dirPath) {
-  return Effect15.tryPromise({
+  return Effect14.tryPromise({
     try: () => mkdir4(dirPath, { recursive: true }),
     catch: (error) => new ProgressStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "append",
       cause: error
     })
-  }).pipe(Effect15.asVoid);
+  }).pipe(Effect14.asVoid);
 }
 function getSessionDir3(sessionId) {
   return join4(process.cwd(), PLANS_DIR3, sessionId);
@@ -4296,8 +4455,8 @@ function serializeProgress(progress) {
   return JSON.stringify(progress, null, 2);
 }
 function deserializeProgress(json) {
-  return Effect15.gen(function* () {
-    const parsed = yield* Effect15.try({
+  return Effect14.gen(function* () {
+    const parsed = yield* Effect14.try({
       try: () => JSON.parse(json),
       catch: (error) => new ProgressStoreError({
         message: `Invalid JSON in progress file: ${String(error)}`,
@@ -4306,7 +4465,7 @@ function deserializeProgress(json) {
       })
     });
     const validated = yield* decodeProgressFile(parsed).pipe(
-      Effect15.mapError(
+      Effect14.mapError(
         (error) => new ProgressStoreError({
           message: `Progress validation failed: ${String(error)}`,
           operation: "load",
@@ -4324,12 +4483,12 @@ function createEmptyProgress(sessionId, createdAt) {
     entries: []
   };
 }
-var make6 = {
-  append: (sessionId, entry) => Effect15.gen(function* () {
+var make4 = {
+  append: (sessionId, entry) => Effect14.gen(function* () {
     const sessionDir = getSessionDir3(sessionId);
     yield* ensureDir3(sessionDir);
     const progressPath = getProgressPath(sessionId);
-    const existing = yield* Effect15.tryPromise({
+    const existing = yield* Effect14.tryPromise({
       try: async () => {
         try {
           const content = await readFile3(progressPath, "utf-8");
@@ -4347,7 +4506,7 @@ var make6 = {
     let progress;
     if (existing) {
       progress = yield* deserializeProgress(existing).pipe(
-        Effect15.mapError(
+        Effect14.mapError(
           (err) => new ProgressStoreError({
             message: err.message,
             operation: "append",
@@ -4363,7 +4522,7 @@ var make6 = {
       ...progress,
       entries: [...progress.entries, entry]
     };
-    yield* Effect15.tryPromise({
+    yield* Effect14.tryPromise({
       try: () => writeFile3(progressPath, serializeProgress(updatedProgress), "utf-8"),
       catch: (error) => new ProgressStoreError({
         message: `Failed to write progress file: ${progressPath}`,
@@ -4372,9 +4531,9 @@ var make6 = {
       })
     });
   }),
-  load: (sessionId) => Effect15.gen(function* () {
+  load: (sessionId) => Effect14.gen(function* () {
     const progressPath = getProgressPath(sessionId);
-    const content = yield* Effect15.tryPromise({
+    const content = yield* Effect14.tryPromise({
       try: async () => {
         try {
           return await readFile3(progressPath, "utf-8");
@@ -4394,23 +4553,23 @@ var make6 = {
     }
     return yield* deserializeProgress(content);
   }),
-  getRecent: (sessionId, count) => Effect15.gen(function* () {
-    const progress = yield* make6.load(sessionId);
+  getRecent: (sessionId, count) => Effect14.gen(function* () {
+    const progress = yield* make4.load(sessionId);
     const entries = progress.entries;
     return entries.slice(-count);
   })
 };
-var Live10 = Layer10.succeed(ProgressStore, make6);
+var Live11 = Layer9.succeed(ProgressStore, make4);
 var FileSystemProgress = {
-  Live: Live10
+  Live: Live11
 };
 
 // src/layers/progress/memory.ts
 init_esm_shims();
-import { DateTime as DateTime4, Effect as Effect16, Layer as Layer11, Ref as Ref6 } from "effect";
+import { DateTime as DateTime4, Effect as Effect15, Layer as Layer10, Ref as Ref6 } from "effect";
 function createMemoryProgressStore(stateRef) {
   return {
-    append: (sessionId, entry) => Effect16.gen(function* () {
+    append: (sessionId, entry) => Effect15.gen(function* () {
       const state = yield* Ref6.get(stateRef);
       let progress = state.get(sessionId);
       if (!progress) {
@@ -4428,7 +4587,7 @@ function createMemoryProgressStore(stateRef) {
       state.set(sessionId, updatedProgress);
       yield* Ref6.set(stateRef, state);
     }),
-    load: (sessionId) => Effect16.gen(function* () {
+    load: (sessionId) => Effect15.gen(function* () {
       const state = yield* Ref6.get(stateRef);
       const progress = state.get(sessionId);
       if (!progress) {
@@ -4441,7 +4600,7 @@ function createMemoryProgressStore(stateRef) {
       }
       return progress;
     }),
-    getRecent: (sessionId, count) => Effect16.gen(function* () {
+    getRecent: (sessionId, count) => Effect15.gen(function* () {
       const state = yield* Ref6.get(stateRef);
       const progress = state.get(sessionId);
       if (!progress) {
@@ -4452,17 +4611,17 @@ function createMemoryProgressStore(stateRef) {
   };
 }
 function layer5() {
-  return Layer11.effect(
+  return Layer10.effect(
     ProgressStore,
-    Effect16.gen(function* () {
+    Effect15.gen(function* () {
       const stateRef = yield* Ref6.make(/* @__PURE__ */ new Map());
       return createMemoryProgressStore(stateRef);
     })
   );
 }
-var Live11 = layer5();
+var Live12 = layer5();
 var MemoryProgress = {
-  Live: Live11,
+  Live: Live12,
   layer: layer5
 };
 
@@ -4470,7 +4629,7 @@ var MemoryProgress = {
 init_esm_shims();
 import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 import { join as join5 } from "path";
-import { DateTime as DateTime5, Effect as Effect17, Layer as Layer12 } from "effect";
+import { DateTime as DateTime5, Effect as Effect16, Layer as Layer11 } from "effect";
 import { humanId } from "human-id";
 
 // src/services/session-store.ts
@@ -4486,14 +4645,14 @@ function generateSessionId(timestampMs) {
   return `${id}-${timestampMs}`;
 }
 function ensureDir4(dirPath) {
-  return Effect17.tryPromise({
+  return Effect16.tryPromise({
     try: () => mkdir5(dirPath, { recursive: true }),
     catch: (error) => new SessionStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "create",
       cause: error
     })
-  }).pipe(Effect17.asVoid);
+  }).pipe(Effect16.asVoid);
 }
 function getSessionPath(sessionId) {
   return join5(process.cwd(), SESSIONS_DIR, `${sessionId}.json`);
@@ -4502,8 +4661,8 @@ function serializeSession(session) {
   return JSON.stringify(session, null, 2);
 }
 function deserializeSession(json) {
-  return Effect17.gen(function* () {
-    const parsed = yield* Effect17.try({
+  return Effect16.gen(function* () {
+    const parsed = yield* Effect16.try({
       try: () => JSON.parse(json),
       catch: (error) => new SessionStoreError({
         message: `Invalid JSON in session file: ${String(error)}`,
@@ -4512,7 +4671,7 @@ function deserializeSession(json) {
       })
     });
     const validated = yield* decodeSession(parsed).pipe(
-      Effect17.mapError(
+      Effect16.mapError(
         (error) => new SessionStoreError({
           message: `Session validation failed: ${String(error)}`,
           operation: "get",
@@ -4523,8 +4682,8 @@ function deserializeSession(json) {
     return validated;
   });
 }
-var make7 = {
-  create: (originalTask) => Effect17.gen(function* () {
+var make5 = {
+  create: (originalTask) => Effect16.gen(function* () {
     const sessionsDir = join5(process.cwd(), SESSIONS_DIR);
     yield* ensureDir4(sessionsDir);
     const now = yield* DateTime5.now;
@@ -4538,7 +4697,7 @@ var make7 = {
       completedTasks: []
     };
     const sessionPath = getSessionPath(sessionId);
-    yield* Effect17.tryPromise({
+    yield* Effect16.tryPromise({
       try: () => writeFile4(sessionPath, serializeSession(session), "utf-8"),
       catch: (error) => new SessionStoreError({
         message: `Failed to write session file: ${sessionPath}`,
@@ -4548,9 +4707,9 @@ var make7 = {
     });
     return session;
   }),
-  get: (sessionId) => Effect17.gen(function* () {
+  get: (sessionId) => Effect16.gen(function* () {
     const sessionPath = getSessionPath(sessionId);
-    const content = yield* Effect17.tryPromise({
+    const content = yield* Effect16.tryPromise({
       try: () => readFile4(sessionPath, "utf-8"),
       catch: (error) => new SessionStoreError({
         message: `Failed to read session file: ${sessionPath}`,
@@ -4560,9 +4719,9 @@ var make7 = {
     });
     return yield* deserializeSession(content);
   }),
-  update: (sessionId, session) => Effect17.gen(function* () {
+  update: (sessionId, session) => Effect16.gen(function* () {
     const sessionPath = getSessionPath(sessionId);
-    yield* Effect17.tryPromise({
+    yield* Effect16.tryPromise({
       try: () => writeFile4(sessionPath, serializeSession(session), "utf-8"),
       catch: (error) => new SessionStoreError({
         message: `Failed to update session file: ${sessionPath}`,
@@ -4572,17 +4731,17 @@ var make7 = {
     });
   })
 };
-var Live12 = Layer12.succeed(SessionStore, make7);
+var Live13 = Layer11.succeed(SessionStore, make5);
 var FileSystemSession = {
-  Live: Live12
+  Live: Live13
 };
 
 // src/layers/session/memory.ts
 init_esm_shims();
-import { DateTime as DateTime6, Effect as Effect18, Layer as Layer13, Ref as Ref7 } from "effect";
+import { DateTime as DateTime6, Effect as Effect17, Layer as Layer12, Ref as Ref7 } from "effect";
 function createMemorySessionStore(stateRef, counterRef) {
   return {
-    create: (originalTask) => Effect18.gen(function* () {
+    create: (originalTask) => Effect17.gen(function* () {
       const state = yield* Ref7.get(stateRef);
       const counter = yield* Ref7.updateAndGet(counterRef, (n) => n + 1);
       const sessionId = `test-session-${counter}`;
@@ -4598,11 +4757,11 @@ function createMemorySessionStore(stateRef, counterRef) {
       yield* Ref7.set(stateRef, state);
       return session;
     }),
-    get: (sessionId) => Effect18.gen(function* () {
+    get: (sessionId) => Effect17.gen(function* () {
       const state = yield* Ref7.get(stateRef);
       const session = state.get(sessionId);
       if (!session) {
-        return yield* Effect18.fail(
+        return yield* Effect17.fail(
           new SessionStoreError({
             message: `Session not found: ${sessionId}`,
             operation: "get"
@@ -4611,10 +4770,10 @@ function createMemorySessionStore(stateRef, counterRef) {
       }
       return session;
     }),
-    update: (sessionId, session) => Effect18.gen(function* () {
+    update: (sessionId, session) => Effect17.gen(function* () {
       const state = yield* Ref7.get(stateRef);
       if (!state.has(sessionId)) {
-        return yield* Effect18.fail(
+        return yield* Effect17.fail(
           new SessionStoreError({
             message: `Session not found: ${sessionId}`,
             operation: "update"
@@ -4627,24 +4786,24 @@ function createMemorySessionStore(stateRef, counterRef) {
   };
 }
 function layer6() {
-  return Layer13.effect(
+  return Layer12.effect(
     SessionStore,
-    Effect18.gen(function* () {
+    Effect17.gen(function* () {
       const stateRef = yield* Ref7.make(/* @__PURE__ */ new Map());
       const counterRef = yield* Ref7.make(0);
       return createMemorySessionStore(stateRef, counterRef);
     })
   );
 }
-var Live13 = layer6();
+var Live14 = layer6();
 var MemorySession = {
-  Live: Live13,
+  Live: Live14,
   layer: layer6
 };
 
 // src/layers/signal/ferix-parser.ts
 init_esm_shims();
-import { Effect as Effect19, Layer as Layer14, Ref as Ref8 } from "effect";
+import { Effect as Effect18, Layer as Layer13, Ref as Ref8 } from "effect";
 
 // src/services/signal-parser.ts
 init_esm_shims();
@@ -5154,10 +5313,10 @@ signalSpecRegistry.register(tasksDefinedSpec);
 // src/layers/signal/ferix-parser.ts
 var MAX_BUFFER_SIZE = 1024 * 1024;
 function createAccumulatorImpl() {
-  return Effect19.gen(function* () {
+  return Effect18.gen(function* () {
     const chunksRef = yield* Ref8.make([]);
     const emittedRef = yield* Ref8.make(/* @__PURE__ */ new Set());
-    const feed = (text) => Effect19.gen(function* () {
+    const feed = (text) => Effect18.gen(function* () {
       const chunks = yield* Ref8.get(chunksRef);
       chunks.push(text);
       const buffer = chunks.join("");
@@ -5185,7 +5344,7 @@ function createAccumulatorImpl() {
       yield* Ref8.set(emittedRef, emitted);
       return newSignals;
     });
-    const flush = () => Effect19.gen(function* () {
+    const flush = () => Effect18.gen(function* () {
       const chunks = yield* Ref8.get(chunksRef);
       const buffer = chunks.join("");
       yield* Ref8.set(chunksRef, []);
@@ -5200,41 +5359,17 @@ function createAccumulatorImpl() {
     return { feed, flush };
   });
 }
-var make8 = {
-  parse: (text) => Effect19.succeed(signalSpecRegistry.parseAll(text)),
+var make6 = {
+  parse: (text) => Effect18.succeed(signalSpecRegistry.parseAll(text)),
   createAccumulator: createAccumulatorImpl
 };
-var Live14 = Layer14.succeed(SignalParser, make8);
+var Live15 = Layer13.succeed(SignalParser, make6);
 var FerixParser = {
-  Live: Live14
-};
-
-// src/layers/llm/types.ts
-init_esm_shims();
-var PROVIDER_CONFIGS = {
-  claude: {
-    name: "claude",
-    cliCommand: "claude",
-    args: [
-      "--permission-mode",
-      "acceptEdits",
-      "--output-format",
-      "stream-json",
-      "--verbose",
-      "--include-partial-messages"
-    ],
-    permissions: "acceptEdits"
-  },
-  cursor: {
-    name: "cursor",
-    cliCommand: "cursor-agent",
-    args: ["--print", "--force", "--output-format", "stream-json"],
-    permissions: "acceptEdits"
-  }
+  Live: Live15
 };
 
 // src/layers/index.ts
-var ProductionLayers = Layer15.mergeAll(
+var ProductionLayers = Layer14.mergeAll(
   ClaudeCLI.Live,
   FerixParser.Live,
   FileSystemPlan.Live,
@@ -5244,8 +5379,8 @@ var ProductionLayers = Layer15.mergeAll(
   FileSystemGit.Live
 );
 function createProductionLayers(provider = "claude") {
-  const llmLayer = createProviderLayer(provider);
-  return Layer15.mergeAll(
+  const llmLayer = createProviderLayer2(provider);
+  return Layer14.mergeAll(
     llmLayer,
     FerixParser.Live,
     FileSystemPlan.Live,
@@ -5255,7 +5390,7 @@ function createProductionLayers(provider = "claude") {
     FileSystemGit.Live
   );
 }
-var TestLayers = Layer15.mergeAll(
+var TestLayers = Layer14.mergeAll(
   Mock.Live,
   FerixParser.Live,
   MemoryPlan.Live,
@@ -5265,7 +5400,7 @@ var TestLayers = Layer15.mergeAll(
   MemoryGit.Live
 );
 function createTestLayers(events) {
-  return Layer15.mergeAll(
+  return Layer14.mergeAll(
     Mock.layer({ events }),
     FerixParser.Live,
     MemoryPlan.layer(),
@@ -5281,27 +5416,27 @@ init_esm_shims();
 
 // src/orchestrator/loop.ts
 init_esm_shims();
-import { DateTime as DateTime10, Effect as Effect24, Option, pipe as pipe3, Ref as Ref12, Stream as Stream10 } from "effect";
+import { DateTime as DateTime10, Effect as Effect23, Option, pipe as pipe3, Ref as Ref12, Stream as Stream9 } from "effect";
 
 // src/orchestrator/discovery.ts
 init_esm_shims();
-import { DateTime as DateTime8, Effect as Effect22, pipe, Ref as Ref10, Stream as Stream8 } from "effect";
+import { DateTime as DateTime8, Effect as Effect21, pipe, Ref as Ref10, Stream as Stream7 } from "effect";
 
 // src/layers/plan/task-generation.ts
 init_esm_shims();
 import { mkdir as mkdir6, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
 import { join as join6 } from "path";
-import { Effect as Effect20 } from "effect";
+import { Effect as Effect19 } from "effect";
 var PLANS_DIR4 = ".ferix/plans";
 function ensureDir5(dirPath) {
-  return Effect20.tryPromise({
+  return Effect19.tryPromise({
     try: () => mkdir6(dirPath, { recursive: true }),
     catch: (error) => new PlanStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "create",
       cause: error
     })
-  }).pipe(Effect20.asVoid);
+  }).pipe(Effect19.asVoid);
 }
 function getSessionDir4(sessionId) {
   return join6(process.cwd(), PLANS_DIR4, sessionId);
@@ -5310,12 +5445,12 @@ function getTasksMdPath(sessionId) {
   return join6(getSessionDir4(sessionId), "tasks.md");
 }
 function writeTasksMd(sessionId, tasks) {
-  return Effect20.gen(function* () {
+  return Effect19.gen(function* () {
     const sessionDir = getSessionDir4(sessionId);
     yield* ensureDir5(sessionDir);
     const tasksMdPath = getTasksMdPath(sessionId);
     const content = formatTasksMd(tasks);
-    yield* Effect20.tryPromise({
+    yield* Effect19.tryPromise({
       try: () => writeFile5(tasksMdPath, content, "utf-8"),
       catch: (error) => new PlanStoreError({
         message: `Failed to write tasks.md: ${tasksMdPath}`,
@@ -5497,7 +5632,7 @@ function mapSignalToDomain(signal, context) {
 
 // src/orchestrator/plan-updates.ts
 init_esm_shims();
-import { DateTime as DateTime7, Effect as Effect21, Ref as Ref9 } from "effect";
+import { DateTime as DateTime7, Effect as Effect20, Ref as Ref9 } from "effect";
 
 // src/orchestrator/plan-updates/index.ts
 init_esm_shims();
@@ -5802,9 +5937,9 @@ function persistPlanUpdate(planStore, plan, operation) {
     tasks: plan.tasks
   }) : planStore.update(plan.id, plan);
   return storeOp.pipe(
-    Effect21.map(() => null),
-    Effect21.catchAll(
-      (error) => Effect21.succeed({
+    Effect20.map(() => null),
+    Effect20.catchAll(
+      (error) => Effect20.succeed({
         _tag: "PlanUpdateFailed",
         operation,
         error: error.message,
@@ -5814,7 +5949,7 @@ function persistPlanUpdate(planStore, plan, operation) {
   );
 }
 function updatePlanFromSignal(currentPlanRef, persistenceStateRef, signal, sessionId, originalTask) {
-  return Effect21.gen(function* () {
+  return Effect20.gen(function* () {
     const currentPlan = yield* Ref9.get(currentPlanRef);
     const now = yield* DateTime7.now;
     const timestamp = DateTime7.formatIso(now);
@@ -5836,7 +5971,7 @@ function updatePlanFromSignal(currentPlanRef, persistenceStateRef, signal, sessi
   });
 }
 function flushPlanPersistence(planStore, currentPlanRef, persistenceStateRef) {
-  return Effect21.gen(function* () {
+  return Effect20.gen(function* () {
     const state = yield* Ref9.get(persistenceStateRef);
     if (!(state.dirty && state.pendingOperation)) {
       return [];
@@ -6110,12 +6245,12 @@ Begin.`);
 
 // src/orchestrator/discovery.ts
 function processTextSignals(signalParser, text, context) {
-  return Effect22.gen(function* () {
+  return Effect21.gen(function* () {
     const events = [];
     const parsedSignals = [];
     const signals = yield* signalParser.parse(text).pipe(
-      Effect22.tapError(
-        (error) => Effect22.logDebug(
+      Effect21.tapError(
+        (error) => Effect21.logDebug(
           "Signal parsing failed, continuing with empty signals",
           {
             error: String(error),
@@ -6123,7 +6258,7 @@ function processTextSignals(signalParser, text, context) {
           }
         )
       ),
-      Effect22.orElseSucceed(() => [])
+      Effect21.orElseSucceed(() => [])
     );
     for (const signal of signals) {
       events.push(mapSignalToDomain(signal, context));
@@ -6133,7 +6268,7 @@ function processTextSignals(signalParser, text, context) {
   });
 }
 function processLLMEvent(signalParser, llmEvent, context) {
-  return Effect22.gen(function* () {
+  return Effect21.gen(function* () {
     const domainEvent = mapLLMEventToDomain(llmEvent, context);
     const events = [domainEvent];
     const allSignals = [];
@@ -6177,8 +6312,8 @@ function planTasksToGeneratedTasks(plan) {
   }));
 }
 function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, config, sessionId, worktreePath) {
-  return Stream8.unwrap(
-    Effect22.gen(function* () {
+  return Stream7.unwrap(
+    Effect21.gen(function* () {
       const startTimeUtc = yield* DateTime8.now;
       const startTime = DateTime8.toEpochMillis(startTimeUtc);
       const persistenceStateRef = yield* Ref10.make({
@@ -6196,16 +6331,16 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
       };
       const prompt = buildDiscoveryPrompt(config);
       const llmStream = llm.execute(prompt, worktreePath ? { cwd: worktreePath } : void 0).pipe(
-        Stream8.mapError(
+        Stream7.mapError(
           (e) => new OrchestratorError({
             message: `LLM execution failed during discovery: ${String(e)}`,
             phase: "discovery",
             cause: e
           })
         ),
-        Stream8.flatMap(
-          (llmEvent) => Stream8.unwrap(
-            Effect22.gen(function* () {
+        Stream7.flatMap(
+          (llmEvent) => Stream7.unwrap(
+            Effect21.gen(function* () {
               const now = yield* DateTime8.now;
               const context = {
                 timestamp: DateTime8.toEpochMillis(now)
@@ -6226,13 +6361,13 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
                 );
                 events.push(...planEvents);
               }
-              return Stream8.fromIterable(events);
+              return Stream7.fromIterable(events);
             })
           )
         ),
         // Convert LLM errors to LoopFailed events
-        Stream8.catchAll(
-          (error) => Stream8.succeed({
+        Stream7.catchAll(
+          (error) => Stream7.succeed({
             _tag: "LoopFailed",
             error: {
               message: error.message,
@@ -6241,8 +6376,8 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
           })
         )
       );
-      const completionStream = Stream8.fromEffect(
-        Effect22.gen(function* () {
+      const completionStream = Stream7.fromEffect(
+        Effect21.gen(function* () {
           const persistEvents = yield* flushPlanPersistence(
             planStore,
             currentPlanRef,
@@ -6253,12 +6388,12 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
           if (plan && plan.tasks.length > 0) {
             const generatedTasks = planTasksToGeneratedTasks(plan);
             yield* writeTasksMd(sessionId, generatedTasks).pipe(
-              Effect22.tapError(
-                (error) => Effect22.logDebug("Failed to write tasks.md, continuing", {
+              Effect21.tapError(
+                (error) => Effect21.logDebug("Failed to write tasks.md, continuing", {
                   error: String(error)
                 })
               ),
-              Effect22.orElseSucceed(() => void 0)
+              Effect21.orElseSucceed(() => void 0)
             );
           }
           const endTimeUtc = yield* DateTime8.now;
@@ -6270,12 +6405,12 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
           };
           return [...persistEvents, discoveryCompleted];
         })
-      ).pipe(Stream8.flatMap((events) => Stream8.fromIterable(events)));
+      ).pipe(Stream7.flatMap((events) => Stream7.fromIterable(events)));
       return pipe(
-        Stream8.succeed(discoveryStarted),
-        Stream8.concat(Stream8.succeed(analysingToolUse)),
-        Stream8.concat(llmStream),
-        Stream8.concat(completionStream)
+        Stream7.succeed(discoveryStarted),
+        Stream7.concat(Stream7.succeed(analysingToolUse)),
+        Stream7.concat(llmStream),
+        Stream7.concat(completionStream)
       );
     })
   );
@@ -6283,15 +6418,15 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
 
 // src/orchestrator/iteration.ts
 init_esm_shims();
-import { DateTime as DateTime9, Effect as Effect23, pipe as pipe2, Ref as Ref11, Stream as Stream9 } from "effect";
+import { DateTime as DateTime9, Effect as Effect22, pipe as pipe2, Ref as Ref11, Stream as Stream8 } from "effect";
 function processTextSignals2(signalParser, text, context) {
-  return Effect23.gen(function* () {
+  return Effect22.gen(function* () {
     const events = [];
     let completed = false;
     const parsedSignals = [];
     const signals = yield* signalParser.parse(text).pipe(
-      Effect23.tapError(
-        (error) => Effect23.logDebug(
+      Effect22.tapError(
+        (error) => Effect22.logDebug(
           "Signal parsing failed, continuing with empty signals",
           {
             error: String(error),
@@ -6299,7 +6434,7 @@ function processTextSignals2(signalParser, text, context) {
           }
         )
       ),
-      Effect23.orElseSucceed(() => [])
+      Effect22.orElseSucceed(() => [])
     );
     for (const signal of signals) {
       events.push(mapSignalToDomain(signal, context));
@@ -6312,7 +6447,7 @@ function processTextSignals2(signalParser, text, context) {
   });
 }
 function processLLMEvent2(signalParser, llmEvent, context) {
-  return Effect23.gen(function* () {
+  return Effect22.gen(function* () {
     const domainEvent = mapLLMEventToDomain(llmEvent, context);
     const events = [domainEvent];
     let completed = false;
@@ -6344,8 +6479,8 @@ function processLLMEvent2(signalParser, llmEvent, context) {
   });
 }
 function createIterationStream(llm, signalParser, planStore, currentPlanRef, loopCompletedRef, config, iteration, sessionId, worktreePath) {
-  return Stream9.unwrap(
-    Effect23.gen(function* () {
+  return Stream8.unwrap(
+    Effect22.gen(function* () {
       const currentPlan = yield* Ref11.get(currentPlanRef);
       const persistenceStateRef = yield* Ref11.make({
         dirty: false,
@@ -6359,16 +6494,16 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
         buildPrompt(config, iteration, currentPlan),
         worktreePath ? { cwd: worktreePath } : void 0
       ).pipe(
-        Stream9.mapError(
+        Stream8.mapError(
           (e) => new OrchestratorError({
             message: `LLM execution failed: ${String(e)}`,
             phase: "iteration",
             cause: e
           })
         ),
-        Stream9.flatMap(
-          (llmEvent) => Stream9.unwrap(
-            Effect23.gen(function* () {
+        Stream8.flatMap(
+          (llmEvent) => Stream8.unwrap(
+            Effect22.gen(function* () {
               const now = yield* DateTime9.now;
               const context = {
                 timestamp: DateTime9.toEpochMillis(now)
@@ -6392,13 +6527,13 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
               if (result.completed) {
                 yield* Ref11.set(loopCompletedRef, true);
               }
-              return Stream9.fromIterable(events);
+              return Stream8.fromIterable(events);
             })
           )
         ),
         // Convert LLM errors to LoopFailed events with iteration context
-        Stream9.catchAll(
-          (error) => Stream9.succeed({
+        Stream8.catchAll(
+          (error) => Stream8.succeed({
             _tag: "LoopFailed",
             error: {
               message: error.message,
@@ -6408,8 +6543,8 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
           })
         )
       );
-      const completionStream = Stream9.fromEffect(
-        Effect23.gen(function* () {
+      const completionStream = Stream8.fromEffect(
+        Effect22.gen(function* () {
           const persistEvents = yield* flushPlanPersistence(
             planStore,
             currentPlanRef,
@@ -6421,11 +6556,11 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
           };
           return [...persistEvents, iterCompleted];
         })
-      ).pipe(Stream9.flatMap((events) => Stream9.fromIterable(events)));
+      ).pipe(Stream8.flatMap((events) => Stream8.fromIterable(events)));
       return pipe2(
-        Stream9.succeed(iterStarted),
-        Stream9.concat(llmStream),
-        Stream9.concat(completionStream)
+        Stream8.succeed(iterStarted),
+        Stream8.concat(llmStream),
+        Stream8.concat(completionStream)
       );
     })
   );
@@ -6433,15 +6568,15 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
 
 // src/orchestrator/loop.ts
 function runLoop(config) {
-  return Stream10.unwrap(
-    Effect24.gen(function* () {
+  return Stream9.unwrap(
+    Effect23.gen(function* () {
       const llm = yield* LLM;
       const signalParser = yield* SignalParser;
       const sessionStore = yield* SessionStore;
       const planStore = yield* PlanStore;
       const git = yield* Git;
       const session = yield* sessionStore.create(config.task).pipe(
-        Effect24.mapError(
+        Effect23.mapError(
           (e) => new OrchestratorError({
             message: `Failed to create session: ${e.message}`,
             phase: "setup",
@@ -6450,7 +6585,7 @@ function runLoop(config) {
         )
       );
       const worktreePath = yield* git.createWorktree(session.id).pipe(
-        Effect24.mapError(
+        Effect23.mapError(
           (e) => new OrchestratorError({
             message: `Failed to create worktree: ${e.message}`,
             phase: "setup",
@@ -6464,12 +6599,12 @@ function runLoop(config) {
         worktreePath,
         branchName
       }).pipe(
-        Effect24.tapError(
-          (error) => Effect24.logDebug("Failed to update session with worktree info", {
+        Effect23.tapError(
+          (error) => Effect23.logDebug("Failed to update session with worktree info", {
             error: String(error)
           })
         ),
-        Effect24.orElseSucceed(() => void 0)
+        Effect23.orElseSucceed(() => void 0)
       );
       const startTimeUtc = yield* DateTime10.now;
       const startTime = DateTime10.toEpochMillis(startTimeUtc);
@@ -6497,9 +6632,9 @@ function runLoop(config) {
         session.id,
         worktreePath
       );
-      const iterationsStream = Stream10.unfoldEffect(
+      const iterationsStream = Stream9.unfoldEffect(
         1,
-        (iteration) => Effect24.gen(function* () {
+        (iteration) => Effect23.gen(function* () {
           const completed = yield* Ref12.get(loopCompletedRef);
           if (completed || iteration > maxIterations) {
             return Option.none();
@@ -6507,7 +6642,7 @@ function runLoop(config) {
           return Option.some([iteration, iteration + 1]);
         })
       ).pipe(
-        Stream10.flatMap(
+        Stream9.flatMap(
           (iteration) => createIterationStream(
             llm,
             signalParser,
@@ -6531,17 +6666,17 @@ function runLoop(config) {
         worktreePath
       );
       return pipe3(
-        Stream10.succeed(loopStarted),
-        Stream10.concat(Stream10.succeed(worktreeCreated)),
-        Stream10.concat(discoveryStream),
-        Stream10.concat(iterationsStream),
-        Stream10.concat(completionStream)
+        Stream9.succeed(loopStarted),
+        Stream9.concat(Stream9.succeed(worktreeCreated)),
+        Stream9.concat(discoveryStream),
+        Stream9.concat(iterationsStream),
+        Stream9.concat(completionStream)
       );
     }).pipe(
       // Also catch setup errors (e.g., session creation failure)
-      Effect24.catchAll(
-        (error) => Effect24.succeed(
-          Stream10.succeed({
+      Effect23.catchAll(
+        (error) => Effect23.succeed(
+          Stream9.succeed({
             _tag: "LoopFailed",
             error: {
               message: error.message,
@@ -6554,19 +6689,19 @@ function runLoop(config) {
   );
 }
 function createCompletionStream(sessionStore, git, session, config, startTime, loopCompletedRef, _worktreePath) {
-  return Stream10.unwrap(
-    Effect24.gen(function* () {
+  return Stream9.unwrap(
+    Effect23.gen(function* () {
       const endTimeUtc = yield* DateTime10.now;
       const durationMs = DateTime10.toEpochMillis(endTimeUtc) - startTime;
       const completed = yield* Ref12.get(loopCompletedRef);
       yield* git.commitChanges(session.id, `feat: complete session ${session.id}`).pipe(
-        Effect24.tapError(
-          (error) => Effect24.logDebug("Final commit failed, continuing", {
+        Effect23.tapError(
+          (error) => Effect23.logDebug("Final commit failed, continuing", {
             sessionId: session.id,
             error: String(error)
           })
         ),
-        Effect24.orElseSucceed(() => void 0)
+        Effect23.orElseSucceed(() => void 0)
       );
       const summary = {
         iterations: config.maxIterations,
@@ -6579,16 +6714,16 @@ function createCompletionStream(sessionStore, git, session, config, startTime, l
         ...session,
         status: completed ? "completed" : "paused"
       }).pipe(
-        Effect24.tapError(
-          (error) => Effect24.logDebug("Session update failed, continuing", {
+        Effect23.tapError(
+          (error) => Effect23.logDebug("Session update failed, continuing", {
             sessionId: session.id,
             error: String(error)
           })
         ),
-        Effect24.orElseSucceed(() => void 0)
+        Effect23.orElseSucceed(() => void 0)
       );
       const loopCompleted = { _tag: "LoopCompleted", summary };
-      return Stream10.succeed(loopCompleted);
+      return Stream9.succeed(loopCompleted);
     })
   );
 }
@@ -6597,11 +6732,11 @@ function createCompletionStream(sessionStore, git, session, config, startTime, l
 function run(options) {
   const { config, consumer: consumerType = "headless", onEvent } = options;
   const events = runLoop(config);
-  const eventsWithCallback = onEvent ? events.pipe(Stream11.tap((event) => Effect25.sync(() => onEvent(event)))) : events;
+  const eventsWithCallback = onEvent ? events.pipe(Stream10.tap((event) => Effect24.sync(() => onEvent(event)))) : events;
   const layers = config.provider ? createProductionLayers(config.provider) : ProductionLayers;
-  const eventsWithLayers = eventsWithCallback.pipe(Stream11.provideLayer(layers));
+  const eventsWithLayers = eventsWithCallback.pipe(Stream10.provideLayer(layers));
   if (consumerType === "none") {
-    return eventsWithLayers.pipe(Stream11.runDrain);
+    return eventsWithLayers.pipe(Stream10.runDrain);
   }
   const consumer = consumerType === "tui" ? createTUIConsumer() : createHeadlessConsumer();
   return consumer.consume(eventsWithLayers);
@@ -6609,19 +6744,19 @@ function run(options) {
 function runTest(options, mockEvents) {
   const { config, onEvent } = options;
   const events = runLoop(config);
-  const eventsWithCallback = onEvent ? events.pipe(Stream11.tap((event) => Effect25.sync(() => onEvent(event)))) : events;
+  const eventsWithCallback = onEvent ? events.pipe(Stream10.tap((event) => Effect24.sync(() => onEvent(event)))) : events;
   const layers = mockEvents ? createTestLayers(mockEvents) : TestLayers;
-  const eventsWithLayers = eventsWithCallback.pipe(Stream11.provideLayer(layers));
-  return eventsWithLayers.pipe(Stream11.runDrain);
+  const eventsWithLayers = eventsWithCallback.pipe(Stream10.provideLayer(layers));
+  return eventsWithLayers.pipe(Stream10.runDrain);
 }
 function collectEvents(config, mockEvents) {
   const events = runLoop(config);
   const layers = mockEvents ? createTestLayers(mockEvents) : TestLayers;
-  return events.pipe(Stream11.provideLayer(layers), Stream11.runCollect).pipe(Effect25.map((chunk) => Array.from(chunk)));
+  return events.pipe(Stream10.provideLayer(layers), Stream10.runCollect).pipe(Effect24.map((chunk) => Array.from(chunk)));
 }
 function main(config) {
   const consumerType = process.stdout.isTTY ? "tui" : "headless";
-  return run({ config, consumer: consumerType }).pipe(Effect25.runPromise);
+  return run({ config, consumer: consumerType }).pipe(Effect24.runPromise);
 }
 
 // src/services/index.ts
@@ -6796,7 +6931,7 @@ export {
   collectEvents,
   createHeadlessConsumer,
   createProductionLayers,
-  createProviderLayer,
+  createProviderLayer2 as createProviderLayer,
   createTUIConsumer,
   createTestLayers,
   decodeGuardrail,