ferix-code 0.0.2-beta.5 → 0.0.2-beta.7

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.5",
+  version: "0.0.2-beta.7",
   description: "Composable RALPH loops for AI coding agents - v2 with Effect",
   type: "module",
   bin: {
@@ -86,7 +86,8 @@ var package_default = {
     dev: "tsup --watch",
     "check-types": "tsc --noEmit",
     test: "bun test",
-    "test:watch": "bun test --watch"
+    "test:watch": "bun test --watch",
+    bump: "npm version prerelease --preid=beta --workspaces=false && bun run build && bun publish --tag beta"
   },
   dependencies: {
     commander: "^14.0.0",
@@ -117,7 +118,7 @@ var package_default = {
 
 // src/program.ts
 init_esm_shims();
-import { Effect as Effect21, Stream as Stream10 } from "effect";
+import { Effect as Effect23, Stream as Stream10 } from "effect";
 
 // src/consumers/index.ts
 init_esm_shims();
@@ -2216,6 +2217,7 @@ var ANSIOutput = class {
 init_esm_shims();
 
 // src/consumers/tui/consumer.ts
+var CLOCK_REFRESH_INTERVAL_MS = 1e3;
 function formatErrorToLines2(err, lines) {
   if (err instanceof Error) {
     lines.push(`  - ${err.name}: ${err.message}`);
@@ -2275,6 +2277,17 @@ function createTUIConsumer() {
       const inputFiber = yield* Effect3.forkDaemon(
         runInputLoop(stateRef, output)
       );
+      const clockFiber = yield* Effect3.forkDaemon(
+        Effect3.forever(
+          Effect3.gen(function* () {
+            yield* Effect3.sleep(CLOCK_REFRESH_INTERVAL_MS);
+            const state = yield* Ref2.get(stateRef);
+            if (state.status === "running") {
+              yield* Effect3.sync(() => safeRender(state, output));
+            }
+          })
+        )
+      );
       const processEvents = events.pipe(
         Stream3.runForEach(
           (event) => Effect3.gen(function* () {
@@ -2326,6 +2339,7 @@ ${errorText}
           })
         );
       }
+      yield* Fiber.interrupt(clockFiber);
       unsubscribeResize();
       cleanup();
     })
@@ -2334,13 +2348,15 @@ ${errorText}
 
 // src/layers/index.ts
 init_esm_shims();
-import { Layer as Layer12 } from "effect";
+import { Layer as Layer14 } from "effect";
 
-// src/layers/guardrails/file-system.ts
+// src/layers/git/file-system.ts
 init_esm_shims();
-import { mkdir, readFile, writeFile } from "fs/promises";
+import { exec } from "child_process";
+import { access, mkdir, rm } from "fs/promises";
 import { join } from "path";
-import { DateTime, Effect as Effect4, Layer } from "effect";
+import { promisify } from "util";
+import { Effect as Effect4, Layer } from "effect";
 
 // src/domain/errors.ts
 init_esm_shims();
@@ -2361,6 +2377,338 @@ var GuardrailsStoreError = class extends Data.TaggedError(
 };
 var OrchestratorError = class extends Data.TaggedError("OrchestratorError") {
 };
+var GitError = class extends Data.TaggedError("GitError") {
+};
+
+// src/services/git.ts
+init_esm_shims();
+import { Context } from "effect";
+var Git = class extends Context.Tag("@ferix/Git")() {
+};
+
+// src/layers/git/file-system.ts
+var execAsync = promisify(exec);
+var WORKTREES_DIR = ".ferix/worktrees";
+var BRANCH_PREFIX = "ferix";
+function getWorktreeDir(sessionId) {
+  return join(process.cwd(), WORKTREES_DIR, sessionId);
+}
+function getBranchName(sessionId) {
+  return `${BRANCH_PREFIX}/${sessionId}`;
+}
+function gitExec(command, cwd) {
+  return Effect4.tryPromise({
+    try: async () => {
+      const { stdout } = await execAsync(command, { cwd });
+      return stdout.trim();
+    },
+    catch: (error) => {
+      const execError = error;
+      return new GitError({
+        message: execError.stderr || execError.message || String(error),
+        operation: "status",
+        cause: error
+      });
+    }
+  });
+}
+function directoryExists(dirPath) {
+  return Effect4.tryPromise({
+    try: async () => {
+      await access(dirPath);
+      return true;
+    },
+    catch: () => new Error("Directory does not exist")
+  }).pipe(Effect4.orElseSucceed(() => false));
+}
+var make = {
+  createWorktree: (sessionId, baseBranch) => Effect4.gen(function* () {
+    const worktreeDir = getWorktreeDir(sessionId);
+    const branchName = getBranchName(sessionId);
+    const worktreesBase = join(process.cwd(), WORKTREES_DIR);
+    yield* Effect4.tryPromise({
+      try: () => mkdir(worktreesBase, { recursive: true }),
+      catch: (error) => new GitError({
+        message: `Failed to create worktrees directory: ${String(error)}`,
+        operation: "createWorktree",
+        cause: error
+      })
+    });
+    const exists = yield* directoryExists(worktreeDir);
+    if (exists) {
+      return worktreeDir;
+    }
+    const baseRef = baseBranch || "HEAD";
+    const command = `git worktree add "${worktreeDir}" -b "${branchName}" ${baseRef}`;
+    yield* gitExec(command).pipe(
+      Effect4.mapError(
+        (error) => new GitError({
+          message: `Failed to create worktree: ${error.message}`,
+          operation: "createWorktree",
+          cause: error
+        })
+      )
+    );
+    return worktreeDir;
+  }),
+  removeWorktree: (sessionId) => Effect4.gen(function* () {
+    const worktreeDir = getWorktreeDir(sessionId);
+    const branchName = getBranchName(sessionId);
+    const exists = yield* directoryExists(worktreeDir);
+    if (!exists) {
+      return;
+    }
+    yield* gitExec(`git worktree remove "${worktreeDir}" --force`).pipe(
+      Effect4.mapError(
+        (error) => new GitError({
+          message: `Failed to remove worktree: ${error.message}`,
+          operation: "removeWorktree",
+          cause: error
+        })
+      ),
+      // If git worktree remove fails, try manual cleanup
+      Effect4.catchAll(
+        () => Effect4.tryPromise({
+          try: () => rm(worktreeDir, { recursive: true, force: true }),
+          catch: (error) => new GitError({
+            message: `Failed to remove worktree directory: ${String(error)}`,
+            operation: "removeWorktree",
+            cause: error
+          })
+        })
+      )
+    );
+    yield* gitExec(`git branch -D "${branchName}"`).pipe(
+      Effect4.catchAll(() => Effect4.succeed(void 0))
+    );
+    yield* gitExec("git worktree prune").pipe(
+      Effect4.catchAll(() => Effect4.succeed(void 0))
+    );
+  }),
+  getWorktreePath: (sessionId) => Effect4.gen(function* () {
+    const worktreeDir = getWorktreeDir(sessionId);
+    const exists = yield* directoryExists(worktreeDir);
+    return exists ? worktreeDir : void 0;
+  }),
+  commitChanges: (sessionId, message) => Effect4.gen(function* () {
+    const worktreeDir = getWorktreeDir(sessionId);
+    const exists = yield* directoryExists(worktreeDir);
+    if (!exists) {
+      return yield* Effect4.fail(
+        new GitError({
+          message: `Worktree not found for session: ${sessionId}`,
+          operation: "commit"
+        })
+      );
+    }
+    yield* gitExec("git add -A", worktreeDir).pipe(
+      Effect4.mapError(
+        (error) => new GitError({
+          message: `Failed to stage changes: ${error.message}`,
+          operation: "commit",
+          cause: error
+        })
+      )
+    );
+    const status = yield* gitExec("git status --porcelain", worktreeDir).pipe(
+      Effect4.catchAll(() => Effect4.succeed(""))
+    );
+    if (!status) {
+      const head = yield* gitExec("git rev-parse HEAD", worktreeDir).pipe(
+        Effect4.mapError(
+          (error) => new GitError({
+            message: `Failed to get HEAD: ${error.message}`,
+            operation: "commit",
+            cause: error
+          })
+        )
+      );
+      return head;
+    }
+    const escapedMessage = message.replace(/"/g, '\\"');
+    yield* gitExec(`git commit -m "${escapedMessage}"`, worktreeDir).pipe(
+      Effect4.mapError(
+        (error) => new GitError({
+          message: `Failed to commit: ${error.message}`,
+          operation: "commit",
+          cause: error
+        })
+      )
+    );
+    const hash = yield* gitExec("git rev-parse HEAD", worktreeDir).pipe(
+      Effect4.mapError(
+        (error) => new GitError({
+          message: `Failed to get commit hash: ${error.message}`,
+          operation: "commit",
+          cause: error
+        })
+      )
+    );
+    return hash;
+  }),
+  pushBranch: (sessionId) => Effect4.gen(function* () {
+    const worktreeDir = getWorktreeDir(sessionId);
+    const branchName = getBranchName(sessionId);
+    const exists = yield* directoryExists(worktreeDir);
+    if (!exists) {
+      return yield* Effect4.fail(
+        new GitError({
+          message: `Worktree not found for session: ${sessionId}`,
+          operation: "push"
+        })
+      );
+    }
+    yield* gitExec(`git push -u origin "${branchName}"`, worktreeDir).pipe(
+      Effect4.mapError(
+        (error) => new GitError({
+          message: `Failed to push branch: ${error.message}`,
+          operation: "push",
+          cause: error
+        })
+      )
+    );
+  }),
+  createPR: (sessionId, title, body) => Effect4.gen(function* () {
+    const worktreeDir = getWorktreeDir(sessionId);
+    const exists = yield* directoryExists(worktreeDir);
+    if (!exists) {
+      return yield* Effect4.fail(
+        new GitError({
+          message: `Worktree not found for session: ${sessionId}`,
+          operation: "createPR"
+        })
+      );
+    }
+    const escapedTitle = title.replace(/"/g, '\\"');
+    const escapedBody = body.replace(/"/g, '\\"');
+    const prUrl = yield* gitExec(
+      `gh pr create --title "${escapedTitle}" --body "${escapedBody}"`,
+      worktreeDir
+    ).pipe(
+      Effect4.mapError(
+        (error) => new GitError({
+          message: `Failed to create PR: ${error.message}`,
+          operation: "createPR",
+          cause: error
+        })
+      )
+    );
+    return prUrl;
+  }),
+  getBranchName
+};
+var Live = Layer.succeed(Git, make);
+var FileSystemGit = {
+  Live
+};
+
+// src/layers/git/memory.ts
+init_esm_shims();
+import { Effect as Effect5, Layer as Layer2, Ref as Ref3 } from "effect";
+var BRANCH_PREFIX2 = "ferix";
+function getBranchName2(sessionId) {
+  return `${BRANCH_PREFIX2}/${sessionId}`;
+}
+function createMemoryGitService(stateRef, commitCounterRef) {
+  return {
+    createWorktree: (sessionId, _baseBranch) => Effect5.gen(function* () {
+      const state = yield* Ref3.get(stateRef);
+      const existing = state.get(sessionId);
+      if (existing) {
+        return existing.path;
+      }
+      const path2 = `.ferix/worktrees/${sessionId}`;
+      const branch = getBranchName2(sessionId);
+      const worktree = {
+        path: path2,
+        branch,
+        commits: []
+      };
+      state.set(sessionId, worktree);
+      yield* Ref3.set(stateRef, state);
+      return path2;
+    }),
+    removeWorktree: (sessionId) => Effect5.gen(function* () {
+      const state = yield* Ref3.get(stateRef);
+      state.delete(sessionId);
+      yield* Ref3.set(stateRef, state);
+    }),
+    getWorktreePath: (sessionId) => Effect5.gen(function* () {
+      const state = yield* Ref3.get(stateRef);
+      const worktree = state.get(sessionId);
+      return worktree?.path;
+    }),
+    commitChanges: (sessionId, message) => Effect5.gen(function* () {
+      const state = yield* Ref3.get(stateRef);
+      const worktree = state.get(sessionId);
+      if (!worktree) {
+        return yield* Effect5.fail(
+          new GitError({
+            message: `Worktree not found for session: ${sessionId}`,
+            operation: "commit"
+          })
+        );
+      }
+      const counter = yield* Ref3.updateAndGet(commitCounterRef, (n) => n + 1);
+      const hash = `test-commit-${counter}`;
+      const updatedWorktree = {
+        ...worktree,
+        commits: [...worktree.commits, `${hash}: ${message}`]
+      };
+      state.set(sessionId, updatedWorktree);
+      yield* Ref3.set(stateRef, state);
+      return hash;
+    }),
+    pushBranch: (sessionId) => Effect5.gen(function* () {
+      const state = yield* Ref3.get(stateRef);
+      const worktree = state.get(sessionId);
+      if (!worktree) {
+        return yield* Effect5.fail(
+          new GitError({
+            message: `Worktree not found for session: ${sessionId}`,
+            operation: "push"
+          })
+        );
+      }
+    }),
+    createPR: (sessionId, title, _body) => Effect5.gen(function* () {
+      const state = yield* Ref3.get(stateRef);
+      const worktree = state.get(sessionId);
+      if (!worktree) {
+        return yield* Effect5.fail(
+          new GitError({
+            message: `Worktree not found for session: ${sessionId}`,
+            operation: "createPR"
+          })
+        );
+      }
+      const slug = title.toLowerCase().replace(/\s+/g, "-").slice(0, 30);
+      return `https://github.com/test/repo/pull/${slug}`;
+    }),
+    getBranchName: getBranchName2
+  };
+}
+function layer() {
+  return Layer2.effect(
+    Git,
+    Effect5.gen(function* () {
+      const stateRef = yield* Ref3.make(/* @__PURE__ */ new Map());
+      const commitCounterRef = yield* Ref3.make(0);
+      return createMemoryGitService(stateRef, commitCounterRef);
+    })
+  );
+}
+var Live2 = layer();
+var MemoryGit = {
+  Live: Live2,
+  layer
+};
+
+// src/layers/guardrails/file-system.ts
+init_esm_shims();
+import { mkdir as mkdir2, readFile, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+import { DateTime, Effect as Effect6, Layer as Layer3 } from "effect";
 
 // src/domain/index.ts
 init_esm_shims();
@@ -2648,6 +2996,16 @@ var ProgressUpdatedEventSchema = taggedEvent("ProgressUpdated", {
   action: S4.Literal("started", "completed", "failed", "learning"),
   timestamp: S4.Number
 });
+var WorktreeCreatedEventSchema = taggedEvent("WorktreeCreated", {
+  sessionId: S4.String,
+  worktreePath: S4.String,
+  branchName: S4.String,
+  timestamp: S4.Number
+});
+var WorktreeRemovedEventSchema = taggedEvent("WorktreeRemoved", {
+  sessionId: S4.String,
+  timestamp: S4.Number
+});
 var DomainEventSchema = S4.Union(
   LoopStartedEventSchema,
   LoopCompletedEventSchema,
@@ -2677,7 +3035,9 @@ var DomainEventSchema = S4.Union(
   PlanUpdateFailedEventSchema,
   LearningRecordedEventSchema,
   GuardrailAddedEventSchema,
-  ProgressUpdatedEventSchema
+  ProgressUpdatedEventSchema,
+  WorktreeCreatedEventSchema,
+  WorktreeRemovedEventSchema
 );
 var DomainEventUtils = {
   isLLMEvent: (e) => e._tag.startsWith("LLM"),
@@ -2805,7 +3165,9 @@ var SessionSchema = S10.Struct({
   status: SessionStatusSchema,
   originalTask: S10.String,
   completedTasks: S10.Array(S10.String),
-  currentTaskId: S10.optional(S10.String)
+  currentTaskId: S10.optional(S10.String),
+  worktreePath: S10.optional(S10.String),
+  branchName: S10.optional(S10.String)
 });
 var decodeSession = S10.decodeUnknown(SessionSchema);
 
@@ -3053,34 +3415,34 @@ var TUIStateSchema = S13.Struct({
 
 // src/services/guardrails-store.ts
 init_esm_shims();
-import { Context } from "effect";
-var GuardrailsStore = class extends Context.Tag("@ferix/GuardrailsStore")() {
+import { Context as Context2 } from "effect";
+var GuardrailsStore = class extends Context2.Tag("@ferix/GuardrailsStore")() {
 };
 
 // src/layers/guardrails/file-system.ts
 var PLANS_DIR = ".ferix/plans";
 function ensureDir(dirPath) {
-  return Effect4.tryPromise({
-    try: () => mkdir(dirPath, { recursive: true }),
+  return Effect6.tryPromise({
+    try: () => mkdir2(dirPath, { recursive: true }),
     catch: (error) => new GuardrailsStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "add",
       cause: error
     })
-  }).pipe(Effect4.asVoid);
+  }).pipe(Effect6.asVoid);
 }
 function getSessionDir(sessionId) {
-  return join(process.cwd(), PLANS_DIR, sessionId);
+  return join2(process.cwd(), PLANS_DIR, sessionId);
 }
 function getGuardrailsPath(sessionId) {
-  return join(getSessionDir(sessionId), "guardrails.json");
+  return join2(getSessionDir(sessionId), "guardrails.json");
 }
 function serializeGuardrails(guardrails) {
   return JSON.stringify(guardrails, null, 2);
 }
 function deserializeGuardrails(json) {
-  return Effect4.gen(function* () {
-    const parsed = yield* Effect4.try({
+  return Effect6.gen(function* () {
+    const parsed = yield* Effect6.try({
       try: () => JSON.parse(json),
       catch: (error) => new GuardrailsStoreError({
         message: `Invalid JSON in guardrails file: ${String(error)}`,
@@ -3089,7 +3451,7 @@ function deserializeGuardrails(json) {
       })
     });
     const validated = yield* decodeGuardrailsFile(parsed).pipe(
-      Effect4.mapError(
+      Effect6.mapError(
         (error) => new GuardrailsStoreError({
           message: `Guardrails validation failed: ${String(error)}`,
           operation: "load",
@@ -3107,12 +3469,12 @@ function createEmptyGuardrails(sessionId, createdAt) {
     guardrails: []
   };
 }
-var make = {
-  add: (sessionId, guardrail) => Effect4.gen(function* () {
+var make2 = {
+  add: (sessionId, guardrail) => Effect6.gen(function* () {
     const sessionDir = getSessionDir(sessionId);
     yield* ensureDir(sessionDir);
     const guardrailsPath = getGuardrailsPath(sessionId);
-    const existing = yield* Effect4.tryPromise({
+    const existing = yield* Effect6.tryPromise({
       try: async () => {
         try {
           const content = await readFile(guardrailsPath, "utf-8");
@@ -3130,7 +3492,7 @@ var make = {
     let guardrails;
     if (existing) {
       guardrails = yield* deserializeGuardrails(existing).pipe(
-        Effect4.mapError(
+        Effect6.mapError(
           (err) => new GuardrailsStoreError({
             message: err.message,
             operation: "add",
@@ -3146,7 +3508,7 @@ var make = {
       ...guardrails,
       guardrails: [...guardrails.guardrails, guardrail]
     };
-    yield* Effect4.tryPromise({
+    yield* Effect6.tryPromise({
       try: () => writeFile(
         guardrailsPath,
         serializeGuardrails(updatedGuardrails),
@@ -3159,9 +3521,9 @@ var make = {
       })
     });
   }),
-  load: (sessionId) => Effect4.gen(function* () {
+  load: (sessionId) => Effect6.gen(function* () {
     const guardrailsPath = getGuardrailsPath(sessionId);
-    const content = yield* Effect4.tryPromise({
+    const content = yield* Effect6.tryPromise({
       try: async () => {
         try {
           return await readFile(guardrailsPath, "utf-8");
@@ -3181,23 +3543,23 @@ var make = {
     }
     return yield* deserializeGuardrails(content);
   }),
-  getActive: (sessionId) => Effect4.gen(function* () {
-    const guardrails = yield* make.load(sessionId);
+  getActive: (sessionId) => Effect6.gen(function* () {
+    const guardrails = yield* make2.load(sessionId);
     return guardrails.guardrails;
   })
 };
-var Live = Layer.succeed(GuardrailsStore, make);
+var Live3 = Layer3.succeed(GuardrailsStore, make2);
 var FileSystemGuardrails = {
-  Live
+  Live: Live3
 };
 
 // src/layers/guardrails/memory.ts
 init_esm_shims();
-import { DateTime as DateTime2, Effect as Effect5, Layer as Layer2, Ref as Ref3 } from "effect";
+import { DateTime as DateTime2, Effect as Effect7, Layer as Layer4, Ref as Ref4 } from "effect";
 function createMemoryGuardrailsStore(stateRef) {
   return {
-    add: (sessionId, guardrail) => Effect5.gen(function* () {
-      const state = yield* Ref3.get(stateRef);
+    add: (sessionId, guardrail) => Effect7.gen(function* () {
+      const state = yield* Ref4.get(stateRef);
       let guardrails = state.get(sessionId);
       if (!guardrails) {
         const now = yield* DateTime2.now;
@@ -3212,10 +3574,10 @@ function createMemoryGuardrailsStore(stateRef) {
         guardrails: [...guardrails.guardrails, guardrail]
       };
       state.set(sessionId, updatedGuardrails);
-      yield* Ref3.set(stateRef, state);
+      yield* Ref4.set(stateRef, state);
     }),
-    load: (sessionId) => Effect5.gen(function* () {
-      const state = yield* Ref3.get(stateRef);
+    load: (sessionId) => Effect7.gen(function* () {
+      const state = yield* Ref4.get(stateRef);
       const guardrails = state.get(sessionId);
       if (!guardrails) {
         const now = yield* DateTime2.now;
@@ -3227,8 +3589,8 @@ function createMemoryGuardrailsStore(stateRef) {
       }
       return guardrails;
     }),
-    getActive: (sessionId) => Effect5.gen(function* () {
-      const state = yield* Ref3.get(stateRef);
+    getActive: (sessionId) => Effect7.gen(function* () {
+      const state = yield* Ref4.get(stateRef);
       const guardrails = state.get(sessionId);
       if (!guardrails) {
         return [];
@@ -3237,36 +3599,36 @@ function createMemoryGuardrailsStore(stateRef) {
     })
   };
 }
-function layer() {
-  return Layer2.effect(
+function layer2() {
+  return Layer4.effect(
     GuardrailsStore,
-    Effect5.gen(function* () {
-      const stateRef = yield* Ref3.make(/* @__PURE__ */ new Map());
+    Effect7.gen(function* () {
+      const stateRef = yield* Ref4.make(/* @__PURE__ */ new Map());
       return createMemoryGuardrailsStore(stateRef);
     })
   );
 }
-var Live2 = layer();
+var Live4 = layer2();
 var MemoryGuardrails = {
-  Live: Live2,
-  layer
+  Live: Live4,
+  layer: layer2
 };
 
 // src/layers/llm/claude-cli.ts
 init_esm_shims();
 import { spawn } from "child_process";
-import { Effect as Effect7, Layer as Layer3, Stream as Stream5 } from "effect";
+import { Effect as Effect9, Layer as Layer5, Stream as Stream5 } from "effect";
 
 // src/services/llm.ts
 init_esm_shims();
-import { Context as Context2 } from "effect";
-var LLM = class extends Context2.Tag("@ferix/LLM")() {
+import { Context as Context3 } from "effect";
+var LLM = class extends Context3.Tag("@ferix/LLM")() {
 };
 
 // src/layers/llm/stream.ts
 init_esm_shims();
 import { createInterface } from "readline";
-import { Effect as Effect6, Stream as Stream4 } from "effect";
+import { Effect as Effect8, Stream as Stream4 } from "effect";
 
 // src/layers/llm/parsers.ts
 init_esm_shims();
@@ -3392,7 +3754,7 @@ function createEventStream(child) {
       emit.fail(
         new LLMError({ message: "Failed to get stdout from child process" })
       );
-      return Effect6.void;
+      return Effect8.void;
     }
     const rl = createInterface({
       input: stdout,
@@ -3431,17 +3793,17 @@ function createEventStream(child) {
         })
       );
     });
-    return Effect6.sync(() => {
+    return Effect8.sync(() => {
       child.kill("SIGTERM");
     });
   });
 }
 
 // src/layers/llm/claude-cli.ts
-var make2 = {
-  execute: (prompt) => {
+var make3 = {
+  execute: (prompt, options) => {
     return Stream5.unwrap(
-      Effect7.sync(() => {
+      Effect9.sync(() => {
         const child = spawn(
           "claude",
           [
@@ -3456,6 +3818,7 @@ var make2 = {
           ],
           {
             stdio: ["inherit", "pipe", "pipe"],
+            cwd: options?.cwd,
             env: {
               ...process.env,
               FORCE_COLOR: "1"
@@ -3467,25 +3830,25 @@ var make2 = {
     );
   }
 };
-var Live3 = Layer3.succeed(LLM, make2);
+var Live5 = Layer5.succeed(LLM, make3);
 var ClaudeCLI = {
-  Live: Live3
+  Live: Live5
 };
 
 // src/layers/llm/mock.ts
 init_esm_shims();
-import { Effect as Effect8, Layer as Layer4, Schema as S14, Stream as Stream6 } from "effect";
+import { Effect as Effect10, Layer as Layer6, Schema as S14, Stream as Stream6 } from "effect";
 var MockLLMConfigSchema = S14.Struct({
   events: S14.Array(LLMEventSchema),
   delayMs: S14.optional(S14.Number)
 });
 function createMockLLM(config) {
   return {
-    execute: (_prompt) => {
+    execute: (_prompt, _options) => {
       const baseStream = Stream6.fromIterable(config.events);
       if (config.delayMs !== void 0 && config.delayMs > 0) {
         const delay = config.delayMs;
-        return baseStream.pipe(Stream6.tap(() => Effect8.sleep(delay)));
+        return baseStream.pipe(Stream6.tap(() => Effect10.sleep(delay)));
       }
       return baseStream;
     }
@@ -3502,45 +3865,45 @@ var defaultMockEvents = [
   }
 ];
 var defaultMock = createMockLLM({ events: defaultMockEvents });
-var Live4 = Layer4.succeed(LLM, defaultMock);
-function layer2(config) {
-  return Layer4.succeed(LLM, createMockLLM(config));
+var Live6 = Layer6.succeed(LLM, defaultMock);
+function layer3(config) {
+  return Layer6.succeed(LLM, createMockLLM(config));
 }
 var Mock = {
-  Live: Live4,
-  layer: layer2,
+  Live: Live6,
+  layer: layer3,
   createMockLLM
 };
 
 // src/layers/plan/file-system.ts
 init_esm_shims();
-import { access, mkdir as mkdir2, readdir, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { join as join2 } from "path";
-import { Effect as Effect9, Layer as Layer5 } from "effect";
+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 Effect11, Layer as Layer7 } from "effect";
 
 // src/services/plan-store.ts
 init_esm_shims();
-import { Context as Context3 } from "effect";
-var PlanStore = class extends Context3.Tag("@ferix/PlanStore")() {
+import { Context as Context4 } from "effect";
+var PlanStore = class extends Context4.Tag("@ferix/PlanStore")() {
 };
 
 // src/layers/plan/file-system.ts
 var PLANS_DIR2 = ".ferix/plans";
 function ensureDir2(dirPath) {
-  return Effect9.tryPromise({
-    try: () => mkdir2(dirPath, { recursive: true }),
+  return Effect11.tryPromise({
+    try: () => mkdir3(dirPath, { recursive: true }),
     catch: (error) => new PlanStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "create",
       cause: error
     })
-  }).pipe(Effect9.asVoid);
+  }).pipe(Effect11.asVoid);
 }
 function getSessionDir2(sessionId) {
-  return join2(process.cwd(), PLANS_DIR2, sessionId);
+  return join3(process.cwd(), PLANS_DIR2, sessionId);
 }
 function getPlanPath(sessionId, planId) {
-  return join2(getSessionDir2(sessionId), `${planId}.json`);
+  return join3(getSessionDir2(sessionId), `${planId}.json`);
 }
 function generatePlanId(taskNumber) {
   return PlanId(`task-${taskNumber}`);
@@ -3549,8 +3912,8 @@ function serializePlan(plan) {
   return JSON.stringify(plan, null, 2);
 }
 function deserializePlan(json, planId) {
-  return Effect9.gen(function* () {
-    const parsed = yield* Effect9.try({
+  return Effect11.gen(function* () {
+    const parsed = yield* Effect11.try({
       try: () => JSON.parse(json),
       catch: (error) => new PlanStoreError({
         message: `Invalid JSON in plan file: ${String(error)}`,
@@ -3559,7 +3922,7 @@ function deserializePlan(json, planId) {
       })
     });
     const validated = yield* decodePlanData(parsed).pipe(
-      Effect9.mapError(
+      Effect11.mapError(
         (error) => new PlanStoreError({
           message: `Plan validation failed: ${String(error)}`,
           operation: "load",
@@ -3573,11 +3936,11 @@ function deserializePlan(json, planId) {
     };
   });
 }
-var make3 = {
-  create: (sessionId, plan) => Effect9.gen(function* () {
+var make4 = {
+  create: (sessionId, plan) => Effect11.gen(function* () {
     const sessionDir = getSessionDir2(sessionId);
     yield* ensureDir2(sessionDir);
-    const existingPlans = yield* Effect9.tryPromise({
+    const existingPlans = yield* Effect11.tryPromise({
       try: async () => {
         try {
           const files = await readdir(sessionDir);
@@ -3594,7 +3957,7 @@ var make3 = {
     const planId = generatePlanId(existingPlans + 1);
     const planPath = getPlanPath(sessionId, planId);
     const fullPlan = { ...plan, id: planId };
-    yield* Effect9.tryPromise({
+    yield* Effect11.tryPromise({
       try: () => writeFile2(planPath, serializePlan(fullPlan), "utf-8"),
       catch: (error) => new PlanStoreError({
         message: `Failed to write plan file: ${planPath}`,
@@ -3604,10 +3967,10 @@ var make3 = {
     });
     return planId;
   }),
-  load: (planId, sessionId) => Effect9.gen(function* () {
+  load: (planId, sessionId) => Effect11.gen(function* () {
     if (sessionId) {
       const planPath = getPlanPath(sessionId, planId);
-      const content = yield* Effect9.tryPromise({
+      const content = yield* Effect11.tryPromise({
         try: () => readFile2(planPath, "utf-8"),
         catch: (error) => new PlanStoreError({
           message: `Failed to read plan file: ${planPath}`,
@@ -3617,9 +3980,9 @@ var make3 = {
       });
       return yield* deserializePlan(content, planId);
     }
-    const sessionDirs = yield* Effect9.tryPromise({
+    const sessionDirs = yield* Effect11.tryPromise({
       try: async () => {
-        const plansDir = join2(process.cwd(), PLANS_DIR2);
+        const plansDir = join3(process.cwd(), PLANS_DIR2);
         const dirs = await readdir(plansDir);
         return dirs;
       },
@@ -3631,18 +3994,18 @@ var make3 = {
     });
     for (const sid of sessionDirs) {
       const planPath = getPlanPath(sid, planId);
-      const exists = yield* Effect9.tryPromise({
+      const exists = yield* Effect11.tryPromise({
         try: async () => {
-          await access(planPath);
+          await access2(planPath);
           return true;
         },
         catch: () => new PlanStoreError({
           message: "File not found",
           operation: "load"
         })
-      }).pipe(Effect9.orElseSucceed(() => false));
+      }).pipe(Effect11.orElseSucceed(() => false));
       if (exists) {
-        const content = yield* Effect9.tryPromise({
+        const content = yield* Effect11.tryPromise({
           try: () => readFile2(planPath, "utf-8"),
           catch: (error) => new PlanStoreError({
             message: `Failed to read plan file: ${planPath}`,
@@ -3653,16 +4016,16 @@ var make3 = {
         return yield* deserializePlan(content, planId);
       }
     }
-    return yield* Effect9.fail(
+    return yield* Effect11.fail(
       new PlanStoreError({
         message: `Plan not found: ${planId}`,
         operation: "load"
       })
     );
   }),
-  update: (planId, plan) => Effect9.gen(function* () {
+  update: (planId, plan) => Effect11.gen(function* () {
     const planPath = getPlanPath(plan.sessionId, planId);
-    yield* Effect9.tryPromise({
+    yield* Effect11.tryPromise({
       try: () => writeFile2(planPath, serializePlan(plan), "utf-8"),
       catch: (error) => new PlanStoreError({
         message: `Failed to update plan file: ${planPath}`,
@@ -3671,9 +4034,9 @@ var make3 = {
       })
     });
   }),
-  list: (sessionId) => Effect9.gen(function* () {
+  list: (sessionId) => Effect11.gen(function* () {
     const sessionDir = getSessionDir2(sessionId);
-    const files = yield* Effect9.tryPromise({
+    const files = yield* Effect11.tryPromise({
       try: async () => {
         try {
           return await readdir(sessionDir);
@@ -3690,18 +4053,18 @@ var make3 = {
     return files.filter((f) => f.endsWith(".json")).map((f) => PlanId(f.replace(".json", "")));
   })
 };
-var Live5 = Layer5.succeed(PlanStore, make3);
+var Live7 = Layer7.succeed(PlanStore, make4);
 var FileSystemPlan = {
-  Live: Live5
+  Live: Live7
 };
 
 // src/layers/plan/memory.ts
 init_esm_shims();
-import { Effect as Effect10, Layer as Layer6, Ref as Ref4 } from "effect";
+import { Effect as Effect12, Layer as Layer8, Ref as Ref5 } from "effect";
 function createMemoryPlanStore(stateRef) {
   return {
-    create: (sessionId, plan) => Effect10.gen(function* () {
-      const state = yield* Ref4.get(stateRef);
+    create: (sessionId, plan) => Effect12.gen(function* () {
+      const state = yield* Ref5.get(stateRef);
       if (!state.has(sessionId)) {
         state.set(sessionId, /* @__PURE__ */ new Map());
       }
@@ -3712,18 +4075,18 @@ function createMemoryPlanStore(stateRef) {
       const planId = PlanId(`task-${sessionPlans.size + 1}`);
       const fullPlan = { ...plan, id: planId };
       sessionPlans.set(planId, fullPlan);
-      yield* Ref4.set(stateRef, state);
+      yield* Ref5.set(stateRef, state);
       return planId;
     }),
-    load: (planId, sessionId) => Effect10.gen(function* () {
-      const state = yield* Ref4.get(stateRef);
+    load: (planId, sessionId) => Effect12.gen(function* () {
+      const state = yield* Ref5.get(stateRef);
       if (sessionId) {
         const sessionPlans = state.get(sessionId);
         const plan = sessionPlans?.get(planId);
         if (plan) {
           return plan;
         }
-        return yield* Effect10.fail(
+        return yield* Effect12.fail(
           new PlanStoreError({
             message: `Plan not found: ${planId}`,
             operation: "load"
@@ -3736,18 +4099,18 @@ function createMemoryPlanStore(stateRef) {
           return plan;
         }
       }
-      return yield* Effect10.fail(
+      return yield* Effect12.fail(
         new PlanStoreError({
           message: `Plan not found: ${planId}`,
           operation: "load"
         })
       );
     }),
-    update: (planId, plan) => Effect10.gen(function* () {
-      const state = yield* Ref4.get(stateRef);
+    update: (planId, plan) => Effect12.gen(function* () {
+      const state = yield* Ref5.get(stateRef);
       const sessionPlans = state.get(plan.sessionId);
       if (!sessionPlans) {
-        return yield* Effect10.fail(
+        return yield* Effect12.fail(
           new PlanStoreError({
             message: `Session not found: ${plan.sessionId}`,
             operation: "update"
@@ -3755,10 +4118,10 @@ function createMemoryPlanStore(stateRef) {
         );
       }
       sessionPlans.set(planId, plan);
-      yield* Ref4.set(stateRef, state);
+      yield* Ref5.set(stateRef, state);
     }),
-    list: (sessionId) => Effect10.gen(function* () {
-      const state = yield* Ref4.get(stateRef);
+    list: (sessionId) => Effect12.gen(function* () {
+      const state = yield* Ref5.get(stateRef);
       const sessionPlans = state.get(sessionId);
       if (!sessionPlans) {
         return [];
@@ -3767,57 +4130,57 @@ function createMemoryPlanStore(stateRef) {
     })
   };
 }
-function layer3() {
-  return Layer6.effect(
+function layer4() {
+  return Layer8.effect(
     PlanStore,
-    Effect10.gen(function* () {
-      const stateRef = yield* Ref4.make(/* @__PURE__ */ new Map());
+    Effect12.gen(function* () {
+      const stateRef = yield* Ref5.make(/* @__PURE__ */ new Map());
       return createMemoryPlanStore(stateRef);
     })
   );
 }
-var Live6 = layer3();
+var Live8 = layer4();
 var MemoryPlan = {
-  Live: Live6,
-  layer: layer3
+  Live: Live8,
+  layer: layer4
 };
 
 // src/layers/progress/file-system.ts
 init_esm_shims();
-import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { join as join3 } from "path";
-import { DateTime as DateTime3, Effect as Effect11, Layer as Layer7 } from "effect";
+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 Effect13, Layer as Layer9 } from "effect";
 
 // src/services/progress-store.ts
 init_esm_shims();
-import { Context as Context4 } from "effect";
-var ProgressStore = class extends Context4.Tag("@ferix/ProgressStore")() {
+import { Context as Context5 } from "effect";
+var ProgressStore = class extends Context5.Tag("@ferix/ProgressStore")() {
 };
 
 // src/layers/progress/file-system.ts
 var PLANS_DIR3 = ".ferix/plans";
 function ensureDir3(dirPath) {
-  return Effect11.tryPromise({
-    try: () => mkdir3(dirPath, { recursive: true }),
+  return Effect13.tryPromise({
+    try: () => mkdir4(dirPath, { recursive: true }),
     catch: (error) => new ProgressStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "append",
       cause: error
     })
-  }).pipe(Effect11.asVoid);
+  }).pipe(Effect13.asVoid);
 }
 function getSessionDir3(sessionId) {
-  return join3(process.cwd(), PLANS_DIR3, sessionId);
+  return join4(process.cwd(), PLANS_DIR3, sessionId);
 }
 function getProgressPath(sessionId) {
-  return join3(getSessionDir3(sessionId), "progress.json");
+  return join4(getSessionDir3(sessionId), "progress.json");
 }
 function serializeProgress(progress) {
   return JSON.stringify(progress, null, 2);
 }
 function deserializeProgress(json) {
-  return Effect11.gen(function* () {
-    const parsed = yield* Effect11.try({
+  return Effect13.gen(function* () {
+    const parsed = yield* Effect13.try({
       try: () => JSON.parse(json),
       catch: (error) => new ProgressStoreError({
         message: `Invalid JSON in progress file: ${String(error)}`,
@@ -3826,7 +4189,7 @@ function deserializeProgress(json) {
       })
     });
     const validated = yield* decodeProgressFile(parsed).pipe(
-      Effect11.mapError(
+      Effect13.mapError(
         (error) => new ProgressStoreError({
           message: `Progress validation failed: ${String(error)}`,
           operation: "load",
@@ -3844,12 +4207,12 @@ function createEmptyProgress(sessionId, createdAt) {
     entries: []
   };
 }
-var make4 = {
-  append: (sessionId, entry) => Effect11.gen(function* () {
+var make5 = {
+  append: (sessionId, entry) => Effect13.gen(function* () {
     const sessionDir = getSessionDir3(sessionId);
     yield* ensureDir3(sessionDir);
     const progressPath = getProgressPath(sessionId);
-    const existing = yield* Effect11.tryPromise({
+    const existing = yield* Effect13.tryPromise({
       try: async () => {
         try {
           const content = await readFile3(progressPath, "utf-8");
@@ -3867,7 +4230,7 @@ var make4 = {
     let progress;
     if (existing) {
       progress = yield* deserializeProgress(existing).pipe(
-        Effect11.mapError(
+        Effect13.mapError(
           (err) => new ProgressStoreError({
             message: err.message,
             operation: "append",
@@ -3883,7 +4246,7 @@ var make4 = {
       ...progress,
       entries: [...progress.entries, entry]
     };
-    yield* Effect11.tryPromise({
+    yield* Effect13.tryPromise({
       try: () => writeFile3(progressPath, serializeProgress(updatedProgress), "utf-8"),
       catch: (error) => new ProgressStoreError({
         message: `Failed to write progress file: ${progressPath}`,
@@ -3892,9 +4255,9 @@ var make4 = {
       })
     });
   }),
-  load: (sessionId) => Effect11.gen(function* () {
+  load: (sessionId) => Effect13.gen(function* () {
     const progressPath = getProgressPath(sessionId);
-    const content = yield* Effect11.tryPromise({
+    const content = yield* Effect13.tryPromise({
       try: async () => {
         try {
           return await readFile3(progressPath, "utf-8");
@@ -3914,24 +4277,24 @@ var make4 = {
     }
     return yield* deserializeProgress(content);
   }),
-  getRecent: (sessionId, count) => Effect11.gen(function* () {
-    const progress = yield* make4.load(sessionId);
+  getRecent: (sessionId, count) => Effect13.gen(function* () {
+    const progress = yield* make5.load(sessionId);
     const entries = progress.entries;
     return entries.slice(-count);
   })
 };
-var Live7 = Layer7.succeed(ProgressStore, make4);
+var Live9 = Layer9.succeed(ProgressStore, make5);
 var FileSystemProgress = {
-  Live: Live7
+  Live: Live9
 };
 
 // src/layers/progress/memory.ts
 init_esm_shims();
-import { DateTime as DateTime4, Effect as Effect12, Layer as Layer8, Ref as Ref5 } from "effect";
+import { DateTime as DateTime4, Effect as Effect14, Layer as Layer10, Ref as Ref6 } from "effect";
 function createMemoryProgressStore(stateRef) {
   return {
-    append: (sessionId, entry) => Effect12.gen(function* () {
-      const state = yield* Ref5.get(stateRef);
+    append: (sessionId, entry) => Effect14.gen(function* () {
+      const state = yield* Ref6.get(stateRef);
       let progress = state.get(sessionId);
       if (!progress) {
         const now = yield* DateTime4.now;
@@ -3946,10 +4309,10 @@ function createMemoryProgressStore(stateRef) {
         entries: [...progress.entries, entry]
       };
       state.set(sessionId, updatedProgress);
-      yield* Ref5.set(stateRef, state);
+      yield* Ref6.set(stateRef, state);
     }),
-    load: (sessionId) => Effect12.gen(function* () {
-      const state = yield* Ref5.get(stateRef);
+    load: (sessionId) => Effect14.gen(function* () {
+      const state = yield* Ref6.get(stateRef);
       const progress = state.get(sessionId);
       if (!progress) {
         const now = yield* DateTime4.now;
@@ -3961,8 +4324,8 @@ function createMemoryProgressStore(stateRef) {
       }
       return progress;
     }),
-    getRecent: (sessionId, count) => Effect12.gen(function* () {
-      const state = yield* Ref5.get(stateRef);
+    getRecent: (sessionId, count) => Effect14.gen(function* () {
+      const state = yield* Ref6.get(stateRef);
       const progress = state.get(sessionId);
       if (!progress) {
         return [];
@@ -3971,32 +4334,32 @@ function createMemoryProgressStore(stateRef) {
     })
   };
 }
-function layer4() {
-  return Layer8.effect(
+function layer5() {
+  return Layer10.effect(
     ProgressStore,
-    Effect12.gen(function* () {
-      const stateRef = yield* Ref5.make(/* @__PURE__ */ new Map());
+    Effect14.gen(function* () {
+      const stateRef = yield* Ref6.make(/* @__PURE__ */ new Map());
       return createMemoryProgressStore(stateRef);
     })
   );
 }
-var Live8 = layer4();
+var Live10 = layer5();
 var MemoryProgress = {
-  Live: Live8,
-  layer: layer4
+  Live: Live10,
+  layer: layer5
 };
 
 // src/layers/session/file-system.ts
 init_esm_shims();
-import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import { join as join4 } from "path";
-import { DateTime as DateTime5, Effect as Effect13, Layer as Layer9 } from "effect";
+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 Effect15, Layer as Layer11 } from "effect";
 import { humanId } from "human-id";
 
 // src/services/session-store.ts
 init_esm_shims();
-import { Context as Context5 } from "effect";
-var SessionStore = class extends Context5.Tag("@ferix/SessionStore")() {
+import { Context as Context6 } from "effect";
+var SessionStore = class extends Context6.Tag("@ferix/SessionStore")() {
 };
 
 // src/layers/session/file-system.ts
@@ -4006,24 +4369,24 @@ function generateSessionId(timestampMs) {
   return `${id}-${timestampMs}`;
 }
 function ensureDir4(dirPath) {
-  return Effect13.tryPromise({
-    try: () => mkdir4(dirPath, { recursive: true }),
+  return Effect15.tryPromise({
+    try: () => mkdir5(dirPath, { recursive: true }),
     catch: (error) => new SessionStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "create",
       cause: error
     })
-  }).pipe(Effect13.asVoid);
+  }).pipe(Effect15.asVoid);
 }
 function getSessionPath(sessionId) {
-  return join4(process.cwd(), SESSIONS_DIR, `${sessionId}.json`);
+  return join5(process.cwd(), SESSIONS_DIR, `${sessionId}.json`);
 }
 function serializeSession(session) {
   return JSON.stringify(session, null, 2);
 }
 function deserializeSession(json) {
-  return Effect13.gen(function* () {
-    const parsed = yield* Effect13.try({
+  return Effect15.gen(function* () {
+    const parsed = yield* Effect15.try({
       try: () => JSON.parse(json),
       catch: (error) => new SessionStoreError({
         message: `Invalid JSON in session file: ${String(error)}`,
@@ -4032,7 +4395,7 @@ function deserializeSession(json) {
       })
     });
     const validated = yield* decodeSession(parsed).pipe(
-      Effect13.mapError(
+      Effect15.mapError(
         (error) => new SessionStoreError({
           message: `Session validation failed: ${String(error)}`,
           operation: "get",
@@ -4043,9 +4406,9 @@ function deserializeSession(json) {
     return validated;
   });
 }
-var make5 = {
-  create: (originalTask) => Effect13.gen(function* () {
-    const sessionsDir = join4(process.cwd(), SESSIONS_DIR);
+var make6 = {
+  create: (originalTask) => Effect15.gen(function* () {
+    const sessionsDir = join5(process.cwd(), SESSIONS_DIR);
     yield* ensureDir4(sessionsDir);
     const now = yield* DateTime5.now;
     const timestampMs = DateTime5.toEpochMillis(now);
@@ -4058,7 +4421,7 @@ var make5 = {
       completedTasks: []
     };
     const sessionPath = getSessionPath(sessionId);
-    yield* Effect13.tryPromise({
+    yield* Effect15.tryPromise({
       try: () => writeFile4(sessionPath, serializeSession(session), "utf-8"),
       catch: (error) => new SessionStoreError({
         message: `Failed to write session file: ${sessionPath}`,
@@ -4068,9 +4431,9 @@ var make5 = {
     });
     return session;
   }),
-  get: (sessionId) => Effect13.gen(function* () {
+  get: (sessionId) => Effect15.gen(function* () {
     const sessionPath = getSessionPath(sessionId);
-    const content = yield* Effect13.tryPromise({
+    const content = yield* Effect15.tryPromise({
       try: () => readFile4(sessionPath, "utf-8"),
       catch: (error) => new SessionStoreError({
         message: `Failed to read session file: ${sessionPath}`,
@@ -4080,9 +4443,9 @@ var make5 = {
     });
     return yield* deserializeSession(content);
   }),
-  update: (sessionId, session) => Effect13.gen(function* () {
+  update: (sessionId, session) => Effect15.gen(function* () {
     const sessionPath = getSessionPath(sessionId);
-    yield* Effect13.tryPromise({
+    yield* Effect15.tryPromise({
       try: () => writeFile4(sessionPath, serializeSession(session), "utf-8"),
       catch: (error) => new SessionStoreError({
         message: `Failed to update session file: ${sessionPath}`,
@@ -4092,19 +4455,19 @@ var make5 = {
     });
   })
 };
-var Live9 = Layer9.succeed(SessionStore, make5);
+var Live11 = Layer11.succeed(SessionStore, make6);
 var FileSystemSession = {
-  Live: Live9
+  Live: Live11
 };
 
 // src/layers/session/memory.ts
 init_esm_shims();
-import { DateTime as DateTime6, Effect as Effect14, Layer as Layer10, Ref as Ref6 } from "effect";
+import { DateTime as DateTime6, Effect as Effect16, Layer as Layer12, Ref as Ref7 } from "effect";
 function createMemorySessionStore(stateRef, counterRef) {
   return {
-    create: (originalTask) => Effect14.gen(function* () {
-      const state = yield* Ref6.get(stateRef);
-      const counter = yield* Ref6.updateAndGet(counterRef, (n) => n + 1);
+    create: (originalTask) => Effect16.gen(function* () {
+      const state = yield* Ref7.get(stateRef);
+      const counter = yield* Ref7.updateAndGet(counterRef, (n) => n + 1);
       const sessionId = `test-session-${counter}`;
       const now = yield* DateTime6.now;
       const session = {
@@ -4115,14 +4478,14 @@ function createMemorySessionStore(stateRef, counterRef) {
         completedTasks: []
       };
       state.set(sessionId, session);
-      yield* Ref6.set(stateRef, state);
+      yield* Ref7.set(stateRef, state);
       return session;
     }),
-    get: (sessionId) => Effect14.gen(function* () {
-      const state = yield* Ref6.get(stateRef);
+    get: (sessionId) => Effect16.gen(function* () {
+      const state = yield* Ref7.get(stateRef);
       const session = state.get(sessionId);
       if (!session) {
-        return yield* Effect14.fail(
+        return yield* Effect16.fail(
           new SessionStoreError({
             message: `Session not found: ${sessionId}`,
             operation: "get"
@@ -4131,10 +4494,10 @@ function createMemorySessionStore(stateRef, counterRef) {
       }
       return session;
     }),
-    update: (sessionId, session) => Effect14.gen(function* () {
-      const state = yield* Ref6.get(stateRef);
+    update: (sessionId, session) => Effect16.gen(function* () {
+      const state = yield* Ref7.get(stateRef);
       if (!state.has(sessionId)) {
-        return yield* Effect14.fail(
+        return yield* Effect16.fail(
           new SessionStoreError({
             message: `Session not found: ${sessionId}`,
             operation: "update"
@@ -4142,34 +4505,34 @@ function createMemorySessionStore(stateRef, counterRef) {
         );
       }
       state.set(sessionId, session);
-      yield* Ref6.set(stateRef, state);
+      yield* Ref7.set(stateRef, state);
     })
   };
 }
-function layer5() {
-  return Layer10.effect(
+function layer6() {
+  return Layer12.effect(
     SessionStore,
-    Effect14.gen(function* () {
-      const stateRef = yield* Ref6.make(/* @__PURE__ */ new Map());
-      const counterRef = yield* Ref6.make(0);
+    Effect16.gen(function* () {
+      const stateRef = yield* Ref7.make(/* @__PURE__ */ new Map());
+      const counterRef = yield* Ref7.make(0);
       return createMemorySessionStore(stateRef, counterRef);
     })
   );
 }
-var Live10 = layer5();
+var Live12 = layer6();
 var MemorySession = {
-  Live: Live10,
-  layer: layer5
+  Live: Live12,
+  layer: layer6
 };
 
 // src/layers/signal/ferix-parser.ts
 init_esm_shims();
-import { Effect as Effect15, Layer as Layer11, Ref as Ref7 } from "effect";
+import { Effect as Effect17, Layer as Layer13, Ref as Ref8 } from "effect";
 
 // src/services/signal-parser.ts
 init_esm_shims();
-import { Context as Context6 } from "effect";
-var SignalParser = class extends Context6.Tag("@ferix/SignalParser")() {
+import { Context as Context7 } from "effect";
+var SignalParser = class extends Context7.Tag("@ferix/SignalParser")() {
 };
 
 // src/layers/signal/specs/index.ts
@@ -4674,20 +5037,20 @@ signalSpecRegistry.register(tasksDefinedSpec);
 // src/layers/signal/ferix-parser.ts
 var MAX_BUFFER_SIZE = 1024 * 1024;
 function createAccumulatorImpl() {
-  return Effect15.gen(function* () {
-    const chunksRef = yield* Ref7.make([]);
-    const emittedRef = yield* Ref7.make(/* @__PURE__ */ new Set());
-    const feed = (text) => Effect15.gen(function* () {
-      const chunks = yield* Ref7.get(chunksRef);
+  return Effect17.gen(function* () {
+    const chunksRef = yield* Ref8.make([]);
+    const emittedRef = yield* Ref8.make(/* @__PURE__ */ new Set());
+    const feed = (text) => Effect17.gen(function* () {
+      const chunks = yield* Ref8.get(chunksRef);
       chunks.push(text);
       const buffer = chunks.join("");
       if (buffer.length > MAX_BUFFER_SIZE) {
-        yield* Ref7.set(chunksRef, [
+        yield* Ref8.set(chunksRef, [
           buffer.slice(buffer.length - MAX_BUFFER_SIZE)
         ]);
       }
       const signals = signalSpecRegistry.parseAll(buffer);
-      const emitted = yield* Ref7.get(emittedRef);
+      const emitted = yield* Ref8.get(emittedRef);
       const newSignals = signals.filter((signal) => {
         const key = signalSpecRegistry.getSignalKey(signal);
         if (emitted.has(key)) {
@@ -4699,61 +5062,64 @@ function createAccumulatorImpl() {
       if (newSignals.length > 0) {
         const lastEndPos = signalSpecRegistry.findLastCompleteSignalEnd(buffer);
         if (lastEndPos > 0 && lastEndPos < buffer.length) {
-          yield* Ref7.set(chunksRef, [buffer.slice(lastEndPos)]);
+          yield* Ref8.set(chunksRef, [buffer.slice(lastEndPos)]);
         }
       }
-      yield* Ref7.set(emittedRef, emitted);
+      yield* Ref8.set(emittedRef, emitted);
       return newSignals;
     });
-    const flush = () => Effect15.gen(function* () {
-      const chunks = yield* Ref7.get(chunksRef);
+    const flush = () => Effect17.gen(function* () {
+      const chunks = yield* Ref8.get(chunksRef);
       const buffer = chunks.join("");
-      yield* Ref7.set(chunksRef, []);
-      const emitted = yield* Ref7.get(emittedRef);
+      yield* Ref8.set(chunksRef, []);
+      const emitted = yield* Ref8.get(emittedRef);
       const signals = signalSpecRegistry.parseAll(buffer);
       const result = signals.filter(
         (signal) => !emitted.has(signalSpecRegistry.getSignalKey(signal))
       );
-      yield* Ref7.set(emittedRef, /* @__PURE__ */ new Set());
+      yield* Ref8.set(emittedRef, /* @__PURE__ */ new Set());
       return result;
     });
     return { feed, flush };
   });
 }
-var make6 = {
-  parse: (text) => Effect15.succeed(signalSpecRegistry.parseAll(text)),
+var make7 = {
+  parse: (text) => Effect17.succeed(signalSpecRegistry.parseAll(text)),
   createAccumulator: createAccumulatorImpl
 };
-var Live11 = Layer11.succeed(SignalParser, make6);
+var Live13 = Layer13.succeed(SignalParser, make7);
 var FerixParser = {
-  Live: Live11
+  Live: Live13
 };
 
 // src/layers/index.ts
-var ProductionLayers = Layer12.mergeAll(
+var ProductionLayers = Layer14.mergeAll(
   ClaudeCLI.Live,
   FerixParser.Live,
   FileSystemPlan.Live,
   FileSystemSession.Live,
   FileSystemProgress.Live,
-  FileSystemGuardrails.Live
+  FileSystemGuardrails.Live,
+  FileSystemGit.Live
 );
-var TestLayers = Layer12.mergeAll(
+var TestLayers = Layer14.mergeAll(
   Mock.Live,
   FerixParser.Live,
   MemoryPlan.Live,
   MemorySession.Live,
   MemoryProgress.Live,
-  MemoryGuardrails.Live
+  MemoryGuardrails.Live,
+  MemoryGit.Live
 );
 function createTestLayers(events) {
-  return Layer12.mergeAll(
+  return Layer14.mergeAll(
     Mock.layer({ events }),
     FerixParser.Live,
     MemoryPlan.layer(),
     MemorySession.layer(),
     MemoryProgress.layer(),
-    MemoryGuardrails.layer()
+    MemoryGuardrails.layer(),
+    MemoryGit.layer()
   );
 }
 
@@ -4762,41 +5128,41 @@ init_esm_shims();
 
 // src/orchestrator/loop.ts
 init_esm_shims();
-import { DateTime as DateTime10, Effect as Effect20, Option, pipe as pipe3, Ref as Ref11, Stream as Stream9 } from "effect";
+import { DateTime as DateTime10, Effect as Effect22, 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 Effect18, pipe, Ref as Ref9, Stream as Stream7 } from "effect";
+import { DateTime as DateTime8, Effect as Effect20, pipe, Ref as Ref10, Stream as Stream7 } from "effect";
 
 // src/layers/plan/task-generation.ts
 init_esm_shims();
-import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import { join as join5 } from "path";
-import { Effect as Effect16 } from "effect";
+import { mkdir as mkdir6, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { join as join6 } from "path";
+import { Effect as Effect18 } from "effect";
 var PLANS_DIR4 = ".ferix/plans";
 function ensureDir5(dirPath) {
-  return Effect16.tryPromise({
-    try: () => mkdir5(dirPath, { recursive: true }),
+  return Effect18.tryPromise({
+    try: () => mkdir6(dirPath, { recursive: true }),
     catch: (error) => new PlanStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "create",
       cause: error
     })
-  }).pipe(Effect16.asVoid);
+  }).pipe(Effect18.asVoid);
 }
 function getSessionDir4(sessionId) {
-  return join5(process.cwd(), PLANS_DIR4, sessionId);
+  return join6(process.cwd(), PLANS_DIR4, sessionId);
 }
 function getTasksMdPath(sessionId) {
-  return join5(getSessionDir4(sessionId), "tasks.md");
+  return join6(getSessionDir4(sessionId), "tasks.md");
 }
 function writeTasksMd(sessionId, tasks) {
-  return Effect16.gen(function* () {
+  return Effect18.gen(function* () {
     const sessionDir = getSessionDir4(sessionId);
     yield* ensureDir5(sessionDir);
     const tasksMdPath = getTasksMdPath(sessionId);
     const content = formatTasksMd(tasks);
-    yield* Effect16.tryPromise({
+    yield* Effect18.tryPromise({
       try: () => writeFile5(tasksMdPath, content, "utf-8"),
       catch: (error) => new PlanStoreError({
         message: `Failed to write tasks.md: ${tasksMdPath}`,
@@ -4978,7 +5344,7 @@ function mapSignalToDomain(signal, context) {
 
 // src/orchestrator/plan-updates.ts
 init_esm_shims();
-import { DateTime as DateTime7, Effect as Effect17, Ref as Ref8 } from "effect";
+import { DateTime as DateTime7, Effect as Effect19, Ref as Ref9 } from "effect";
 
 // src/orchestrator/plan-updates/index.ts
 init_esm_shims();
@@ -5283,9 +5649,9 @@ function persistPlanUpdate(planStore, plan, operation) {
     tasks: plan.tasks
   }) : planStore.update(plan.id, plan);
   return storeOp.pipe(
-    Effect17.map(() => null),
-    Effect17.catchAll(
-      (error) => Effect17.succeed({
+    Effect19.map(() => null),
+    Effect19.catchAll(
+      (error) => Effect19.succeed({
         _tag: "PlanUpdateFailed",
         operation,
         error: error.message,
@@ -5295,8 +5661,8 @@ function persistPlanUpdate(planStore, plan, operation) {
   );
 }
 function updatePlanFromSignal(currentPlanRef, persistenceStateRef, signal, sessionId, originalTask) {
-  return Effect17.gen(function* () {
-    const currentPlan = yield* Ref8.get(currentPlanRef);
+  return Effect19.gen(function* () {
+    const currentPlan = yield* Ref9.get(currentPlanRef);
     const now = yield* DateTime7.now;
     const timestamp = DateTime7.formatIso(now);
     const updateResult = computePlanUpdate(signal, currentPlan, {
@@ -5308,8 +5674,8 @@ function updatePlanFromSignal(currentPlanRef, persistenceStateRef, signal, sessi
       return [];
     }
     const { plan, operation, eventTag } = updateResult;
-    yield* Ref8.set(currentPlanRef, plan);
-    yield* Ref8.update(persistenceStateRef, (state) => ({
+    yield* Ref9.set(currentPlanRef, plan);
+    yield* Ref9.update(persistenceStateRef, (state) => ({
       dirty: true,
       pendingOperation: state.pendingOperation === "create" ? "create" : operation
     }));
@@ -5317,12 +5683,12 @@ function updatePlanFromSignal(currentPlanRef, persistenceStateRef, signal, sessi
   });
 }
 function flushPlanPersistence(planStore, currentPlanRef, persistenceStateRef) {
-  return Effect17.gen(function* () {
-    const state = yield* Ref8.get(persistenceStateRef);
+  return Effect19.gen(function* () {
+    const state = yield* Ref9.get(persistenceStateRef);
     if (!(state.dirty && state.pendingOperation)) {
       return [];
     }
-    const plan = yield* Ref8.get(currentPlanRef);
+    const plan = yield* Ref9.get(currentPlanRef);
     if (!plan) {
       return [];
     }
@@ -5335,7 +5701,7 @@ function flushPlanPersistence(planStore, currentPlanRef, persistenceStateRef) {
     if (failureEvent) {
       events.push(failureEvent);
     }
-    yield* Ref8.set(persistenceStateRef, {
+    yield* Ref9.set(persistenceStateRef, {
       dirty: false,
       pendingOperation: null
     });
@@ -5394,9 +5760,12 @@ Use these XML-like tags to communicate structured information:
   <files-created>new-file.ts</files-created>
 </ferix:task-complete>
 
-### Loop Completion
+### Loop Completion (use ONLY when ALL tasks are done)
 <ferix:complete>
 
+\u26A0\uFE0F IMPORTANT: Only emit <ferix:complete> after ALL tasks in the plan are complete.
+After completing a single task, emit <ferix:task-complete> and continue to the next task.
+
 IMPORTANT: Always emit signals on their own lines, never inside markdown code blocks.`;
 var DISCOVERY_SYSTEM_PROMPT = `You are in the DISCOVERY phase of a ralph loop - an iterative AI coding workflow.
 
@@ -5437,14 +5806,17 @@ Review the code for quality:
 - When done, emit <ferix:review-complete/>`;
 var DEFAULT_COMPLETION_PROMPT = `## Completion
 
-When the task is complete, emit:
+When you finish the CURRENT task, emit:
 <ferix:task-complete id="N">
   <summary>What was accomplished</summary>
   <files-modified>list of modified files</files-modified>
   <files-created>list of new files</files-created>
 </ferix:task-complete>
 
-When ALL tasks are complete, emit <ferix:complete>`;
+After emitting task-complete, CONTINUE working on the next pending task.
+
+\u26A0\uFE0F ONLY emit <ferix:complete> when ALL tasks in the plan are done.
+Do NOT emit <ferix:complete> after completing just one task - continue to the next task instead.`;
 function getPhasePrompt(phase, prompts, defaultPrompt) {
   return prompts?.phases?.[phase] ?? defaultPrompt;
 }
@@ -5585,12 +5957,12 @@ Begin.`);
 
 // src/orchestrator/discovery.ts
 function processTextSignals(signalParser, text, context) {
-  return Effect18.gen(function* () {
+  return Effect20.gen(function* () {
     const events = [];
     const parsedSignals = [];
     const signals = yield* signalParser.parse(text).pipe(
-      Effect18.tapError(
-        (error) => Effect18.logDebug(
+      Effect20.tapError(
+        (error) => Effect20.logDebug(
           "Signal parsing failed, continuing with empty signals",
           {
             error: String(error),
@@ -5598,7 +5970,7 @@ function processTextSignals(signalParser, text, context) {
           }
         )
       ),
-      Effect18.orElseSucceed(() => [])
+      Effect20.orElseSucceed(() => [])
     );
     for (const signal of signals) {
       events.push(mapSignalToDomain(signal, context));
@@ -5608,7 +5980,7 @@ function processTextSignals(signalParser, text, context) {
   });
 }
 function processLLMEvent(signalParser, llmEvent, context) {
-  return Effect18.gen(function* () {
+  return Effect20.gen(function* () {
     const domainEvent = mapLLMEventToDomain(llmEvent, context);
     const events = [domainEvent];
     const allSignals = [];
@@ -5651,12 +6023,12 @@ function planTasksToGeneratedTasks(plan) {
     status: mapTaskStatus(task.status)
   }));
 }
-function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, config, sessionId) {
+function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, config, sessionId, worktreePath) {
   return Stream7.unwrap(
-    Effect18.gen(function* () {
+    Effect20.gen(function* () {
       const startTimeUtc = yield* DateTime8.now;
       const startTime = DateTime8.toEpochMillis(startTimeUtc);
-      const persistenceStateRef = yield* Ref9.make({
+      const persistenceStateRef = yield* Ref10.make({
         dirty: false,
         pendingOperation: null
       });
@@ -5670,7 +6042,7 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
         input: {}
       };
       const prompt = buildDiscoveryPrompt(config);
-      const llmStream = llm.execute(prompt).pipe(
+      const llmStream = llm.execute(prompt, worktreePath ? { cwd: worktreePath } : void 0).pipe(
         Stream7.mapError(
           (e) => new OrchestratorError({
             message: `LLM execution failed during discovery: ${String(e)}`,
@@ -5680,7 +6052,7 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
         ),
         Stream7.flatMap(
           (llmEvent) => Stream7.unwrap(
-            Effect18.gen(function* () {
+            Effect20.gen(function* () {
               const now = yield* DateTime8.now;
               const context = {
                 timestamp: DateTime8.toEpochMillis(now)
@@ -5717,23 +6089,23 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
         )
       );
       const completionStream = Stream7.fromEffect(
-        Effect18.gen(function* () {
+        Effect20.gen(function* () {
           const persistEvents = yield* flushPlanPersistence(
             planStore,
             currentPlanRef,
             persistenceStateRef
           );
-          const plan = yield* Ref9.get(currentPlanRef);
+          const plan = yield* Ref10.get(currentPlanRef);
           const taskCount = plan?.tasks.length ?? 0;
           if (plan && plan.tasks.length > 0) {
             const generatedTasks = planTasksToGeneratedTasks(plan);
             yield* writeTasksMd(sessionId, generatedTasks).pipe(
-              Effect18.tapError(
-                (error) => Effect18.logDebug("Failed to write tasks.md, continuing", {
+              Effect20.tapError(
+                (error) => Effect20.logDebug("Failed to write tasks.md, continuing", {
                   error: String(error)
                 })
               ),
-              Effect18.orElseSucceed(() => void 0)
+              Effect20.orElseSucceed(() => void 0)
             );
           }
           const endTimeUtc = yield* DateTime8.now;
@@ -5758,15 +6130,15 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
 
 // src/orchestrator/iteration.ts
 init_esm_shims();
-import { DateTime as DateTime9, Effect as Effect19, pipe as pipe2, Ref as Ref10, Stream as Stream8 } from "effect";
+import { DateTime as DateTime9, Effect as Effect21, pipe as pipe2, Ref as Ref11, Stream as Stream8 } from "effect";
 function processTextSignals2(signalParser, text, context) {
-  return Effect19.gen(function* () {
+  return Effect21.gen(function* () {
     const events = [];
     let completed = false;
     const parsedSignals = [];
     const signals = yield* signalParser.parse(text).pipe(
-      Effect19.tapError(
-        (error) => Effect19.logDebug(
+      Effect21.tapError(
+        (error) => Effect21.logDebug(
           "Signal parsing failed, continuing with empty signals",
           {
             error: String(error),
@@ -5774,7 +6146,7 @@ function processTextSignals2(signalParser, text, context) {
           }
         )
       ),
-      Effect19.orElseSucceed(() => [])
+      Effect21.orElseSucceed(() => [])
     );
     for (const signal of signals) {
       events.push(mapSignalToDomain(signal, context));
@@ -5787,7 +6159,7 @@ function processTextSignals2(signalParser, text, context) {
   });
 }
 function processLLMEvent2(signalParser, llmEvent, context) {
-  return Effect19.gen(function* () {
+  return Effect21.gen(function* () {
     const domainEvent = mapLLMEventToDomain(llmEvent, context);
     const events = [domainEvent];
     let completed = false;
@@ -5818,11 +6190,11 @@ function processLLMEvent2(signalParser, llmEvent, context) {
     return { events, completed, signals: allSignals };
   });
 }
-function createIterationStream(llm, signalParser, planStore, currentPlanRef, loopCompletedRef, config, iteration, sessionId) {
+function createIterationStream(llm, signalParser, planStore, currentPlanRef, loopCompletedRef, config, iteration, sessionId, worktreePath) {
   return Stream8.unwrap(
-    Effect19.gen(function* () {
-      const currentPlan = yield* Ref10.get(currentPlanRef);
-      const persistenceStateRef = yield* Ref10.make({
+    Effect21.gen(function* () {
+      const currentPlan = yield* Ref11.get(currentPlanRef);
+      const persistenceStateRef = yield* Ref11.make({
         dirty: false,
         pendingOperation: null
       });
@@ -5830,7 +6202,10 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
         _tag: "IterationStarted",
         iteration
       };
-      const llmStream = llm.execute(buildPrompt(config, iteration, currentPlan)).pipe(
+      const llmStream = llm.execute(
+        buildPrompt(config, iteration, currentPlan),
+        worktreePath ? { cwd: worktreePath } : void 0
+      ).pipe(
         Stream8.mapError(
           (e) => new OrchestratorError({
             message: `LLM execution failed: ${String(e)}`,
@@ -5840,7 +6215,7 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
         ),
         Stream8.flatMap(
           (llmEvent) => Stream8.unwrap(
-            Effect19.gen(function* () {
+            Effect21.gen(function* () {
               const now = yield* DateTime9.now;
               const context = {
                 timestamp: DateTime9.toEpochMillis(now)
@@ -5862,7 +6237,7 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
                 events.push(...planEvents);
               }
               if (result.completed) {
-                yield* Ref10.set(loopCompletedRef, true);
+                yield* Ref11.set(loopCompletedRef, true);
               }
               return Stream8.fromIterable(events);
             })
@@ -5881,7 +6256,7 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
         )
       );
       const completionStream = Stream8.fromEffect(
-        Effect19.gen(function* () {
+        Effect21.gen(function* () {
           const persistEvents = yield* flushPlanPersistence(
             planStore,
             currentPlanRef,
@@ -5906,13 +6281,14 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
 // src/orchestrator/loop.ts
 function runLoop(config) {
   return Stream9.unwrap(
-    Effect20.gen(function* () {
+    Effect22.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(
-        Effect20.mapError(
+        Effect22.mapError(
           (e) => new OrchestratorError({
             message: `Failed to create session: ${e.message}`,
             phase: "setup",
@@ -5920,10 +6296,39 @@ function runLoop(config) {
           })
         )
       );
+      const worktreePath = yield* git.createWorktree(session.id).pipe(
+        Effect22.mapError(
+          (e) => new OrchestratorError({
+            message: `Failed to create worktree: ${e.message}`,
+            phase: "setup",
+            cause: e
+          })
+        )
+      );
+      const branchName = git.getBranchName(session.id);
+      yield* sessionStore.update(session.id, {
+        ...session,
+        worktreePath,
+        branchName
+      }).pipe(
+        Effect22.tapError(
+          (error) => Effect22.logDebug("Failed to update session with worktree info", {
+            error: String(error)
+          })
+        ),
+        Effect22.orElseSucceed(() => void 0)
+      );
       const startTimeUtc = yield* DateTime10.now;
       const startTime = DateTime10.toEpochMillis(startTimeUtc);
-      const loopCompletedRef = yield* Ref11.make(false);
-      const currentPlanRef = yield* Ref11.make(void 0);
+      const worktreeCreated = {
+        _tag: "WorktreeCreated",
+        sessionId: session.id,
+        worktreePath,
+        branchName,
+        timestamp: startTime
+      };
+      const loopCompletedRef = yield* Ref12.make(false);
+      const currentPlanRef = yield* Ref12.make(void 0);
       const maxIterations = config.maxIterations === 0 ? Number.POSITIVE_INFINITY : config.maxIterations;
       const loopStarted = {
         _tag: "LoopStarted",
@@ -5936,12 +6341,13 @@ function runLoop(config) {
         planStore,
         currentPlanRef,
         config,
-        session.id
+        session.id,
+        worktreePath
       );
       const iterationsStream = Stream9.unfoldEffect(
         1,
-        (iteration) => Effect20.gen(function* () {
-          const completed = yield* Ref11.get(loopCompletedRef);
+        (iteration) => Effect22.gen(function* () {
+          const completed = yield* Ref12.get(loopCompletedRef);
           if (completed || iteration > maxIterations) {
             return Option.none();
           }
@@ -5957,27 +6363,31 @@ function runLoop(config) {
             loopCompletedRef,
             config,
             iteration,
-            session.id
+            session.id,
+            worktreePath
           )
         )
       );
       const completionStream = createCompletionStream(
         sessionStore,
+        git,
         session,
         config,
         startTime,
-        loopCompletedRef
+        loopCompletedRef,
+        worktreePath
       );
       return pipe3(
         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)
-      Effect20.catchAll(
-        (error) => Effect20.succeed(
+      Effect22.catchAll(
+        (error) => Effect22.succeed(
           Stream9.succeed({
             _tag: "LoopFailed",
             error: {
@@ -5990,12 +6400,38 @@ function runLoop(config) {
     )
   );
 }
-function createCompletionStream(sessionStore, session, config, startTime, loopCompletedRef) {
-  return Stream9.fromEffect(
-    Effect20.gen(function* () {
+function createCompletionStream(sessionStore, git, session, config, startTime, loopCompletedRef, worktreePath) {
+  return Stream9.unwrap(
+    Effect22.gen(function* () {
       const endTimeUtc = yield* DateTime10.now;
       const durationMs = DateTime10.toEpochMillis(endTimeUtc) - startTime;
-      const completed = yield* Ref11.get(loopCompletedRef);
+      const completed = yield* Ref12.get(loopCompletedRef);
+      yield* git.commitChanges(session.id, `feat: complete session ${session.id}`).pipe(
+        Effect22.tapError(
+          (error) => Effect22.logDebug("Final commit failed, continuing cleanup", {
+            sessionId: session.id,
+            error: String(error)
+          })
+        ),
+        Effect22.orElseSucceed(() => void 0)
+      );
+      yield* git.removeWorktree(session.id).pipe(
+        Effect22.tapError(
+          (error) => Effect22.logDebug("Worktree cleanup failed, continuing", {
+            sessionId: session.id,
+            worktreePath,
+            error: String(error)
+          })
+        ),
+        Effect22.orElseSucceed(() => void 0)
+      );
+      const cleanupTimeUtc = yield* DateTime10.now;
+      const cleanupTime = DateTime10.toEpochMillis(cleanupTimeUtc);
+      const worktreeRemoved = {
+        _tag: "WorktreeRemoved",
+        sessionId: session.id,
+        timestamp: cleanupTime
+      };
       const summary = {
         iterations: config.maxIterations,
         success: completed,
@@ -6007,16 +6443,16 @@ function createCompletionStream(sessionStore, session, config, startTime, loopCo
         ...session,
         status: completed ? "completed" : "paused"
       }).pipe(
-        Effect20.tapError(
-          (error) => Effect20.logDebug("Session update failed, continuing", {
+        Effect22.tapError(
+          (error) => Effect22.logDebug("Session update failed, continuing", {
             sessionId: session.id,
             error: String(error)
           })
         ),
-        Effect20.orElseSucceed(() => void 0)
+        Effect22.orElseSucceed(() => void 0)
       );
-      const event = { _tag: "LoopCompleted", summary };
-      return event;
+      const loopCompleted = { _tag: "LoopCompleted", summary };
+      return Stream9.fromIterable([worktreeRemoved, loopCompleted]);
     })
   );
 }
@@ -6025,7 +6461,7 @@ function createCompletionStream(sessionStore, session, config, startTime, loopCo
 function run(options) {
   const { config, consumer: consumerType = "headless", onEvent } = options;
   const events = runLoop(config);
-  const eventsWithCallback = onEvent ? events.pipe(Stream10.tap((event) => Effect21.sync(() => onEvent(event)))) : events;
+  const eventsWithCallback = onEvent ? events.pipe(Stream10.tap((event) => Effect23.sync(() => onEvent(event)))) : events;
   const eventsWithLayers = eventsWithCallback.pipe(
     Stream10.provideLayer(ProductionLayers)
   );
@@ -6038,7 +6474,7 @@ function run(options) {
 function runTest(options, mockEvents) {
   const { config, onEvent } = options;
   const events = runLoop(config);
-  const eventsWithCallback = onEvent ? events.pipe(Stream10.tap((event) => Effect21.sync(() => onEvent(event)))) : events;
+  const eventsWithCallback = onEvent ? events.pipe(Stream10.tap((event) => Effect23.sync(() => onEvent(event)))) : events;
   const layers = mockEvents ? createTestLayers(mockEvents) : TestLayers;
   const eventsWithLayers = eventsWithCallback.pipe(Stream10.provideLayer(layers));
   return eventsWithLayers.pipe(Stream10.runDrain);
@@ -6046,11 +6482,11 @@ function runTest(options, mockEvents) {
 function collectEvents(config, mockEvents) {
   const events = runLoop(config);
   const layers = mockEvents ? createTestLayers(mockEvents) : TestLayers;
-  return events.pipe(Stream10.provideLayer(layers), Stream10.runCollect).pipe(Effect21.map((chunk) => Array.from(chunk)));
+  return events.pipe(Stream10.provideLayer(layers), Stream10.runCollect).pipe(Effect23.map((chunk) => Array.from(chunk)));
 }
 function main(config) {
   const consumerType = process.stdout.isTTY ? "tui" : "headless";
-  return run({ config, consumer: consumerType }).pipe(Effect21.runPromise);
+  return run({ config, consumer: consumerType }).pipe(Effect23.runPromise);
 }
 
 // src/services/index.ts
@@ -6103,6 +6539,7 @@ export {
   ExecutionModeSchema,
   FerixParser,
   FileLoggerConfigSchema,
+  FileSystemGit,
   FileSystemGuardrails,
   FileSystemPlan,
   FileSystemProgress,
@@ -6110,6 +6547,8 @@ export {
   GeneratedTaskListSchema,
   GeneratedTaskSchema,
   GeneratedTaskStatusSchema,
+  Git,
+  GitError,
   GuardrailAddedEventSchema,
   GuardrailSchema,
   GuardrailSeveritySchema,
@@ -6139,6 +6578,7 @@ export {
   LoopStartedEventSchema,
   LoopStatusSchema,
   LoopSummarySchema,
+  MemoryGit,
   MemoryGuardrails,
   MemoryPlan,
   MemoryProgress,
@@ -6211,6 +6651,8 @@ export {
   ToolStartEventSchema,
   ToolUseEventSchema,
   ViewModeSchema,
+  WorktreeCreatedEventSchema,
+  WorktreeRemovedEventSchema,
   buildPrompt,
   collectEvents,
   createHeadlessConsumer,