ferix-code 0.0.2-beta.1 → 0.0.2-beta.11

package/dist/index.js

@@ -71,11 +71,12 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "ferix-code",
-  version: "0.0.2-beta.0",
+  version: "0.0.2-beta.11",
   description: "Composable RALPH loops for AI coding agents - v2 with Effect",
   type: "module",
   bin: {
-    "ferix-code": "./dist/index.js"
+    ferix: "dist/index.js",
+    "ferix-code": "dist/index.js"
   },
   files: [
     "dist"
@@ -85,13 +86,12 @@ 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: {
-    "@effect/platform": "^0.72.0",
-    "@effect/platform-node": "^0.66.0",
     commander: "^14.0.0",
-    effect: "^3.12.0",
+    effect: "^3.19.15",
     "human-id": "^4.1.3",
     picocolors: "^1.1.1"
   },
@@ -118,7 +118,7 @@ var package_default = {
 
 // src/program.ts
 init_esm_shims();
-import { Effect as Effect17, Stream as Stream10 } from "effect";
+import { Effect as Effect23, Stream as Stream10 } from "effect";
 
 // src/consumers/index.ts
 init_esm_shims();
@@ -126,7 +126,7 @@ init_esm_shims();
 // src/consumers/headless/consumer.ts
 init_esm_shims();
 import { Cause, Effect, Stream } from "effect";
-import pc9 from "picocolors";
+import pc10 from "picocolors";
 
 // src/consumers/headless/formatters/index.ts
 init_esm_shims();
@@ -307,6 +307,17 @@ var taskCompletedFormatter = {
 headlessFormatterRegistry.register(tasksDefinedFormatter);
 headlessFormatterRegistry.register(taskCompletedFormatter);
 
+// src/consumers/headless/formatters/worktree.ts
+init_esm_shims();
+import pc9 from "picocolors";
+var worktreeCreatedFormatter = {
+  tag: "WorktreeCreated",
+  format: (event) => pc9.cyan(
+    `[WORKTREE] Branch: ${event.branchName} | Path: ${event.worktreePath}`
+  )
+};
+headlessFormatterRegistry.register(worktreeCreatedFormatter);
+
 // src/consumers/headless/formatters/index.ts
 function formatEvent(event) {
   return headlessFormatterRegistry.format(event);
@@ -315,37 +326,37 @@ function formatEvent(event) {
 // src/consumers/headless/consumer.ts
 function formatErrorToLines(err, lines) {
   if (err instanceof Error) {
-    lines.push(pc9.red(`  - ${err.name}: ${err.message}`));
+    lines.push(pc10.red(`  - ${err.name}: ${err.message}`));
     if (err.stack) {
       lines.push("");
-      lines.push(pc9.yellow("Stack trace:"));
+      lines.push(pc10.yellow("Stack trace:"));
       for (const stackLine of err.stack.split("\n").slice(1)) {
-        lines.push(pc9.dim(`  ${stackLine.trim()}`));
+        lines.push(pc10.dim(`  ${stackLine.trim()}`));
       }
     }
   } else {
-    lines.push(pc9.red(`  - ${String(err)}`));
+    lines.push(pc10.red(`  - ${String(err)}`));
   }
 }
 function formatCauseVerbose(cause) {
   const lines = [];
-  const separator2 = pc9.red(
+  const separator2 = pc10.red(
     "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"
   );
   const causeType = Cause.isFailure(cause) ? "Failure" : "Other";
   lines.push("");
   lines.push(separator2);
-  lines.push(pc9.red("                           ERROR"));
+  lines.push(pc10.red("                           ERROR"));
   lines.push(separator2);
   lines.push("");
-  lines.push(`${pc9.yellow("Type:")} ${causeType}`);
+  lines.push(`${pc10.yellow("Type:")} ${causeType}`);
   lines.push("");
-  lines.push(pc9.yellow("Details:"));
+  lines.push(pc10.yellow("Details:"));
   lines.push(Cause.pretty(cause));
   const failures = Cause.failures(cause);
   if (failures.length > 0) {
     lines.push("");
-    lines.push(pc9.yellow("Failures:"));
+    lines.push(pc10.yellow("Failures:"));
     for (const failure of failures) {
       formatErrorToLines(failure, lines);
     }
@@ -353,7 +364,7 @@ function formatCauseVerbose(cause) {
   const defects = Cause.defects(cause);
   if (defects.length > 0) {
     lines.push("");
-    lines.push(pc9.yellow("Defects (unexpected errors):"));
+    lines.push(pc10.yellow("Defects (unexpected errors):"));
     for (const defect of defects) {
       formatErrorToLines(defect, lines);
     }
@@ -534,40 +545,40 @@ init_esm_shims();
 
 // src/consumers/tui/tags/primitives.ts
 init_esm_shims();
-import pc11 from "picocolors";
+import pc12 from "picocolors";
 
 // src/consumers/tui/render/primitives.ts
 init_esm_shims();
-import pc10 from "picocolors";
+import pc11 from "picocolors";
 var ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
 var colors = {
-  brand: pc10.magenta,
-  success: pc10.green,
-  warning: pc10.yellow,
-  error: pc10.red,
-  info: pc10.cyan,
-  muted: pc10.dim,
-  highlight: pc10.bold,
-  brightWhite: (s) => pc10.bold(pc10.white(s)),
-  brightMagenta: (s) => pc10.bold(pc10.magenta(s)),
-  brightCyan: (s) => pc10.bold(pc10.cyan(s)),
-  brightGreen: (s) => pc10.bold(pc10.green(s)),
-  brightYellow: (s) => pc10.bold(pc10.yellow(s)),
-  brightRed: (s) => pc10.bold(pc10.red(s))
+  brand: pc11.magenta,
+  success: pc11.green,
+  warning: pc11.yellow,
+  error: pc11.red,
+  info: pc11.cyan,
+  muted: pc11.dim,
+  highlight: pc11.bold,
+  brightWhite: (s) => pc11.bold(pc11.white(s)),
+  brightMagenta: (s) => pc11.bold(pc11.magenta(s)),
+  brightCyan: (s) => pc11.bold(pc11.cyan(s)),
+  brightGreen: (s) => pc11.bold(pc11.green(s)),
+  brightYellow: (s) => pc11.bold(pc11.yellow(s)),
+  brightRed: (s) => pc11.bold(pc11.red(s))
 };
 var toolColors = {
-  Read: pc10.cyan,
-  Edit: pc10.yellow,
-  Write: pc10.green,
-  Bash: pc10.magenta,
-  Glob: pc10.blue,
-  Grep: pc10.blue,
+  Read: pc11.cyan,
+  Edit: pc11.yellow,
+  Write: pc11.green,
+  Bash: pc11.magenta,
+  Glob: pc11.blue,
+  Grep: pc11.blue,
   Task: colors.brightWhite,
-  WebFetch: pc10.cyan,
-  WebSearch: pc10.blue
+  WebFetch: pc11.cyan,
+  WebSearch: pc11.blue
 };
 function getToolColor(tool) {
-  return toolColors[tool] || pc10.white;
+  return toolColors[tool] || pc11.white;
 }
 var symbols = {
   diamond: "\u25C6",
@@ -594,24 +605,24 @@ var box = {
 };
 function topBorder(width) {
   const repeatCount = Math.max(0, width - 2);
-  return pc10.cyan(
+  return pc11.cyan(
     `${box.topLeft}${box.horizontal.repeat(repeatCount)}${box.topRight}`
   );
 }
 function separator(width) {
   const repeatCount = Math.max(0, width - 2);
-  return pc10.cyan(
+  return pc11.cyan(
     `${box.teeRight}${box.horizontal.repeat(repeatCount)}${box.teeLeft}`
   );
 }
 function borderedLine(content, width) {
   const stripped = stripAnsi(content);
   const padding = Math.max(0, width - stripped.length - 4);
-  return `${pc10.cyan(box.vertical)} ${content}${" ".repeat(padding)} ${pc10.cyan(box.vertical)}`;
+  return `${pc11.cyan(box.vertical)} ${content}${" ".repeat(padding)} ${pc11.cyan(box.vertical)}`;
 }
 function emptyBorderedLine(width) {
   const repeatCount = Math.max(0, width - 2);
-  return `${pc10.cyan(box.vertical)}${" ".repeat(repeatCount)}${pc10.cyan(box.vertical)}`;
+  return `${pc11.cyan(box.vertical)}${" ".repeat(repeatCount)}${pc11.cyan(box.vertical)}`;
 }
 function stripAnsi(str) {
   return str.replace(ANSI_PATTERN, "");
@@ -708,31 +719,31 @@ function taskListHeader(width) {
   }
   const label = ` ${symbols.diamond} TASKS ${symbols.diamond} `;
   const sideLen = Math.max(1, Math.floor((innerWidth - label.length) / 2));
-  return `${pc11.cyan("\u250C")}${pc11.cyan(box.singleHorizontal.repeat(sideLen))}${colors.brand(label)}${pc11.cyan(box.singleHorizontal.repeat(sideLen))}`;
+  return `${pc12.cyan("\u250C")}${pc12.cyan(box.singleHorizontal.repeat(sideLen))}${colors.brand(label)}${pc12.cyan(box.singleHorizontal.repeat(sideLen))}`;
 }
 function taskListFooter() {
-  return pc11.cyan("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+  return pc12.cyan("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
 }
 function taskLine(id, description) {
-  return `${pc11.cyan("\u2502")} ${colors.brightMagenta(`[${id}]`)} ${description}`;
+  return `${pc12.cyan("\u2502")} ${colors.brightMagenta(`[${id}]`)} ${description}`;
 }
 function taskDone(id) {
   return `${colors.success(symbols.checkmark)} ${colors.muted(`Task ${id} complete`)}`;
 }
 function phasesHeader(taskId) {
-  return `${pc11.cyan("\u2502")}   ${colors.muted(`Phases for task ${taskId}:`)}`;
+  return `${pc12.cyan("\u2502")}   ${colors.muted(`Phases for task ${taskId}:`)}`;
 }
 function phaseLine(id, description) {
-  return `${pc11.cyan("\u2502")}   ${colors.muted(symbols.treeMiddle)} ${colors.muted(symbols.bulletEmpty)} ${colors.muted(`[${id}]`)} ${description}`;
+  return `${pc12.cyan("\u2502")}   ${colors.muted(symbols.treeMiddle)} ${colors.muted(symbols.bulletEmpty)} ${colors.muted(`[${id}]`)} ${description}`;
 }
 function phaseStart(id) {
-  return `${pc11.cyan("\u2502")}   ${colors.warning(symbols.bulletFilled)} ${colors.muted(`Phase ${id} started`)}`;
+  return `${pc12.cyan("\u2502")}   ${colors.warning(symbols.bulletFilled)} ${colors.muted(`Phase ${id} started`)}`;
 }
 function phaseDone(id) {
-  return `${pc11.cyan("\u2502")}   ${colors.success(symbols.checkmark)} ${colors.muted(`Phase ${id} complete`)}`;
+  return `${pc12.cyan("\u2502")}   ${colors.success(symbols.checkmark)} ${colors.muted(`Phase ${id} complete`)}`;
 }
 function phaseFailed(id, reason) {
-  return `${pc11.cyan("\u2502")}   ${colors.error(symbols.cross)} ${colors.muted(`Phase ${id} failed:`)} ${colors.error(reason)}`;
+  return `${pc12.cyan("\u2502")}   ${colors.error(symbols.cross)} ${colors.muted(`Phase ${id} failed:`)} ${colors.error(reason)}`;
 }
 function criterionPassed(id) {
   return `${colors.success(symbols.checkmark)} ${colors.muted(`Criterion ${id} passed`)}`;
@@ -768,10 +779,10 @@ function reviewFailedBanner(width) {
   );
 }
 function criteriaHeader(taskId) {
-  return `${pc11.cyan("\u2502")}   ${colors.muted(`Success criteria for task ${taskId}:`)}`;
+  return `${pc12.cyan("\u2502")}   ${colors.muted(`Success criteria for task ${taskId}:`)}`;
 }
 function criterionLine(id, description) {
-  return `${pc11.cyan("\u2502")}   ${colors.muted(symbols.treeMiddle)} ${colors.muted(symbols.bulletEmpty)} ${colors.muted(`[${id}]`)} ${description}`;
+  return `${pc12.cyan("\u2502")}   ${colors.muted(symbols.treeMiddle)} ${colors.muted(symbols.bulletEmpty)} ${colors.muted(`[${id}]`)} ${description}`;
 }
 
 // src/consumers/tui/tags/handlers/completion.ts
@@ -1044,11 +1055,11 @@ init_esm_shims();
 
 // src/consumers/tui/tools/registry.ts
 init_esm_shims();
-import pc12 from "picocolors";
-var brightWhite = (s) => pc12.bold(pc12.white(s));
+import pc13 from "picocolors";
+var brightWhite = (s) => pc13.bold(pc13.white(s));
 function createToolDisplayRegistry() {
   const configs = /* @__PURE__ */ new Map();
-  const defaultColor = pc12.white;
+  const defaultColor = pc13.white;
   return {
     register(config) {
       configs.set(config.tool, config);
@@ -1085,32 +1096,32 @@ var toolDisplayRegistry = createToolDisplayRegistry();
 toolDisplayRegistry.register({
   tool: "Read",
   inputKey: "file_path",
-  color: pc12.cyan
+  color: pc13.cyan
 });
 toolDisplayRegistry.register({
   tool: "Edit",
   inputKey: "file_path",
-  color: pc12.yellow
+  color: pc13.yellow
 });
 toolDisplayRegistry.register({
   tool: "Write",
   inputKey: "file_path",
-  color: pc12.green
+  color: pc13.green
 });
 toolDisplayRegistry.register({
   tool: "Bash",
   inputKey: "command",
-  color: pc12.magenta
+  color: pc13.magenta
 });
 toolDisplayRegistry.register({
   tool: "Glob",
   inputKey: "pattern",
-  color: pc12.blue
+  color: pc13.blue
 });
 toolDisplayRegistry.register({
   tool: "Grep",
   inputKey: "pattern",
-  color: pc12.blue
+  color: pc13.blue
 });
 toolDisplayRegistry.register({
   tool: "Task",
@@ -1120,12 +1131,12 @@ toolDisplayRegistry.register({
 toolDisplayRegistry.register({
   tool: "WebFetch",
   inputKey: "url",
-  color: pc12.cyan
+  color: pc13.cyan
 });
 toolDisplayRegistry.register({
   tool: "WebSearch",
   inputKey: "query",
-  color: pc12.blue
+  color: pc13.blue
 });
 
 // src/consumers/tui/tools/index.ts
@@ -1305,6 +1316,34 @@ stateReducerRegistry.register(loopStartedReducer);
 stateReducerRegistry.register(loopCompletedReducer);
 stateReducerRegistry.register(loopFailedReducer);
 
+// src/consumers/tui/reducers/progress.ts
+init_esm_shims();
+var learningRecordedReducer = {
+  tag: "LearningRecorded",
+  reduce: (state, event) => {
+    const category = event.category ? `[${event.category}] ` : "";
+    const line = `Learning: ${category}${event.content}`;
+    return appendOutput(state, `${line}
+`);
+  }
+};
+var guardrailAddedReducer = {
+  tag: "GuardrailAdded",
+  reduce: (state, event) => {
+    const severityIcon = event.severity === "critical" ? "[critical]" : "[warn]";
+    const line = `${severityIcon} Guardrail: ${event.pattern}`;
+    return appendOutput(state, `${line}
+`);
+  }
+};
+var progressUpdatedReducer = {
+  tag: "ProgressUpdated",
+  reduce: (state) => state
+};
+stateReducerRegistry.register(learningRecordedReducer);
+stateReducerRegistry.register(guardrailAddedReducer);
+stateReducerRegistry.register(progressUpdatedReducer);
+
 // src/consumers/tui/reducers/tasks.ts
 init_esm_shims();
 var tasksDefinedReducer = {
@@ -1385,6 +1424,21 @@ stateReducerRegistry.register(criterionPassedReducer);
 stateReducerRegistry.register(criterionFailedReducer);
 stateReducerRegistry.register(taskCompletedReducer);
 
+// src/consumers/tui/reducers/worktree.ts
+init_esm_shims();
+var worktreeCreatedReducer = {
+  tag: "WorktreeCreated",
+  reduce: (state, event) => appendOutput(
+    state,
+    `
+Worktree created
+   Branch: ${event.branchName}
+   Path: ${event.worktreePath}
+`
+  )
+};
+stateReducerRegistry.register(worktreeCreatedReducer);
+
 // src/consumers/tui/reducers/index.ts
 function reduce(state, event) {
   return stateReducerRegistry.reduce(state, event);
@@ -1463,7 +1517,7 @@ init_esm_shims();
 
 // src/consumers/tui/render/footer.ts
 init_esm_shims();
-import pc13 from "picocolors";
+import pc14 from "picocolors";
 function hint(key, description) {
   return `${colors.brand(symbols.diamond)} ${colors.brightWhite(key)} ${colors.muted(description)}`;
 }
@@ -1512,7 +1566,7 @@ function renderFooter(state, width, outputHeight) {
   const content = hints.join("  ");
   const stripped = stripAnsi(content);
   const padding = Math.max(0, width - stripped.length - 4);
-  return `${pc13.cyan(box.bottomLeft)}${pc13.cyan(box.horizontal)} ${content}${pc13.cyan(box.horizontal.repeat(Math.max(1, padding)))}${pc13.cyan(box.bottomRight)}`;
+  return `${pc14.cyan(box.bottomLeft)}${pc14.cyan(box.horizontal)} ${content}${pc14.cyan(box.horizontal.repeat(Math.max(1, padding)))}${pc14.cyan(box.bottomRight)}`;
 }
 
 // src/consumers/tui/render/status-bar.ts
@@ -1591,7 +1645,7 @@ init_esm_shims();
 
 // src/consumers/tui/render/task-detail.ts
 init_esm_shims();
-import pc14 from "picocolors";
+import pc15 from "picocolors";
 function renderPhase(phase, isLast, width) {
   const lines = [];
   const prefix = isLast ? symbols.treeLast : symbols.treeMiddle;
@@ -1656,7 +1710,7 @@ function renderEmptyState(height, width) {
   return lines;
 }
 function renderTaskHeader(task, width, innerWidth) {
-  const sepLine = pc14.cyan(box.horizontal.repeat(innerWidth));
+  const sepLine = pc15.cyan(box.horizontal.repeat(innerWidth));
   return [
     emptyBorderedLine(width),
     borderedLine(
@@ -1730,7 +1784,7 @@ function renderGitSection(state, width, innerWidth) {
     return [];
   }
   const lines = [];
-  const sepLine = pc14.cyan(box.horizontal.repeat(innerWidth));
+  const sepLine = pc15.cyan(box.horizontal.repeat(innerWidth));
   const pushStatus = state.gitPushed ? colors.success(symbols.checkmark) : colors.muted("Not pushed");
   lines.push(borderedLine(sepLine, width));
   lines.push(
@@ -1809,7 +1863,7 @@ init_esm_shims();
 
 // src/consumers/tui/render/tasks-list.ts
 init_esm_shims();
-import pc15 from "picocolors";
+import pc16 from "picocolors";
 function renderTaskLine(task, isSelected, width) {
   const innerWidth = width - 4;
   const parts = [];
@@ -1873,7 +1927,7 @@ function renderTasksListView(state, height, width) {
   lines.push(emptyBorderedLine(width));
   const headerText = `${colors.brand(symbols.diamond)} ${colors.brightWhite("TASKS")} ${colors.brand(symbols.diamond)}`;
   lines.push(borderedLine(headerText, width));
-  const sepLine = pc15.cyan(box.horizontal.repeat(innerWidth));
+  const sepLine = pc16.cyan(box.horizontal.repeat(innerWidth));
   lines.push(borderedLine(sepLine, width));
   lines.push(emptyBorderedLine(width));
   const gitLines = renderGitInfo(state, width);
@@ -2189,6 +2243,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}`);
@@ -2248,6 +2303,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* () {
@@ -2299,6 +2365,7 @@ ${errorText}
           })
         );
       }
+      yield* Fiber.interrupt(clockFiber);
       unsubscribeResize();
       cleanup();
     })
@@ -2307,23 +2374,15 @@ ${errorText}
 
 // src/layers/index.ts
 init_esm_shims();
-import { Layer as Layer8 } from "effect";
-
-// src/layers/llm/claude-cli.ts
-init_esm_shims();
-import { spawn } from "child_process";
-import { Effect as Effect5, Layer, Stream as Stream5 } from "effect";
-
-// src/services/llm.ts
-init_esm_shims();
-import { Context } from "effect";
-var LLM = class extends Context.Tag("@ferix/LLM")() {
-};
+import { Layer as Layer14 } from "effect";
 
-// src/layers/llm/stream.ts
+// src/layers/git/file-system.ts
 init_esm_shims();
-import { createInterface } from "readline";
-import { Effect as Effect4, Stream as Stream4 } from "effect";
+import { exec } from "child_process";
+import { access, copyFile, mkdir, rm } from "fs/promises";
+import { dirname, join } from "path";
+import { promisify } from "util";
+import { Effect as Effect4, Layer } from "effect";
 
 // src/domain/errors.ts
 init_esm_shims();
@@ -2336,288 +2395,369 @@ var PlanStoreError = class extends Data.TaggedError("PlanStoreError") {
 };
 var SessionStoreError = class extends Data.TaggedError("SessionStoreError") {
 };
+var ProgressStoreError = class extends Data.TaggedError("ProgressStoreError") {
+};
+var GuardrailsStoreError = class extends Data.TaggedError(
+  "GuardrailsStoreError"
+) {
+};
 var OrchestratorError = class extends Data.TaggedError("OrchestratorError") {
 };
+var GitError = class extends Data.TaggedError("GitError") {
+};
 
-// src/layers/llm/parsers.ts
+// src/services/git.ts
 init_esm_shims();
-function parseJsonLine(line) {
-  if (!line.startsWith("{")) {
-    return null;
-  }
-  try {
-    return JSON.parse(line);
-  } catch {
-    return null;
-  }
-}
-function isTextContent(json) {
-  return typeof json === "object" && json !== null && "type" in json && typeof json.type === "string";
-}
-function isToolUse(json) {
-  return typeof json === "object" && json !== null && "type" in json && "content_block" in json;
-}
-function extractText(json) {
-  if (!isTextContent(json)) {
-    return null;
-  }
-  if (json.type === "content_block_delta") {
-    const delta = json;
-    if (delta.delta?.type === "text_delta" && delta.delta.text) {
-      return delta.delta.text;
-    }
-  }
-  if (json.type === "assistant" && json.message?.content) {
-    for (const block of json.message.content) {
-      if (block.type === "text" && block.text) {
-        return block.text;
-      }
+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
+      });
     }
-  }
-  return null;
-}
-function isToolInputDelta(json) {
-  return typeof json === "object" && json !== null && "type" in json && json.type === "content_block_delta" && "delta" in json;
+  });
 }
-function extractToolInfo(json) {
-  if (typeof json === "object" && json !== null && "type" in json && json.type === "content_block_stop") {
-    return {
-      type: "end",
-      name: "unknown"
-    };
-  }
-  if (!isToolUse(json)) {
-    if (isToolInputDelta(json) && json.delta?.type === "input_json_delta" && json.delta.partial_json) {
-      return {
-        type: "input_delta",
-        name: "",
-        partialJson: json.delta.partial_json
-      };
+function directoryExists(dirPath) {
+  return Effect4.tryPromise({
+    try: async () => {
+      await access(dirPath);
+      return true;
+    },
+    catch: () => new Error("Directory does not exist")
+  }).pipe(Effect4.orElseSucceed(() => false));
+}
+function copyUntrackedFiles(worktreeDir) {
+  return Effect4.gen(function* () {
+    const untrackedOutput = yield* gitExec(
+      "git ls-files --others --exclude-standard"
+    ).pipe(Effect4.catchAll(() => Effect4.succeed("")));
+    const untrackedFiles = untrackedOutput.split("\n").filter((f) => f.length > 0).filter((f) => !f.startsWith(".ferix/"));
+    for (const file of untrackedFiles) {
+      const srcPath = join(process.cwd(), file);
+      const destPath = join(worktreeDir, file);
+      yield* Effect4.tryPromise({
+        try: async () => {
+          await mkdir(dirname(destPath), { recursive: true });
+          await copyFile(srcPath, destPath);
+        },
+        catch: () => new GitError({
+          message: `Failed to copy untracked file: ${file}`,
+          operation: "createWorktree"
+        })
+      }).pipe(Effect4.catchAll(() => Effect4.succeed(void 0)));
     }
-    return null;
-  }
-  if (json.type === "content_block_start" && json.content_block?.type === "tool_use") {
-    return {
-      type: "start",
-      name: json.content_block.name || "unknown"
-    };
-  }
-  return null;
-}
-function safeParseJson(jsonStr) {
-  try {
-    return JSON.parse(jsonStr);
-  } catch {
-    return null;
-  }
-}
-function unwrapStreamEvent(json) {
-  if (typeof json === "object" && json !== null && "type" in json && json.type === "stream_event" && "event" in json) {
-    return json.event;
-  }
-  return json;
+  });
 }
-
-// src/layers/llm/stream.ts
-function handleToolEvent(toolInfo, toolState, emit) {
-  if (toolInfo.type === "start") {
-    toolState.currentTool = toolInfo.name;
-    toolState.inputChunks.length = 0;
-    emit.single({ _tag: "ToolStart", tool: toolInfo.name });
-    return;
-  }
-  if (toolInfo.type === "input_delta" && toolInfo.partialJson) {
-    toolState.inputChunks.push(toolInfo.partialJson);
-    return;
-  }
-  if (toolInfo.type === "end" && toolState.currentTool) {
-    const inputJson = toolState.inputChunks.join("");
-    const input = safeParseJson(inputJson);
-    if (input !== null) {
-      emit.single({ _tag: "ToolUse", tool: toolState.currentTool, input });
+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;
     }
-    emit.single({ _tag: "ToolEnd", tool: toolState.currentTool });
-    toolState.currentTool = "";
-    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 Stream4.async((emit) => {
-    const outputChunks = [];
-    const toolState = { currentTool: "", inputChunks: [] };
-    const stdout = child.stdout;
-    if (!stdout) {
-      emit.fail(
-        new LLMError({ message: "Failed to get stdout from child process" })
+    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
+        })
+      )
+    );
+    yield* copyUntrackedFiles(worktreeDir);
+    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"
+        })
       );
-      return Effect4.void;
     }
-    const rl = createInterface({
-      input: stdout,
-      crlfDelay: Number.POSITIVE_INFINITY
-    });
-    rl.on("line", (line) => {
-      const json = parseJsonLine(line);
-      if (json) {
-        processJsonLine(json, outputChunks, toolState, emit);
-      }
-    });
-    child.stderr?.on("data", (data) => {
-      const text = data.toString().trim();
-      if (text) {
-        emit.single({ _tag: "Text", text: `[stderr] ${text}` });
-      }
-    });
-    child.on("close", (exitCode) => {
-      if (exitCode !== 0) {
-        emit.fail(
-          new LLMError({
-            message: `Claude CLI exited with code ${exitCode}`
+    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
           })
-        );
-      } else {
-        const fullOutput = outputChunks.join("");
-        emit.single({ _tag: "Done", output: fullOutput });
-        emit.end();
-      }
-    });
-    child.on("error", (error) => {
-      emit.fail(
-        new LLMError({
-          message: error.message,
+        )
+      );
+      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"
+        })
       );
-    });
-    return Effect4.sync(() => {
-      child.kill("SIGTERM");
-    });
-  });
-}
-
-// src/layers/llm/claude-cli.ts
-var make = {
-  execute: (prompt) => {
-    return Stream5.unwrap(
-      Effect5.sync(() => {
-        const child = spawn(
-          "claude",
-          [
-            "--permission-mode",
-            "acceptEdits",
-            "--output-format",
-            "stream-json",
-            "--verbose",
-            "--include-partial-messages",
-            "-p",
-            prompt
-          ],
-          {
-            stdio: ["inherit", "pipe", "pipe"],
-            env: {
-              ...process.env,
-              FORCE_COLOR: "1"
-            }
-          }
-        );
-        return createEventStream(child);
-      })
+    }
+    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(LLM, make);
-var ClaudeCLI = {
+var Live = Layer.succeed(Git, make);
+var FileSystemGit = {
   Live
 };
 
-// src/layers/llm/mock.ts
-init_esm_shims();
-import { Effect as Effect6, Layer as Layer2, Schema as S2, Stream as Stream6 } from "effect";
-
-// src/domain/schemas/llm.ts
+// src/layers/git/memory.ts
 init_esm_shims();
-import { Schema as S } from "effect";
-var TextEventSchema = S.TaggedStruct("Text", {
-  text: S.String
-});
-var ToolStartEventSchema = S.TaggedStruct("ToolStart", {
-  tool: S.String
-});
-var ToolUseEventSchema = S.TaggedStruct("ToolUse", {
-  tool: S.String,
-  input: S.Unknown
-});
-var ToolEndEventSchema = S.TaggedStruct("ToolEnd", {
-  tool: S.String
-});
-var DoneEventSchema = S.TaggedStruct("Done", {
-  output: S.String
-});
-var LLMEventSchema = S.Union(
-  TextEventSchema,
-  ToolStartEventSchema,
-  ToolUseEventSchema,
-  ToolEndEventSchema,
-  DoneEventSchema
-);
-var decodeLLMEvent = S.decodeUnknown(LLMEventSchema);
-
-// src/layers/llm/mock.ts
-var MockLLMConfigSchema = S2.Struct({
-  events: S2.Array(LLMEventSchema),
-  delayMs: S2.optional(S2.Number)
-});
-function createMockLLM(config) {
+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 {
-    execute: (_prompt) => {
-      const baseStream = Stream6.fromIterable(config.events);
-      if (config.delayMs !== void 0 && config.delayMs > 0) {
-        const delay = config.delayMs;
-        return baseStream.pipe(Stream6.tap(() => Effect6.sleep(delay)));
+    createWorktree: (sessionId, _baseBranch) => Effect5.gen(function* () {
+      const state = yield* Ref3.get(stateRef);
+      const existing = state.get(sessionId);
+      if (existing) {
+        return existing.path;
       }
-      return baseStream;
-    }
+      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
   };
 }
-var defaultMockEvents = [
-  { _tag: "Text", text: "Processing task...\n" },
-  { _tag: "ToolStart", tool: "Read" },
-  { _tag: "ToolEnd", tool: "Read" },
-  { _tag: "Text", text: "Task completed successfully.\n" },
-  {
-    _tag: "Done",
-    output: "Processing task...\nTask completed successfully.\n"
-  }
-];
-var defaultMock = createMockLLM({ events: defaultMockEvents });
-var Live2 = Layer2.succeed(LLM, defaultMock);
-function layer(config) {
-  return Layer2.succeed(LLM, createMockLLM(config));
+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 Mock = {
+var Live2 = layer();
+var MemoryGit = {
   Live: Live2,
-  layer,
-  createMockLLM
+  layer
 };
 
-// src/layers/plan/file-system.ts
+// src/layers/guardrails/file-system.ts
 init_esm_shims();
-import { access, mkdir, readdir, readFile, writeFile } from "fs/promises";
-import { join } from "path";
-import { Effect as Effect7, Layer as Layer3 } from "effect";
+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();
@@ -2627,55 +2767,55 @@ init_esm_shims();
 
 // src/domain/schemas/config.ts
 init_esm_shims();
-import { Schema as S3 } from "effect";
-var PhasePromptOverridesSchema = S3.Struct({
-  breakdown: S3.optional(S3.String),
-  planning: S3.optional(S3.String),
-  execution: S3.optional(S3.String),
-  check: S3.optional(S3.String),
-  verify: S3.optional(S3.String),
-  review: S3.optional(S3.String),
-  completion: S3.optional(S3.String)
-});
-var PromptConfigSchema = S3.Struct({
-  systemPrompt: S3.optional(S3.String),
-  phases: S3.optional(PhasePromptOverridesSchema),
-  additionalContext: S3.optional(S3.String)
-});
-var LoopConfigSchema = S3.Struct({
-  task: S3.String,
-  maxIterations: S3.Number,
-  verifyCommands: S3.Array(S3.String),
-  sessionId: S3.optional(S3.String),
-  branch: S3.optional(S3.String),
-  push: S3.optional(S3.Boolean),
-  pr: S3.optional(S3.Boolean),
-  verbose: S3.optional(S3.Boolean),
-  prompts: S3.optional(PromptConfigSchema)
-});
-var LoopSummarySchema = S3.Struct({
-  iterations: S3.Number,
-  success: S3.Boolean,
-  sessionId: S3.String,
-  completedTasks: S3.Array(S3.String),
-  durationMs: S3.Number
-});
-var LoopErrorSchema = S3.Struct({
-  message: S3.String,
-  phase: S3.String,
-  iteration: S3.optional(S3.Number)
-});
-var decodeLoopConfig = S3.decodeUnknown(LoopConfigSchema);
+import { Schema as S } from "effect";
+var PhasePromptOverridesSchema = S.Struct({
+  breakdown: S.optional(S.String),
+  planning: S.optional(S.String),
+  execution: S.optional(S.String),
+  check: S.optional(S.String),
+  verify: S.optional(S.String),
+  review: S.optional(S.String),
+  completion: S.optional(S.String)
+});
+var PromptConfigSchema = S.Struct({
+  systemPrompt: S.optional(S.String),
+  phases: S.optional(PhasePromptOverridesSchema),
+  additionalContext: S.optional(S.String)
+});
+var LoopConfigSchema = S.Struct({
+  task: S.String,
+  maxIterations: S.Number,
+  verifyCommands: S.Array(S.String),
+  sessionId: S.optional(S.String),
+  branch: S.optional(S.String),
+  push: S.optional(S.Boolean),
+  pr: S.optional(S.Boolean),
+  verbose: S.optional(S.Boolean),
+  prompts: S.optional(PromptConfigSchema)
+});
+var LoopSummarySchema = S.Struct({
+  iterations: S.Number,
+  success: S.Boolean,
+  sessionId: S.String,
+  completedTasks: S.Array(S.String),
+  durationMs: S.Number
+});
+var LoopErrorSchema = S.Struct({
+  message: S.String,
+  phase: S.String,
+  iteration: S.optional(S.Number)
+});
+var decodeLoopConfig = S.decodeUnknown(LoopConfigSchema);
 
 // src/domain/schemas/events.ts
 init_esm_shims();
-import { Schema as S6 } from "effect";
+import { Schema as S4 } from "effect";
 
 // src/domain/schemas/plan.ts
 init_esm_shims();
-import { Brand, Schema as S4 } from "effect";
+import { Brand, Schema as S2 } from "effect";
 var PlanId = Brand.nominal();
-var TaskStatusSchema = S4.Literal(
+var TaskStatusSchema = S2.Literal(
   "pending",
   "planning",
   "in_progress",
@@ -2683,114 +2823,114 @@ var TaskStatusSchema = S4.Literal(
   "failed",
   "skipped"
 );
-var PhaseStatusSchema = S4.Literal(
+var PhaseStatusSchema = S2.Literal(
   "pending",
   "in_progress",
   "done",
   "failed"
 );
-var CriterionStatusSchema = S4.Literal("pending", "passed", "failed");
-var PhaseSchema = S4.Struct({
-  id: S4.String,
-  description: S4.String,
+var CriterionStatusSchema = S2.Literal("pending", "passed", "failed");
+var PhaseSchema = S2.Struct({
+  id: S2.String,
+  description: S2.String,
   status: PhaseStatusSchema
 });
-var CriterionSchema = S4.Struct({
-  id: S4.String,
-  description: S4.String,
+var CriterionSchema = S2.Struct({
+  id: S2.String,
+  description: S2.String,
   status: CriterionStatusSchema,
-  failureReason: S4.optional(S4.String)
+  failureReason: S2.optional(S2.String)
 });
-var TaskSchema = S4.Struct({
-  id: S4.String,
-  title: S4.String,
-  description: S4.String,
+var TaskSchema = S2.Struct({
+  id: S2.String,
+  title: S2.String,
+  description: S2.String,
   status: TaskStatusSchema,
-  phases: S4.Array(PhaseSchema),
-  criteria: S4.Array(CriterionSchema),
-  filesToModify: S4.Array(S4.String),
-  attempts: S4.Number,
-  completionNotes: S4.optional(S4.String)
-});
-var PlanDataSchema = S4.Struct({
-  sessionId: S4.String,
-  createdAt: S4.String,
-  originalTask: S4.String,
-  context: S4.optional(S4.String),
-  tasks: S4.Array(TaskSchema)
-});
-var PlanSchema = S4.Struct({
-  id: S4.String,
-  sessionId: S4.String,
-  createdAt: S4.String,
-  originalTask: S4.String,
-  context: S4.optional(S4.String),
-  tasks: S4.Array(TaskSchema)
-});
-var decodePlan = S4.decodeUnknown(PlanSchema);
-var decodePlanData = S4.decodeUnknown(PlanDataSchema);
+  phases: S2.Array(PhaseSchema),
+  criteria: S2.Array(CriterionSchema),
+  filesToModify: S2.Array(S2.String),
+  attempts: S2.Number,
+  completionNotes: S2.optional(S2.String)
+});
+var PlanDataSchema = S2.Struct({
+  sessionId: S2.String,
+  createdAt: S2.String,
+  originalTask: S2.String,
+  context: S2.optional(S2.String),
+  tasks: S2.Array(TaskSchema)
+});
+var PlanSchema = S2.Struct({
+  id: S2.String,
+  sessionId: S2.String,
+  createdAt: S2.String,
+  originalTask: S2.String,
+  context: S2.optional(S2.String),
+  tasks: S2.Array(TaskSchema)
+});
+var decodePlan = S2.decodeUnknown(PlanSchema);
+var decodePlanData = S2.decodeUnknown(PlanDataSchema);
 
 // src/domain/schemas/shared.ts
 init_esm_shims();
-import { Schema as S5 } from "effect";
-var TaskBasicInfoSchema = S5.Struct({
-  id: S5.String,
-  title: S5.String,
-  description: S5.String
+import { Schema as S3 } from "effect";
+var TaskBasicInfoSchema = S3.Struct({
+  id: S3.String,
+  title: S3.String,
+  description: S3.String
 });
-var PhaseBasicInfoSchema = S5.Struct({
-  id: S5.String,
-  description: S5.String
+var PhaseBasicInfoSchema = S3.Struct({
+  id: S3.String,
+  description: S3.String
 });
-var CriterionBasicInfoSchema = S5.Struct({
-  id: S5.String,
-  description: S5.String
+var CriterionBasicInfoSchema = S3.Struct({
+  id: S3.String,
+  description: S3.String
 });
-var TasksDefinedDataSchema = S5.Struct({
-  tasks: S5.Array(TaskBasicInfoSchema)
+var TasksDefinedDataSchema = S3.Struct({
+  tasks: S3.Array(TaskBasicInfoSchema)
 });
-var PhasesDefinedDataSchema = S5.Struct({
-  taskId: S5.String,
-  phases: S5.Array(PhaseBasicInfoSchema)
+var PhasesDefinedDataSchema = S3.Struct({
+  taskId: S3.String,
+  phases: S3.Array(PhaseBasicInfoSchema)
 });
-var CriteriaDefinedDataSchema = S5.Struct({
-  taskId: S5.String,
-  criteria: S5.Array(CriterionBasicInfoSchema)
+var CriteriaDefinedDataSchema = S3.Struct({
+  taskId: S3.String,
+  criteria: S3.Array(CriterionBasicInfoSchema)
 });
-var PhaseIdDataSchema = S5.Struct({
-  phaseId: S5.String
+var PhaseIdDataSchema = S3.Struct({
+  phaseId: S3.String
 });
-var PhaseFailedDataSchema = S5.Struct({
-  phaseId: S5.String,
-  reason: S5.String
+var PhaseFailedDataSchema = S3.Struct({
+  phaseId: S3.String,
+  reason: S3.String
 });
-var CriterionIdDataSchema = S5.Struct({
-  criterionId: S5.String
+var CriterionIdDataSchema = S3.Struct({
+  criterionId: S3.String
 });
-var CriterionFailedDataSchema = S5.Struct({
-  criterionId: S5.String,
-  reason: S5.String
+var CriterionFailedDataSchema = S3.Struct({
+  criterionId: S3.String,
+  reason: S3.String
 });
-var ReviewCompleteDataSchema = S5.Struct({
-  changesMade: S5.Boolean
+var ReviewCompleteDataSchema = S3.Struct({
+  changesMade: S3.Boolean
 });
-var TaskCompleteSignalDataSchema = S5.Struct({
-  taskId: S5.String,
-  summary: S5.String,
-  filesModified: S5.Array(S5.String),
-  filesCreated: S5.Array(S5.String)
+var TaskCompleteSignalDataSchema = S3.Struct({
+  taskId: S3.String,
+  summary: S3.String,
+  filesModified: S3.Array(S3.String),
+  filesCreated: S3.Array(S3.String)
 });
-var TaskCompleteDataSchema = S5.Struct({
-  taskId: S5.String,
-  summary: S5.String
+var TaskCompleteDataSchema = S3.Struct({
+  taskId: S3.String,
+  summary: S3.String
 });
 
 // src/domain/schemas/events.ts
-var taggedEvent = (tag, fields) => S6.TaggedStruct(tag, fields);
-var taggedFromData = (tag, dataSchema, extraFields = {}) => S6.TaggedStruct(tag, { ...dataSchema.fields, ...extraFields });
+var taggedEvent = (tag, fields) => S4.TaggedStruct(tag, fields);
+var taggedFromData = (tag, dataSchema, extraFields = {}) => S4.TaggedStruct(tag, { ...dataSchema.fields, ...extraFields });
 var LoopStartedEventSchema = taggedEvent("LoopStarted", {
   config: LoopConfigSchema,
-  timestamp: S6.Number
+  timestamp: S4.Number
 });
 var LoopCompletedEventSchema = taggedEvent("LoopCompleted", {
   summary: LoopSummarySchema
@@ -2799,30 +2939,30 @@ var LoopFailedEventSchema = taggedEvent("LoopFailed", {
   error: LoopErrorSchema
 });
 var DiscoveryStartedEventSchema = taggedEvent("DiscoveryStarted", {
-  timestamp: S6.Number
+  timestamp: S4.Number
 });
 var DiscoveryCompletedEventSchema = taggedEvent("DiscoveryCompleted", {
-  taskCount: S6.Number,
-  timestamp: S6.Number
+  taskCount: S4.Number,
+  timestamp: S4.Number
 });
 var IterationStartedEventSchema = taggedEvent("IterationStarted", {
-  iteration: S6.Number
+  iteration: S4.Number
 });
 var IterationCompletedEventSchema = taggedEvent("IterationCompleted", {
-  iteration: S6.Number
+  iteration: S4.Number
 });
 var LLMTextEventSchema = taggedEvent("LLMText", {
-  text: S6.String
+  text: S4.String
 });
 var LLMToolStartEventSchema = taggedEvent("LLMToolStart", {
-  tool: S6.String
+  tool: S4.String
 });
 var LLMToolUseEventSchema = taggedEvent("LLMToolUse", {
-  tool: S6.String,
-  input: S6.Unknown
+  tool: S4.String,
+  input: S4.Unknown
 });
 var LLMToolEndEventSchema = taggedEvent("LLMToolEnd", {
-  tool: S6.String
+  tool: S4.String
 });
 var TasksDefinedEventSchema = taggedFromData(
   "TasksDefined",
@@ -2839,17 +2979,17 @@ var CriteriaDefinedEventSchema = taggedFromData(
 var PhaseStartedEventSchema = taggedFromData(
   "PhaseStarted",
   PhaseIdDataSchema,
-  { timestamp: S6.Number }
+  { timestamp: S4.Number }
 );
 var PhaseCompletedEventSchema = taggedFromData(
   "PhaseCompleted",
   PhaseIdDataSchema,
-  { timestamp: S6.Number }
+  { timestamp: S4.Number }
 );
 var PhaseFailedEventSchema = taggedFromData(
   "PhaseFailed",
   PhaseFailedDataSchema,
-  { timestamp: S6.Number }
+  { timestamp: S4.Number }
 );
 var CriterionPassedEventSchema = taggedFromData(
   "CriterionPassed",
@@ -2859,9 +2999,9 @@ var CriterionFailedEventSchema = taggedFromData(
   "CriterionFailed",
   CriterionFailedDataSchema
 );
-var CheckPassedEventSchema = S6.TaggedStruct("CheckPassed", {});
+var CheckPassedEventSchema = S4.TaggedStruct("CheckPassed", {});
 var CheckFailedEventSchema = taggedEvent("CheckFailed", {
-  failedCriteria: S6.Array(S6.String)
+  failedCriteria: S4.Array(S4.String)
 });
 var ReviewCompleteEventSchema = taggedFromData(
   "ReviewComplete",
@@ -2870,7 +3010,7 @@ var ReviewCompleteEventSchema = taggedFromData(
 var TaskCompletedEventSchema = taggedFromData(
   "TaskCompleted",
   TaskCompleteDataSchema,
-  { timestamp: S6.Number }
+  { timestamp: S4.Number }
 );
 var PlanCreatedEventSchema = taggedEvent("PlanCreated", {
   plan: PlanSchema
@@ -2879,11 +3019,43 @@ var PlanUpdatedEventSchema = taggedEvent("PlanUpdated", {
   plan: PlanSchema
 });
 var PlanUpdateFailedEventSchema = taggedEvent("PlanUpdateFailed", {
-  operation: S6.Literal("create", "update"),
-  error: S6.String,
-  planId: S6.optional(S6.String)
+  operation: S4.Literal("create", "update"),
+  error: S4.String,
+  planId: S4.optional(S4.String)
+});
+var LearningRecordedEventSchema = taggedEvent("LearningRecorded", {
+  iteration: S4.Number,
+  content: S4.String,
+  category: S4.optional(S4.Literal("success", "failure", "optimization")),
+  timestamp: S4.Number
+});
+var GuardrailAddedEventSchema = taggedEvent("GuardrailAdded", {
+  id: S4.String,
+  iteration: S4.Number,
+  pattern: S4.String,
+  sign: S4.String,
+  avoidance: S4.String,
+  severity: S4.Literal("warning", "critical"),
+  timestamp: S4.Number
+});
+var ProgressUpdatedEventSchema = taggedEvent("ProgressUpdated", {
+  sessionId: S4.String,
+  iteration: S4.Number,
+  taskId: S4.String,
+  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 = S6.Union(
+var DomainEventSchema = S4.Union(
   LoopStartedEventSchema,
   LoopCompletedEventSchema,
   LoopFailedEventSchema,
@@ -2909,7 +3081,12 @@ var DomainEventSchema = S6.Union(
   TaskCompletedEventSchema,
   PlanCreatedEventSchema,
   PlanUpdatedEventSchema,
-  PlanUpdateFailedEventSchema
+  PlanUpdateFailedEventSchema,
+  LearningRecordedEventSchema,
+  GuardrailAddedEventSchema,
+  ProgressUpdatedEventSchema,
+  WorktreeCreatedEventSchema,
+  WorktreeRemovedEventSchema
 );
 var DomainEventUtils = {
   isLLMEvent: (e) => e._tag.startsWith("LLM"),
@@ -2919,6 +3096,55 @@ var DomainEventUtils = {
   isDiscoveryEvent: (e) => e._tag.startsWith("Discovery")
 };
 
+// src/domain/schemas/guardrails.ts
+init_esm_shims();
+import { Schema as S5 } from "effect";
+var GuardrailSeveritySchema = S5.Literal("warning", "critical");
+var GuardrailSchema = S5.Struct({
+  id: S5.String,
+  createdAt: S5.String,
+  iteration: S5.Number,
+  pattern: S5.String,
+  sign: S5.String,
+  avoidance: S5.String,
+  severity: GuardrailSeveritySchema
+});
+var GuardrailsFileSchema = S5.Struct({
+  sessionId: S5.String,
+  createdAt: S5.String,
+  guardrails: S5.Array(GuardrailSchema)
+});
+var decodeGuardrail = S5.decodeUnknown(GuardrailSchema);
+var decodeGuardrailsFile = S5.decodeUnknown(GuardrailsFileSchema);
+
+// src/domain/schemas/llm.ts
+init_esm_shims();
+import { Schema as S6 } from "effect";
+var TextEventSchema = S6.TaggedStruct("Text", {
+  text: S6.String
+});
+var ToolStartEventSchema = S6.TaggedStruct("ToolStart", {
+  tool: S6.String
+});
+var ToolUseEventSchema = S6.TaggedStruct("ToolUse", {
+  tool: S6.String,
+  input: S6.Unknown
+});
+var ToolEndEventSchema = S6.TaggedStruct("ToolEnd", {
+  tool: S6.String
+});
+var DoneEventSchema = S6.TaggedStruct("Done", {
+  output: S6.String
+});
+var LLMEventSchema = S6.Union(
+  TextEventSchema,
+  ToolStartEventSchema,
+  ToolUseEventSchema,
+  ToolEndEventSchema,
+  DoneEventSchema
+);
+var decodeLLMEvent = S6.decodeUnknown(LLMEventSchema);
+
 // src/domain/schemas/logger.ts
 init_esm_shims();
 import { Schema as S7 } from "effect";
@@ -2947,29 +3173,57 @@ var RunOptionsDataSchema = S8.Struct({
   consumer: S8.optional(ConsumerTypeSchema)
 });
 
-// src/domain/schemas/session.ts
+// src/domain/schemas/progress.ts
 init_esm_shims();
 import { Schema as S9 } from "effect";
-var SessionStatusSchema = S9.Literal(
+var ProgressActionSchema = S9.Literal(
+  "started",
+  "completed",
+  "failed",
+  "learning"
+);
+var ProgressEntrySchema = S9.Struct({
+  iteration: S9.Number,
+  timestamp: S9.String,
+  taskId: S9.String,
+  action: ProgressActionSchema,
+  summary: S9.String,
+  learnings: S9.optional(S9.Array(S9.String)),
+  filesModified: S9.optional(S9.Array(S9.String))
+});
+var ProgressFileSchema = S9.Struct({
+  sessionId: S9.String,
+  createdAt: S9.String,
+  entries: S9.Array(ProgressEntrySchema)
+});
+var decodeProgressEntry = S9.decodeUnknown(ProgressEntrySchema);
+var decodeProgressFile = S9.decodeUnknown(ProgressFileSchema);
+
+// src/domain/schemas/session.ts
+init_esm_shims();
+import { Schema as S10 } from "effect";
+var SessionStatusSchema = S10.Literal(
   "active",
   "completed",
   "failed",
   "paused"
 );
-var SessionSchema = S9.Struct({
-  id: S9.String,
-  createdAt: S9.String,
+var SessionSchema = S10.Struct({
+  id: S10.String,
+  createdAt: S10.String,
   status: SessionStatusSchema,
-  originalTask: S9.String,
-  completedTasks: S9.Array(S9.String),
-  currentTaskId: S9.optional(S9.String)
+  originalTask: S10.String,
+  completedTasks: S10.Array(S10.String),
+  currentTaskId: S10.optional(S10.String),
+  worktreePath: S10.optional(S10.String),
+  branchName: S10.optional(S10.String)
 });
-var decodeSession = S9.decodeUnknown(SessionSchema);
+var decodeSession = S10.decodeUnknown(SessionSchema);
 
 // src/domain/schemas/signals.ts
 init_esm_shims();
-import { Schema as S10 } from "effect";
-var taggedFromData2 = (tag, dataSchema) => S10.TaggedStruct(tag, dataSchema.fields);
+import { Schema as S11 } from "effect";
+var taggedFromData2 = (tag, dataSchema) => S11.TaggedStruct(tag, dataSchema.fields);
 var TasksDefinedSignalSchema = taggedFromData2(
   "TasksDefined",
   TasksDefinedDataSchema
@@ -3002,8 +3256,8 @@ var CriterionFailedSignalSchema = taggedFromData2(
   "CriterionFailed",
   CriterionFailedDataSchema
 );
-var CheckPassedSignalSchema = S10.TaggedStruct("CheckPassed", {});
-var CheckFailedSignalSchema = S10.TaggedStruct("CheckFailed", {});
+var CheckPassedSignalSchema = S11.TaggedStruct("CheckPassed", {});
+var CheckFailedSignalSchema = S11.TaggedStruct("CheckFailed", {});
 var ReviewCompleteSignalSchema = taggedFromData2(
   "ReviewComplete",
   ReviewCompleteDataSchema
@@ -3012,8 +3266,23 @@ var TaskCompleteSignalSchema = taggedFromData2(
   "TaskComplete",
   TaskCompleteSignalDataSchema
 );
-var LoopCompleteSignalSchema = S10.TaggedStruct("LoopComplete", {});
-var SignalSchema = S10.Union(
+var LoopCompleteSignalSchema = S11.TaggedStruct("LoopComplete", {});
+var LearningCategorySchema = S11.Literal(
+  "success",
+  "failure",
+  "optimization"
+);
+var LearningSignalSchema = S11.TaggedStruct("Learning", {
+  content: S11.String,
+  category: S11.optional(LearningCategorySchema)
+});
+var GuardrailSignalSchema = S11.TaggedStruct("Guardrail", {
+  pattern: S11.String,
+  sign: S11.String,
+  avoidance: S11.String,
+  severity: S11.Literal("warning", "critical")
+});
+var SignalSchema = S11.Union(
   TasksDefinedSignalSchema,
   PhasesDefinedSignalSchema,
   CriteriaDefinedSignalSchema,
@@ -3026,26 +3295,28 @@ var SignalSchema = S10.Union(
   CheckFailedSignalSchema,
   ReviewCompleteSignalSchema,
   TaskCompleteSignalSchema,
-  LoopCompleteSignalSchema
+  LoopCompleteSignalSchema,
+  LearningSignalSchema,
+  GuardrailSignalSchema
 );
-var decodeSignal = S10.decodeUnknown(SignalSchema);
-var decodeSignalSync = S10.decodeUnknownSync(SignalSchema);
+var decodeSignal = S11.decodeUnknown(SignalSchema);
+var decodeSignalSync = S11.decodeUnknownSync(SignalSchema);
 
 // src/domain/schemas/task-generation.ts
 init_esm_shims();
-import { Schema as S11 } from "effect";
-var GeneratedTaskStatusSchema = S11.Literal(
+import { Schema as S12 } from "effect";
+var GeneratedTaskStatusSchema = S12.Literal(
   "pending",
   "in_progress",
   "done",
   "failed"
 );
-var GeneratedTaskSchema = S11.Struct({
-  id: S11.String,
-  title: S11.String,
+var GeneratedTaskSchema = S12.Struct({
+  id: S12.String,
+  title: S12.String,
   status: GeneratedTaskStatusSchema
 });
-var GeneratedTaskListSchema = S11.Array(GeneratedTaskSchema);
+var GeneratedTaskListSchema = S12.Array(GeneratedTaskSchema);
 var STATUS_ICONS = {
   done: "[x]",
   in_progress: "[~]",
@@ -3104,15 +3375,15 @@ function parseTasksMd(content) {
 
 // src/domain/schemas/tui.ts
 init_esm_shims();
-import { Schema as S12 } from "effect";
-var ViewModeSchema = S12.Literal("logs", "tasks", "detail");
-var LoopStatusSchema = S12.Literal(
+import { Schema as S13 } from "effect";
+var ViewModeSchema = S13.Literal("logs", "tasks", "detail");
+var LoopStatusSchema = S13.Literal(
   "idle",
   "running",
   "complete",
   "error"
 );
-var ExecutionModeSchema = S12.Literal(
+var ExecutionModeSchema = S13.Literal(
   "idle",
   "discovery",
   "breakdown",
@@ -3122,98 +3393,566 @@ var ExecutionModeSchema = S12.Literal(
   "verifying",
   "reviewing"
 );
-var TUIPhaseStatusSchema = S12.Literal(
+var TUIPhaseStatusSchema = S13.Literal(
   "pending",
   "in_progress",
   "done",
   "failed"
 );
-var TUICriterionStatusSchema = S12.Literal(
+var TUICriterionStatusSchema = S13.Literal(
   "pending",
   "passed",
   "failed"
 );
-var TUITaskStatusSchema = S12.Literal(
+var TUITaskStatusSchema = S13.Literal(
   "pending",
   "in_progress",
   "done",
   "failed"
 );
-var TUIPhaseSchema = S12.Struct({
-  id: S12.String,
-  description: S12.String,
+var TUIPhaseSchema = S13.Struct({
+  id: S13.String,
+  description: S13.String,
   status: TUIPhaseStatusSchema,
-  startedAt: S12.optional(S12.Number),
-  completedAt: S12.optional(S12.Number)
+  startedAt: S13.optional(S13.Number),
+  completedAt: S13.optional(S13.Number)
 });
-var TUICriterionSchema = S12.Struct({
-  id: S12.String,
-  description: S12.String,
+var TUICriterionSchema = S13.Struct({
+  id: S13.String,
+  description: S13.String,
   status: TUICriterionStatusSchema,
-  failureReason: S12.optional(S12.String)
+  failureReason: S13.optional(S13.String)
 });
-var TUITaskSchema = S12.Struct({
-  id: S12.String,
-  title: S12.String,
+var TUITaskSchema = S13.Struct({
+  id: S13.String,
+  title: S13.String,
   status: TUITaskStatusSchema,
-  phases: S12.Array(TUIPhaseSchema),
-  criteria: S12.Array(TUICriterionSchema),
-  startedAt: S12.optional(S12.Number),
-  completedAt: S12.optional(S12.Number)
+  phases: S13.Array(TUIPhaseSchema),
+  criteria: S13.Array(TUICriterionSchema),
+  startedAt: S13.optional(S13.Number),
+  completedAt: S13.optional(S13.Number)
 });
-var TUIStateSchema = S12.Struct({
+var TUIStateSchema = S13.Struct({
   // Loop info
-  task: S12.String,
-  iteration: S12.Number,
-  maxIterations: S12.Number,
+  task: S13.String,
+  iteration: S13.Number,
+  maxIterations: S13.Number,
   status: LoopStatusSchema,
-  startTime: S12.Number,
+  startTime: S13.Number,
   // Discovery phase
-  discoveryInProgress: S12.Boolean,
-  discoveryCompleted: S12.Boolean,
+  discoveryInProgress: S13.Boolean,
+  discoveryCompleted: S13.Boolean,
   // Current activity
   executionMode: ExecutionModeSchema,
-  currentTool: S12.optional(S12.String),
-  currentTaskId: S12.optional(S12.String),
+  currentTool: S13.optional(S13.String),
+  currentTaskId: S13.optional(S13.String),
   // Output
-  outputLines: S12.Array(S12.String),
-  partialLine: S12.String,
+  outputLines: S13.Array(S13.String),
+  partialLine: S13.String,
   // Tasks
-  tasks: S12.Array(TUITaskSchema),
+  tasks: S13.Array(TUITaskSchema),
   // Navigation
   viewMode: ViewModeSchema,
-  selectedTaskIndex: S12.Number,
-  scrollOffset: S12.Number,
-  userScrolled: S12.Boolean,
+  selectedTaskIndex: S13.Number,
+  scrollOffset: S13.Number,
+  userScrolled: S13.Boolean,
   // Git
-  gitBranch: S12.optional(S12.String),
-  gitPushed: S12.Boolean,
-  prUrl: S12.optional(S12.String)
+  gitBranch: S13.optional(S13.String),
+  gitPushed: S13.Boolean,
+  prUrl: S13.optional(S13.String)
 });
 
+// src/services/guardrails-store.ts
+init_esm_shims();
+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 Effect6.tryPromise({
+    try: () => mkdir2(dirPath, { recursive: true }),
+    catch: (error) => new GuardrailsStoreError({
+      message: `Failed to create directory: ${dirPath}`,
+      operation: "add",
+      cause: error
+    })
+  }).pipe(Effect6.asVoid);
+}
+function getSessionDir(sessionId) {
+  return join2(process.cwd(), PLANS_DIR, sessionId);
+}
+function getGuardrailsPath(sessionId) {
+  return join2(getSessionDir(sessionId), "guardrails.json");
+}
+function serializeGuardrails(guardrails) {
+  return JSON.stringify(guardrails, null, 2);
+}
+function deserializeGuardrails(json) {
+  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)}`,
+        operation: "load",
+        cause: error
+      })
+    });
+    const validated = yield* decodeGuardrailsFile(parsed).pipe(
+      Effect6.mapError(
+        (error) => new GuardrailsStoreError({
+          message: `Guardrails validation failed: ${String(error)}`,
+          operation: "load",
+          cause: error
+        })
+      )
+    );
+    return validated;
+  });
+}
+function createEmptyGuardrails(sessionId, createdAt) {
+  return {
+    sessionId,
+    createdAt,
+    guardrails: []
+  };
+}
+var make2 = {
+  add: (sessionId, guardrail) => Effect6.gen(function* () {
+    const sessionDir = getSessionDir(sessionId);
+    yield* ensureDir(sessionDir);
+    const guardrailsPath = getGuardrailsPath(sessionId);
+    const existing = yield* Effect6.tryPromise({
+      try: async () => {
+        try {
+          const content = await readFile(guardrailsPath, "utf-8");
+          return content;
+        } catch {
+          return null;
+        }
+      },
+      catch: (error) => new GuardrailsStoreError({
+        message: `Failed to read guardrails file: ${guardrailsPath}`,
+        operation: "add",
+        cause: error
+      })
+    });
+    let guardrails;
+    if (existing) {
+      guardrails = yield* deserializeGuardrails(existing).pipe(
+        Effect6.mapError(
+          (err) => new GuardrailsStoreError({
+            message: err.message,
+            operation: "add",
+            cause: err
+          })
+        )
+      );
+    } else {
+      const now = yield* DateTime.now;
+      guardrails = createEmptyGuardrails(sessionId, DateTime.formatIso(now));
+    }
+    const updatedGuardrails = {
+      ...guardrails,
+      guardrails: [...guardrails.guardrails, guardrail]
+    };
+    yield* Effect6.tryPromise({
+      try: () => writeFile(
+        guardrailsPath,
+        serializeGuardrails(updatedGuardrails),
+        "utf-8"
+      ),
+      catch: (error) => new GuardrailsStoreError({
+        message: `Failed to write guardrails file: ${guardrailsPath}`,
+        operation: "add",
+        cause: error
+      })
+    });
+  }),
+  load: (sessionId) => Effect6.gen(function* () {
+    const guardrailsPath = getGuardrailsPath(sessionId);
+    const content = yield* Effect6.tryPromise({
+      try: async () => {
+        try {
+          return await readFile(guardrailsPath, "utf-8");
+        } catch {
+          return null;
+        }
+      },
+      catch: (error) => new GuardrailsStoreError({
+        message: `Failed to read guardrails file: ${guardrailsPath}`,
+        operation: "load",
+        cause: error
+      })
+    });
+    if (content === null) {
+      const now = yield* DateTime.now;
+      return createEmptyGuardrails(sessionId, DateTime.formatIso(now));
+    }
+    return yield* deserializeGuardrails(content);
+  }),
+  getActive: (sessionId) => Effect6.gen(function* () {
+    const guardrails = yield* make2.load(sessionId);
+    return guardrails.guardrails;
+  })
+};
+var Live3 = Layer3.succeed(GuardrailsStore, make2);
+var FileSystemGuardrails = {
+  Live: Live3
+};
+
+// src/layers/guardrails/memory.ts
+init_esm_shims();
+import { DateTime as DateTime2, Effect as Effect7, Layer as Layer4, Ref as Ref4 } from "effect";
+function createMemoryGuardrailsStore(stateRef) {
+  return {
+    add: (sessionId, guardrail) => Effect7.gen(function* () {
+      const state = yield* Ref4.get(stateRef);
+      let guardrails = state.get(sessionId);
+      if (!guardrails) {
+        const now = yield* DateTime2.now;
+        guardrails = {
+          sessionId,
+          createdAt: DateTime2.formatIso(now),
+          guardrails: []
+        };
+      }
+      const updatedGuardrails = {
+        ...guardrails,
+        guardrails: [...guardrails.guardrails, guardrail]
+      };
+      state.set(sessionId, updatedGuardrails);
+      yield* Ref4.set(stateRef, state);
+    }),
+    load: (sessionId) => Effect7.gen(function* () {
+      const state = yield* Ref4.get(stateRef);
+      const guardrails = state.get(sessionId);
+      if (!guardrails) {
+        const now = yield* DateTime2.now;
+        return {
+          sessionId,
+          createdAt: DateTime2.formatIso(now),
+          guardrails: []
+        };
+      }
+      return guardrails;
+    }),
+    getActive: (sessionId) => Effect7.gen(function* () {
+      const state = yield* Ref4.get(stateRef);
+      const guardrails = state.get(sessionId);
+      if (!guardrails) {
+        return [];
+      }
+      return guardrails.guardrails;
+    })
+  };
+}
+function layer2() {
+  return Layer4.effect(
+    GuardrailsStore,
+    Effect7.gen(function* () {
+      const stateRef = yield* Ref4.make(/* @__PURE__ */ new Map());
+      return createMemoryGuardrailsStore(stateRef);
+    })
+  );
+}
+var Live4 = layer2();
+var MemoryGuardrails = {
+  Live: Live4,
+  layer: layer2
+};
+
+// src/layers/llm/claude-cli.ts
+init_esm_shims();
+import { spawn } from "child_process";
+import { Effect as Effect9, Layer as Layer5, Stream as Stream5 } from "effect";
+
+// src/services/llm.ts
+init_esm_shims();
+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 Effect8, Stream as Stream4 } from "effect";
+
+// src/layers/llm/parsers.ts
+init_esm_shims();
+function parseJsonLine(line) {
+  if (!line.startsWith("{")) {
+    return null;
+  }
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function isTextContent(json) {
+  return typeof json === "object" && json !== null && "type" in json && typeof json.type === "string";
+}
+function isToolUse(json) {
+  return typeof json === "object" && json !== null && "type" in json && "content_block" in json;
+}
+function extractText(json) {
+  if (!isTextContent(json)) {
+    return null;
+  }
+  if (json.type === "content_block_delta") {
+    const delta = json;
+    if (delta.delta?.type === "text_delta" && delta.delta.text) {
+      return delta.delta.text;
+    }
+  }
+  if (json.type === "assistant" && json.message?.content) {
+    for (const block of json.message.content) {
+      if (block.type === "text" && block.text) {
+        return block.text;
+      }
+    }
+  }
+  return null;
+}
+function isToolInputDelta(json) {
+  return typeof json === "object" && json !== null && "type" in json && json.type === "content_block_delta" && "delta" in json;
+}
+function extractToolInfo(json) {
+  if (typeof json === "object" && json !== null && "type" in json && json.type === "content_block_stop") {
+    return {
+      type: "end",
+      name: "unknown"
+    };
+  }
+  if (!isToolUse(json)) {
+    if (isToolInputDelta(json) && json.delta?.type === "input_json_delta" && json.delta.partial_json) {
+      return {
+        type: "input_delta",
+        name: "",
+        partialJson: json.delta.partial_json
+      };
+    }
+    return null;
+  }
+  if (json.type === "content_block_start" && json.content_block?.type === "tool_use") {
+    return {
+      type: "start",
+      name: json.content_block.name || "unknown"
+    };
+  }
+  return null;
+}
+function safeParseJson(jsonStr) {
+  try {
+    return JSON.parse(jsonStr);
+  } catch {
+    return null;
+  }
+}
+function unwrapStreamEvent(json) {
+  if (typeof json === "object" && json !== null && "type" in json && json.type === "stream_event" && "event" in json) {
+    return json.event;
+  }
+  return json;
+}
+
+// src/layers/llm/stream.ts
+function handleToolEvent(toolInfo, toolState, emit) {
+  if (toolInfo.type === "start") {
+    toolState.currentTool = toolInfo.name;
+    toolState.inputChunks.length = 0;
+    emit.single({ _tag: "ToolStart", tool: toolInfo.name });
+    return;
+  }
+  if (toolInfo.type === "input_delta" && toolInfo.partialJson) {
+    toolState.inputChunks.push(toolInfo.partialJson);
+    return;
+  }
+  if (toolInfo.type === "end" && toolState.currentTool) {
+    const inputJson = toolState.inputChunks.join("");
+    const input = safeParseJson(inputJson);
+    if (input !== null) {
+      emit.single({ _tag: "ToolUse", tool: toolState.currentTool, input });
+    }
+    emit.single({ _tag: "ToolEnd", tool: toolState.currentTool });
+    toolState.currentTool = "";
+    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 Stream4.async((emit) => {
+    const outputChunks = [];
+    const toolState = { currentTool: "", inputChunks: [] };
+    const stdout = child.stdout;
+    if (!stdout) {
+      emit.fail(
+        new LLMError({ message: "Failed to get stdout from child process" })
+      );
+      return Effect8.void;
+    }
+    const rl = createInterface({
+      input: stdout,
+      crlfDelay: Number.POSITIVE_INFINITY
+    });
+    rl.on("line", (line) => {
+      const json = parseJsonLine(line);
+      if (json) {
+        processJsonLine(json, outputChunks, toolState, emit);
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      const text = data.toString().trim();
+      if (text) {
+        emit.single({ _tag: "Text", text: `[stderr] ${text}` });
+      }
+    });
+    child.on("close", (exitCode) => {
+      if (exitCode !== 0) {
+        emit.fail(
+          new LLMError({
+            message: `Claude CLI exited with code ${exitCode}`
+          })
+        );
+      } else {
+        const fullOutput = outputChunks.join("");
+        emit.single({ _tag: "Done", output: fullOutput });
+        emit.end();
+      }
+    });
+    child.on("error", (error) => {
+      emit.fail(
+        new LLMError({
+          message: error.message,
+          cause: error
+        })
+      );
+    });
+    return Effect8.sync(() => {
+      child.kill("SIGTERM");
+    });
+  });
+}
+
+// src/layers/llm/claude-cli.ts
+var make3 = {
+  execute: (prompt, options) => {
+    return Stream5.unwrap(
+      Effect9.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);
+      })
+    );
+  }
+};
+var Live5 = Layer5.succeed(LLM, make3);
+var ClaudeCLI = {
+  Live: Live5
+};
+
+// src/layers/llm/mock.ts
+init_esm_shims();
+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, _options) => {
+      const baseStream = Stream6.fromIterable(config.events);
+      if (config.delayMs !== void 0 && config.delayMs > 0) {
+        const delay = config.delayMs;
+        return baseStream.pipe(Stream6.tap(() => Effect10.sleep(delay)));
+      }
+      return baseStream;
+    }
+  };
+}
+var defaultMockEvents = [
+  { _tag: "Text", text: "Processing task...\n" },
+  { _tag: "ToolStart", tool: "Read" },
+  { _tag: "ToolEnd", tool: "Read" },
+  { _tag: "Text", text: "Task completed successfully.\n" },
+  {
+    _tag: "Done",
+    output: "Processing task...\nTask completed successfully.\n"
+  }
+];
+var defaultMock = createMockLLM({ events: defaultMockEvents });
+var Live6 = Layer6.succeed(LLM, defaultMock);
+function layer3(config) {
+  return Layer6.succeed(LLM, createMockLLM(config));
+}
+var Mock = {
+  Live: Live6,
+  layer: layer3,
+  createMockLLM
+};
+
+// src/layers/plan/file-system.ts
+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 Effect11, Layer as Layer7 } from "effect";
+
 // src/services/plan-store.ts
 init_esm_shims();
-import { Context as Context2 } from "effect";
-var PlanStore = class extends Context2.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_DIR = ".ferix/plans";
-function ensureDir(dirPath) {
-  return Effect7.tryPromise({
-    try: () => mkdir(dirPath, { recursive: true }),
+var PLANS_DIR2 = ".ferix/plans";
+function ensureDir2(dirPath) {
+  return Effect11.tryPromise({
+    try: () => mkdir3(dirPath, { recursive: true }),
     catch: (error) => new PlanStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "create",
       cause: error
     })
-  }).pipe(Effect7.asVoid);
+  }).pipe(Effect11.asVoid);
 }
-function getSessionDir(sessionId) {
-  return join(process.cwd(), PLANS_DIR, sessionId);
+function getSessionDir2(sessionId) {
+  return join3(process.cwd(), PLANS_DIR2, sessionId);
 }
 function getPlanPath(sessionId, planId) {
-  return join(getSessionDir(sessionId), `${planId}.json`);
+  return join3(getSessionDir2(sessionId), `${planId}.json`);
 }
 function generatePlanId(taskNumber) {
   return PlanId(`task-${taskNumber}`);
@@ -3222,8 +3961,8 @@ function serializePlan(plan) {
   return JSON.stringify(plan, null, 2);
 }
 function deserializePlan(json, planId) {
-  return Effect7.gen(function* () {
-    const parsed = yield* Effect7.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)}`,
@@ -3232,7 +3971,7 @@ function deserializePlan(json, planId) {
       })
     });
     const validated = yield* decodePlanData(parsed).pipe(
-      Effect7.mapError(
+      Effect11.mapError(
         (error) => new PlanStoreError({
           message: `Plan validation failed: ${String(error)}`,
           operation: "load",
@@ -3246,11 +3985,11 @@ function deserializePlan(json, planId) {
     };
   });
 }
-var make2 = {
-  create: (sessionId, plan) => Effect7.gen(function* () {
-    const sessionDir = getSessionDir(sessionId);
-    yield* ensureDir(sessionDir);
-    const existingPlans = yield* Effect7.tryPromise({
+var make4 = {
+  create: (sessionId, plan) => Effect11.gen(function* () {
+    const sessionDir = getSessionDir2(sessionId);
+    yield* ensureDir2(sessionDir);
+    const existingPlans = yield* Effect11.tryPromise({
       try: async () => {
         try {
           const files = await readdir(sessionDir);
@@ -3267,8 +4006,8 @@ var make2 = {
     const planId = generatePlanId(existingPlans + 1);
     const planPath = getPlanPath(sessionId, planId);
     const fullPlan = { ...plan, id: planId };
-    yield* Effect7.tryPromise({
-      try: () => writeFile(planPath, serializePlan(fullPlan), "utf-8"),
+    yield* Effect11.tryPromise({
+      try: () => writeFile2(planPath, serializePlan(fullPlan), "utf-8"),
       catch: (error) => new PlanStoreError({
         message: `Failed to write plan file: ${planPath}`,
         operation: "create",
@@ -3277,11 +4016,11 @@ var make2 = {
     });
     return planId;
   }),
-  load: (planId, sessionId) => Effect7.gen(function* () {
+  load: (planId, sessionId) => Effect11.gen(function* () {
     if (sessionId) {
       const planPath = getPlanPath(sessionId, planId);
-      const content = yield* Effect7.tryPromise({
-        try: () => readFile(planPath, "utf-8"),
+      const content = yield* Effect11.tryPromise({
+        try: () => readFile2(planPath, "utf-8"),
         catch: (error) => new PlanStoreError({
           message: `Failed to read plan file: ${planPath}`,
           operation: "load",
@@ -3290,9 +4029,9 @@ var make2 = {
       });
       return yield* deserializePlan(content, planId);
     }
-    const sessionDirs = yield* Effect7.tryPromise({
+    const sessionDirs = yield* Effect11.tryPromise({
       try: async () => {
-        const plansDir = join(process.cwd(), PLANS_DIR);
+        const plansDir = join3(process.cwd(), PLANS_DIR2);
         const dirs = await readdir(plansDir);
         return dirs;
       },
@@ -3304,19 +4043,19 @@ var make2 = {
     });
     for (const sid of sessionDirs) {
       const planPath = getPlanPath(sid, planId);
-      const exists = yield* Effect7.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(Effect7.orElseSucceed(() => false));
+      }).pipe(Effect11.orElseSucceed(() => false));
       if (exists) {
-        const content = yield* Effect7.tryPromise({
-          try: () => readFile(planPath, "utf-8"),
+        const content = yield* Effect11.tryPromise({
+          try: () => readFile2(planPath, "utf-8"),
           catch: (error) => new PlanStoreError({
             message: `Failed to read plan file: ${planPath}`,
             operation: "load",
@@ -3326,17 +4065,17 @@ var make2 = {
         return yield* deserializePlan(content, planId);
       }
     }
-    return yield* Effect7.fail(
+    return yield* Effect11.fail(
       new PlanStoreError({
         message: `Plan not found: ${planId}`,
         operation: "load"
       })
     );
   }),
-  update: (planId, plan) => Effect7.gen(function* () {
+  update: (planId, plan) => Effect11.gen(function* () {
     const planPath = getPlanPath(plan.sessionId, planId);
-    yield* Effect7.tryPromise({
-      try: () => writeFile(planPath, serializePlan(plan), "utf-8"),
+    yield* Effect11.tryPromise({
+      try: () => writeFile2(planPath, serializePlan(plan), "utf-8"),
       catch: (error) => new PlanStoreError({
         message: `Failed to update plan file: ${planPath}`,
         operation: "update",
@@ -3344,9 +4083,9 @@ var make2 = {
       })
     });
   }),
-  list: (sessionId) => Effect7.gen(function* () {
-    const sessionDir = getSessionDir(sessionId);
-    const files = yield* Effect7.tryPromise({
+  list: (sessionId) => Effect11.gen(function* () {
+    const sessionDir = getSessionDir2(sessionId);
+    const files = yield* Effect11.tryPromise({
       try: async () => {
         try {
           return await readdir(sessionDir);
@@ -3363,18 +4102,18 @@ var make2 = {
     return files.filter((f) => f.endsWith(".json")).map((f) => PlanId(f.replace(".json", "")));
   })
 };
-var Live3 = Layer3.succeed(PlanStore, make2);
+var Live7 = Layer7.succeed(PlanStore, make4);
 var FileSystemPlan = {
-  Live: Live3
+  Live: Live7
 };
 
 // src/layers/plan/memory.ts
 init_esm_shims();
-import { Effect as Effect8, Layer as Layer4, Ref as Ref3 } from "effect";
+import { Effect as Effect12, Layer as Layer8, Ref as Ref5 } from "effect";
 function createMemoryPlanStore(stateRef) {
   return {
-    create: (sessionId, plan) => Effect8.gen(function* () {
-      const state = yield* Ref3.get(stateRef);
+    create: (sessionId, plan) => Effect12.gen(function* () {
+      const state = yield* Ref5.get(stateRef);
       if (!state.has(sessionId)) {
         state.set(sessionId, /* @__PURE__ */ new Map());
       }
@@ -3385,18 +4124,18 @@ function createMemoryPlanStore(stateRef) {
       const planId = PlanId(`task-${sessionPlans.size + 1}`);
       const fullPlan = { ...plan, id: planId };
       sessionPlans.set(planId, fullPlan);
-      yield* Ref3.set(stateRef, state);
+      yield* Ref5.set(stateRef, state);
       return planId;
     }),
-    load: (planId, sessionId) => Effect8.gen(function* () {
-      const state = yield* Ref3.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* Effect8.fail(
+        return yield* Effect12.fail(
           new PlanStoreError({
             message: `Plan not found: ${planId}`,
             operation: "load"
@@ -3409,18 +4148,18 @@ function createMemoryPlanStore(stateRef) {
           return plan;
         }
       }
-      return yield* Effect8.fail(
+      return yield* Effect12.fail(
         new PlanStoreError({
           message: `Plan not found: ${planId}`,
           operation: "load"
         })
       );
     }),
-    update: (planId, plan) => Effect8.gen(function* () {
-      const state = yield* Ref3.get(stateRef);
+    update: (planId, plan) => Effect12.gen(function* () {
+      const state = yield* Ref5.get(stateRef);
       const sessionPlans = state.get(plan.sessionId);
       if (!sessionPlans) {
-        return yield* Effect8.fail(
+        return yield* Effect12.fail(
           new PlanStoreError({
             message: `Session not found: ${plan.sessionId}`,
             operation: "update"
@@ -3428,10 +4167,10 @@ function createMemoryPlanStore(stateRef) {
         );
       }
       sessionPlans.set(planId, plan);
-      yield* Ref3.set(stateRef, state);
+      yield* Ref5.set(stateRef, state);
     }),
-    list: (sessionId) => Effect8.gen(function* () {
-      const state = yield* Ref3.get(stateRef);
+    list: (sessionId) => Effect12.gen(function* () {
+      const state = yield* Ref5.get(stateRef);
       const sessionPlans = state.get(sessionId);
       if (!sessionPlans) {
         return [];
@@ -3440,32 +4179,236 @@ function createMemoryPlanStore(stateRef) {
     })
   };
 }
-function layer2() {
-  return Layer4.effect(
+function layer4() {
+  return Layer8.effect(
     PlanStore,
-    Effect8.gen(function* () {
-      const stateRef = yield* Ref3.make(/* @__PURE__ */ new Map());
+    Effect12.gen(function* () {
+      const stateRef = yield* Ref5.make(/* @__PURE__ */ new Map());
       return createMemoryPlanStore(stateRef);
     })
   );
 }
-var Live4 = layer2();
+var Live8 = layer4();
 var MemoryPlan = {
-  Live: Live4,
-  layer: layer2
+  Live: Live8,
+  layer: layer4
+};
+
+// src/layers/progress/file-system.ts
+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 Effect13, Layer as Layer9 } from "effect";
+
+// src/services/progress-store.ts
+init_esm_shims();
+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 Effect13.tryPromise({
+    try: () => mkdir4(dirPath, { recursive: true }),
+    catch: (error) => new ProgressStoreError({
+      message: `Failed to create directory: ${dirPath}`,
+      operation: "append",
+      cause: error
+    })
+  }).pipe(Effect13.asVoid);
+}
+function getSessionDir3(sessionId) {
+  return join4(process.cwd(), PLANS_DIR3, sessionId);
+}
+function getProgressPath(sessionId) {
+  return join4(getSessionDir3(sessionId), "progress.json");
+}
+function serializeProgress(progress) {
+  return JSON.stringify(progress, null, 2);
+}
+function deserializeProgress(json) {
+  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)}`,
+        operation: "load",
+        cause: error
+      })
+    });
+    const validated = yield* decodeProgressFile(parsed).pipe(
+      Effect13.mapError(
+        (error) => new ProgressStoreError({
+          message: `Progress validation failed: ${String(error)}`,
+          operation: "load",
+          cause: error
+        })
+      )
+    );
+    return validated;
+  });
+}
+function createEmptyProgress(sessionId, createdAt) {
+  return {
+    sessionId,
+    createdAt,
+    entries: []
+  };
+}
+var make5 = {
+  append: (sessionId, entry) => Effect13.gen(function* () {
+    const sessionDir = getSessionDir3(sessionId);
+    yield* ensureDir3(sessionDir);
+    const progressPath = getProgressPath(sessionId);
+    const existing = yield* Effect13.tryPromise({
+      try: async () => {
+        try {
+          const content = await readFile3(progressPath, "utf-8");
+          return content;
+        } catch {
+          return null;
+        }
+      },
+      catch: (error) => new ProgressStoreError({
+        message: `Failed to read progress file: ${progressPath}`,
+        operation: "append",
+        cause: error
+      })
+    });
+    let progress;
+    if (existing) {
+      progress = yield* deserializeProgress(existing).pipe(
+        Effect13.mapError(
+          (err) => new ProgressStoreError({
+            message: err.message,
+            operation: "append",
+            cause: err
+          })
+        )
+      );
+    } else {
+      const now = yield* DateTime3.now;
+      progress = createEmptyProgress(sessionId, DateTime3.formatIso(now));
+    }
+    const updatedProgress = {
+      ...progress,
+      entries: [...progress.entries, entry]
+    };
+    yield* Effect13.tryPromise({
+      try: () => writeFile3(progressPath, serializeProgress(updatedProgress), "utf-8"),
+      catch: (error) => new ProgressStoreError({
+        message: `Failed to write progress file: ${progressPath}`,
+        operation: "append",
+        cause: error
+      })
+    });
+  }),
+  load: (sessionId) => Effect13.gen(function* () {
+    const progressPath = getProgressPath(sessionId);
+    const content = yield* Effect13.tryPromise({
+      try: async () => {
+        try {
+          return await readFile3(progressPath, "utf-8");
+        } catch {
+          return null;
+        }
+      },
+      catch: (error) => new ProgressStoreError({
+        message: `Failed to read progress file: ${progressPath}`,
+        operation: "load",
+        cause: error
+      })
+    });
+    if (content === null) {
+      const now = yield* DateTime3.now;
+      return createEmptyProgress(sessionId, DateTime3.formatIso(now));
+    }
+    return yield* deserializeProgress(content);
+  }),
+  getRecent: (sessionId, count) => Effect13.gen(function* () {
+    const progress = yield* make5.load(sessionId);
+    const entries = progress.entries;
+    return entries.slice(-count);
+  })
+};
+var Live9 = Layer9.succeed(ProgressStore, make5);
+var FileSystemProgress = {
+  Live: Live9
+};
+
+// src/layers/progress/memory.ts
+init_esm_shims();
+import { DateTime as DateTime4, Effect as Effect14, Layer as Layer10, Ref as Ref6 } from "effect";
+function createMemoryProgressStore(stateRef) {
+  return {
+    append: (sessionId, entry) => Effect14.gen(function* () {
+      const state = yield* Ref6.get(stateRef);
+      let progress = state.get(sessionId);
+      if (!progress) {
+        const now = yield* DateTime4.now;
+        progress = {
+          sessionId,
+          createdAt: DateTime4.formatIso(now),
+          entries: []
+        };
+      }
+      const updatedProgress = {
+        ...progress,
+        entries: [...progress.entries, entry]
+      };
+      state.set(sessionId, updatedProgress);
+      yield* Ref6.set(stateRef, state);
+    }),
+    load: (sessionId) => Effect14.gen(function* () {
+      const state = yield* Ref6.get(stateRef);
+      const progress = state.get(sessionId);
+      if (!progress) {
+        const now = yield* DateTime4.now;
+        return {
+          sessionId,
+          createdAt: DateTime4.formatIso(now),
+          entries: []
+        };
+      }
+      return progress;
+    }),
+    getRecent: (sessionId, count) => Effect14.gen(function* () {
+      const state = yield* Ref6.get(stateRef);
+      const progress = state.get(sessionId);
+      if (!progress) {
+        return [];
+      }
+      return progress.entries.slice(-count);
+    })
+  };
+}
+function layer5() {
+  return Layer10.effect(
+    ProgressStore,
+    Effect14.gen(function* () {
+      const stateRef = yield* Ref6.make(/* @__PURE__ */ new Map());
+      return createMemoryProgressStore(stateRef);
+    })
+  );
+}
+var Live10 = layer5();
+var MemoryProgress = {
+  Live: Live10,
+  layer: layer5
 };
 
 // src/layers/session/file-system.ts
 init_esm_shims();
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { join as join2 } from "path";
-import { DateTime, Effect as Effect9, Layer as Layer5 } 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 Context3 } from "effect";
-var SessionStore = class extends Context3.Tag("@ferix/SessionStore")() {
+import { Context as Context6 } from "effect";
+var SessionStore = class extends Context6.Tag("@ferix/SessionStore")() {
 };
 
 // src/layers/session/file-system.ts
@@ -3474,25 +4417,25 @@ function generateSessionId(timestampMs) {
   const id = humanId({ separator: "-", capitalize: false });
   return `${id}-${timestampMs}`;
 }
-function ensureDir2(dirPath) {
-  return Effect9.tryPromise({
-    try: () => mkdir2(dirPath, { recursive: true }),
+function ensureDir4(dirPath) {
+  return Effect15.tryPromise({
+    try: () => mkdir5(dirPath, { recursive: true }),
     catch: (error) => new SessionStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "create",
       cause: error
     })
-  }).pipe(Effect9.asVoid);
+  }).pipe(Effect15.asVoid);
 }
 function getSessionPath(sessionId) {
-  return join2(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 Effect9.gen(function* () {
-    const parsed = yield* Effect9.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)}`,
@@ -3501,7 +4444,7 @@ function deserializeSession(json) {
       })
     });
     const validated = yield* decodeSession(parsed).pipe(
-      Effect9.mapError(
+      Effect15.mapError(
         (error) => new SessionStoreError({
           message: `Session validation failed: ${String(error)}`,
           operation: "get",
@@ -3512,23 +4455,23 @@ function deserializeSession(json) {
     return validated;
   });
 }
-var make3 = {
-  create: (originalTask) => Effect9.gen(function* () {
-    const sessionsDir = join2(process.cwd(), SESSIONS_DIR);
-    yield* ensureDir2(sessionsDir);
-    const now = yield* DateTime.now;
-    const timestampMs = DateTime.toEpochMillis(now);
+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);
     const sessionId = generateSessionId(timestampMs);
     const session = {
       id: sessionId,
-      createdAt: DateTime.formatIso(now),
+      createdAt: DateTime5.formatIso(now),
       status: "active",
       originalTask,
       completedTasks: []
     };
     const sessionPath = getSessionPath(sessionId);
-    yield* Effect9.tryPromise({
-      try: () => writeFile2(sessionPath, serializeSession(session), "utf-8"),
+    yield* Effect15.tryPromise({
+      try: () => writeFile4(sessionPath, serializeSession(session), "utf-8"),
       catch: (error) => new SessionStoreError({
         message: `Failed to write session file: ${sessionPath}`,
         operation: "create",
@@ -3537,10 +4480,10 @@ var make3 = {
     });
     return session;
   }),
-  get: (sessionId) => Effect9.gen(function* () {
+  get: (sessionId) => Effect15.gen(function* () {
     const sessionPath = getSessionPath(sessionId);
-    const content = yield* Effect9.tryPromise({
-      try: () => readFile2(sessionPath, "utf-8"),
+    const content = yield* Effect15.tryPromise({
+      try: () => readFile4(sessionPath, "utf-8"),
       catch: (error) => new SessionStoreError({
         message: `Failed to read session file: ${sessionPath}`,
         operation: "get",
@@ -3549,10 +4492,10 @@ var make3 = {
     });
     return yield* deserializeSession(content);
   }),
-  update: (sessionId, session) => Effect9.gen(function* () {
+  update: (sessionId, session) => Effect15.gen(function* () {
     const sessionPath = getSessionPath(sessionId);
-    yield* Effect9.tryPromise({
-      try: () => writeFile2(sessionPath, serializeSession(session), "utf-8"),
+    yield* Effect15.tryPromise({
+      try: () => writeFile4(sessionPath, serializeSession(session), "utf-8"),
       catch: (error) => new SessionStoreError({
         message: `Failed to update session file: ${sessionPath}`,
         operation: "update",
@@ -3561,37 +4504,37 @@ var make3 = {
     });
   })
 };
-var Live5 = Layer5.succeed(SessionStore, make3);
+var Live11 = Layer11.succeed(SessionStore, make6);
 var FileSystemSession = {
-  Live: Live5
+  Live: Live11
 };
 
 // src/layers/session/memory.ts
 init_esm_shims();
-import { DateTime as DateTime2, Effect as Effect10, Layer as Layer6, Ref as Ref4 } from "effect";
+import { DateTime as DateTime6, Effect as Effect16, Layer as Layer12, Ref as Ref7 } from "effect";
 function createMemorySessionStore(stateRef, counterRef) {
   return {
-    create: (originalTask) => Effect10.gen(function* () {
-      const state = yield* Ref4.get(stateRef);
-      const counter = yield* Ref4.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* DateTime2.now;
+      const now = yield* DateTime6.now;
       const session = {
         id: sessionId,
-        createdAt: DateTime2.formatIso(now),
+        createdAt: DateTime6.formatIso(now),
         status: "active",
         originalTask,
         completedTasks: []
       };
       state.set(sessionId, session);
-      yield* Ref4.set(stateRef, state);
+      yield* Ref7.set(stateRef, state);
       return session;
     }),
-    get: (sessionId) => Effect10.gen(function* () {
-      const state = yield* Ref4.get(stateRef);
+    get: (sessionId) => Effect16.gen(function* () {
+      const state = yield* Ref7.get(stateRef);
       const session = state.get(sessionId);
       if (!session) {
-        return yield* Effect10.fail(
+        return yield* Effect16.fail(
           new SessionStoreError({
             message: `Session not found: ${sessionId}`,
             operation: "get"
@@ -3600,10 +4543,10 @@ function createMemorySessionStore(stateRef, counterRef) {
       }
       return session;
     }),
-    update: (sessionId, session) => Effect10.gen(function* () {
-      const state = yield* Ref4.get(stateRef);
+    update: (sessionId, session) => Effect16.gen(function* () {
+      const state = yield* Ref7.get(stateRef);
       if (!state.has(sessionId)) {
-        return yield* Effect10.fail(
+        return yield* Effect16.fail(
           new SessionStoreError({
             message: `Session not found: ${sessionId}`,
             operation: "update"
@@ -3611,34 +4554,34 @@ function createMemorySessionStore(stateRef, counterRef) {
         );
       }
       state.set(sessionId, session);
-      yield* Ref4.set(stateRef, state);
+      yield* Ref7.set(stateRef, state);
     })
   };
 }
-function layer3() {
-  return Layer6.effect(
+function layer6() {
+  return Layer12.effect(
     SessionStore,
-    Effect10.gen(function* () {
-      const stateRef = yield* Ref4.make(/* @__PURE__ */ new Map());
-      const counterRef = yield* Ref4.make(0);
+    Effect16.gen(function* () {
+      const stateRef = yield* Ref7.make(/* @__PURE__ */ new Map());
+      const counterRef = yield* Ref7.make(0);
       return createMemorySessionStore(stateRef, counterRef);
     })
   );
 }
-var Live6 = layer3();
+var Live12 = layer6();
 var MemorySession = {
-  Live: Live6,
-  layer: layer3
+  Live: Live12,
+  layer: layer6
 };
 
 // src/layers/signal/ferix-parser.ts
 init_esm_shims();
-import { Effect as Effect11, Layer as Layer7, Ref as Ref5 } 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 Context4 } from "effect";
-var SignalParser = class extends Context4.Tag("@ferix/SignalParser")() {
+import { Context as Context7 } from "effect";
+var SignalParser = class extends Context7.Tag("@ferix/SignalParser")() {
 };
 
 // src/layers/signal/specs/index.ts
@@ -3646,7 +4589,7 @@ init_esm_shims();
 
 // src/layers/signal/specs/check.ts
 init_esm_shims();
-import { Schema as S13 } from "effect";
+import { Schema as S15 } from "effect";
 
 // src/layers/signal/specs/registry.ts
 init_esm_shims();
@@ -3703,7 +4646,7 @@ var checkPassedSpec = {
   parse: (text) => {
     if (CHECK_PASSED.test(text)) {
       const raw = { _tag: "CheckPassed" };
-      const result = S13.decodeUnknownEither(CheckPassedSignalSchema)(raw);
+      const result = S15.decodeUnknownEither(CheckPassedSignalSchema)(raw);
       if (result._tag === "Right") {
         return [result.right];
       }
@@ -3719,7 +4662,7 @@ var checkFailedSpec = {
   parse: (text) => {
     if (CHECK_FAILED.test(text)) {
       const raw = { _tag: "CheckFailed" };
-      const result = S13.decodeUnknownEither(CheckFailedSignalSchema)(raw);
+      const result = S15.decodeUnknownEither(CheckFailedSignalSchema)(raw);
       if (result._tag === "Right") {
         return [result.right];
       }
@@ -3733,7 +4676,7 @@ signalSpecRegistry.register(checkFailedSpec);
 
 // src/layers/signal/specs/criteria.ts
 init_esm_shims();
-import { Schema as S14 } from "effect";
+import { Schema as S16 } from "effect";
 var CRITERIA_BLOCK = /<ferix:criteria task="(\d+)">([\s\S]*?)<\/ferix:criteria>/g;
 var CRITERION = /<criterion id="([^"]+)">([^<]+)<\/criterion>/g;
 var CRITERION_PASSED = /<ferix:criterion-passed id="([\d.c]+)"\/>/g;
@@ -3764,7 +4707,7 @@ var criteriaDefinedSpec = {
           taskId: match[1],
           criteria
         };
-        const result = S14.decodeUnknownEither(CriteriaDefinedSignalSchema)(raw);
+        const result = S16.decodeUnknownEither(CriteriaDefinedSignalSchema)(raw);
         if (result._tag === "Right") {
           signals.push(result.right);
         }
@@ -3783,7 +4726,7 @@ var criterionPassedSpec = {
     for (const m of text.matchAll(resetRegex(CRITERION_PASSED))) {
       if (m[1]) {
         const raw = { _tag: "CriterionPassed", criterionId: m[1] };
-        const result = S14.decodeUnknownEither(CriterionPassedSignalSchema)(raw);
+        const result = S16.decodeUnknownEither(CriterionPassedSignalSchema)(raw);
         if (result._tag === "Right") {
           signals.push(result.right);
         }
@@ -3806,7 +4749,7 @@ var criterionFailedSpec = {
           criterionId: m[1],
           reason: m[2] || "Unknown reason"
         };
-        const result = S14.decodeUnknownEither(CriterionFailedSignalSchema)(raw);
+        const result = S16.decodeUnknownEither(CriterionFailedSignalSchema)(raw);
         if (result._tag === "Right") {
           signals.push(result.right);
         }
@@ -3820,9 +4763,88 @@ signalSpecRegistry.register(criteriaDefinedSpec);
 signalSpecRegistry.register(criterionPassedSpec);
 signalSpecRegistry.register(criterionFailedSpec);
 
+// src/layers/signal/specs/guardrail.ts
+init_esm_shims();
+import { Schema as S17 } from "effect";
+var GUARDRAIL = /<ferix:guardrail\s+severity="(warning|critical)"\s*>([\s\S]*?)<\/ferix:guardrail>/g;
+var PATTERN = /<pattern>([\s\S]*?)<\/pattern>/;
+var SIGN = /<sign>([\s\S]*?)<\/sign>/;
+var AVOIDANCE = /<avoidance>([\s\S]*?)<\/avoidance>/;
+var guardrailSpec = {
+  tag: "Guardrail",
+  closingTag: "</ferix:guardrail>",
+  schema: GuardrailSignalSchema,
+  parse: (text) => {
+    const signals = [];
+    const matches = text.matchAll(GUARDRAIL);
+    for (const match of matches) {
+      const severity = match[1];
+      const content = match[2] || "";
+      const patternMatch = content.match(PATTERN);
+      const signMatch = content.match(SIGN);
+      const avoidanceMatch = content.match(AVOIDANCE);
+      const pattern = patternMatch?.[1]?.trim() || "";
+      const sign = signMatch?.[1]?.trim() || "";
+      const avoidance = avoidanceMatch?.[1]?.trim() || "";
+      if (!(pattern && sign && avoidance)) {
+        continue;
+      }
+      const raw = {
+        _tag: "Guardrail",
+        pattern,
+        sign,
+        avoidance,
+        severity
+      };
+      const result = S17.decodeUnknownEither(GuardrailSignalSchema)(raw);
+      if (result._tag === "Right") {
+        signals.push(result.right);
+      }
+    }
+    return signals;
+  },
+  keyFields: (s) => s.pattern.slice(0, 50)
+};
+signalSpecRegistry.register(guardrailSpec);
+
+// src/layers/signal/specs/learning.ts
+init_esm_shims();
+import { Schema as S18 } from "effect";
+var LEARNING = /<ferix:learning(?:\s+category="(success|failure|optimization)")?\s*>([\s\S]*?)<\/ferix:learning>/g;
+var learningSpec = {
+  tag: "Learning",
+  closingTag: "</ferix:learning>",
+  schema: LearningSignalSchema,
+  parse: (text) => {
+    const signals = [];
+    const matches = text.matchAll(LEARNING);
+    for (const match of matches) {
+      const category = match[1];
+      const content = match[2]?.trim() || "";
+      if (!content) {
+        continue;
+      }
+      const raw = {
+        _tag: "Learning",
+        content
+      };
+      if (category) {
+        raw.category = category;
+      }
+      const result = S18.decodeUnknownEither(LearningSignalSchema)(raw);
+      if (result._tag === "Right") {
+        signals.push(result.right);
+      }
+    }
+    return signals;
+  },
+  keyFields: (s) => s.content.slice(0, 50)
+};
+signalSpecRegistry.register(learningSpec);
+
 // src/layers/signal/specs/loop-complete.ts
 init_esm_shims();
-import { Schema as S15 } from "effect";
+import { Schema as S19 } from "effect";
 var LOOP_COMPLETE = /<ferix:complete>/;
 var loopCompleteSpec = {
   tag: "LoopComplete",
@@ -3831,7 +4853,7 @@ var loopCompleteSpec = {
   parse: (text) => {
     if (LOOP_COMPLETE.test(text)) {
       const raw = { _tag: "LoopComplete" };
-      const result = S15.decodeUnknownEither(LoopCompleteSignalSchema)(raw);
+      const result = S19.decodeUnknownEither(LoopCompleteSignalSchema)(raw);
       if (result._tag === "Right") {
         return [result.right];
       }
@@ -3844,7 +4866,7 @@ signalSpecRegistry.register(loopCompleteSpec);
 
 // src/layers/signal/specs/phases.ts
 init_esm_shims();
-import { Schema as S16 } from "effect";
+import { Schema as S20 } from "effect";
 var PHASES_BLOCK = /<ferix:phases task="(\d+)">([\s\S]*?)<\/ferix:phases>/;
 var PHASE = /<phase id="([\d.]+)">([^<]+)<\/phase>/g;
 var PHASE_START = /<ferix:phase-start id="([\d.]+)"\/>/g;
@@ -3877,7 +4899,7 @@ var phasesDefinedSpec = {
       taskId: match[1],
       phases
     };
-    const result = S16.decodeUnknownEither(PhasesDefinedSignalSchema)(raw);
+    const result = S20.decodeUnknownEither(PhasesDefinedSignalSchema)(raw);
     if (result._tag === "Left") {
       return [];
     }
@@ -3894,7 +4916,7 @@ var phaseStartedSpec = {
     for (const m of text.matchAll(resetRegex2(PHASE_START))) {
       if (m[1]) {
         const raw = { _tag: "PhaseStarted", phaseId: m[1] };
-        const result = S16.decodeUnknownEither(PhaseStartedSignalSchema)(raw);
+        const result = S20.decodeUnknownEither(PhaseStartedSignalSchema)(raw);
         if (result._tag === "Right") {
           signals.push(result.right);
         }
@@ -3913,7 +4935,7 @@ var phaseCompletedSpec = {
     for (const m of text.matchAll(resetRegex2(PHASE_DONE))) {
       if (m[1]) {
         const raw = { _tag: "PhaseCompleted", phaseId: m[1] };
-        const result = S16.decodeUnknownEither(PhaseCompletedSignalSchema)(raw);
+        const result = S20.decodeUnknownEither(PhaseCompletedSignalSchema)(raw);
         if (result._tag === "Right") {
           signals.push(result.right);
         }
@@ -3936,7 +4958,7 @@ var phaseFailedSpec = {
           phaseId: m[1],
           reason: m[2] || "Unknown reason"
         };
-        const result = S16.decodeUnknownEither(PhaseFailedSignalSchema)(raw);
+        const result = S20.decodeUnknownEither(PhaseFailedSignalSchema)(raw);
         if (result._tag === "Right") {
           signals.push(result.right);
         }
@@ -3953,7 +4975,7 @@ signalSpecRegistry.register(phaseFailedSpec);
 
 // src/layers/signal/specs/review.ts
 init_esm_shims();
-import { Schema as S17 } from "effect";
+import { Schema as S21 } from "effect";
 var REVIEW_COMPLETE = /<ferix:review-complete\/>/;
 var REVIEW_CHANGES = /<ferix:review-changes-made\/>/;
 var reviewCompleteSpec = {
@@ -3966,7 +4988,7 @@ var reviewCompleteSpec = {
     }
     const changesMade = REVIEW_CHANGES.test(text);
     const raw = { _tag: "ReviewComplete", changesMade };
-    const result = S17.decodeUnknownEither(ReviewCompleteSignalSchema)(raw);
+    const result = S21.decodeUnknownEither(ReviewCompleteSignalSchema)(raw);
     if (result._tag === "Right") {
       return [result.right];
     }
@@ -3978,7 +5000,7 @@ signalSpecRegistry.register(reviewCompleteSpec);
 
 // src/layers/signal/specs/task-complete.ts
 init_esm_shims();
-import { Schema as S18 } from "effect";
+import { Schema as S22 } from "effect";
 var TASK_COMPLETE = /<ferix:task-complete id="(\d+)">([\s\S]*?)<\/ferix:task-complete>/;
 var SUMMARY = /<summary>([\s\S]*?)<\/summary>/;
 var FILES_MODIFIED = /<files-modified>([\s\S]*?)<\/files-modified>/;
@@ -4009,7 +5031,7 @@ var taskCompleteSpec = {
       filesModified: parseFileList(filesModifiedMatch?.[1]),
       filesCreated: parseFileList(filesCreatedMatch?.[1])
     };
-    const result = S18.decodeUnknownEither(TaskCompleteSignalSchema)(raw);
+    const result = S22.decodeUnknownEither(TaskCompleteSignalSchema)(raw);
     if (result._tag === "Right") {
       return [result.right];
     }
@@ -4021,7 +5043,7 @@ signalSpecRegistry.register(taskCompleteSpec);
 
 // src/layers/signal/specs/tasks.ts
 init_esm_shims();
-import { Schema as S19 } from "effect";
+import { Schema as S23 } from "effect";
 var TASKS_BLOCK = /<ferix:tasks>([\s\S]*?)<\/ferix:tasks>/;
 var TASK = /<task id="(\d+)">([^<]+)<\/task>/g;
 function resetRegex3(pattern) {
@@ -4051,7 +5073,7 @@ var tasksDefinedSpec = {
       return [];
     }
     const raw = { _tag: "TasksDefined", tasks };
-    const result = S19.decodeUnknownEither(TasksDefinedSignalSchema)(raw);
+    const result = S23.decodeUnknownEither(TasksDefinedSignalSchema)(raw);
     if (result._tag === "Left") {
       return [];
     }
@@ -4064,20 +5086,20 @@ signalSpecRegistry.register(tasksDefinedSpec);
 // src/layers/signal/ferix-parser.ts
 var MAX_BUFFER_SIZE = 1024 * 1024;
 function createAccumulatorImpl() {
-  return Effect11.gen(function* () {
-    const chunksRef = yield* Ref5.make([]);
-    const emittedRef = yield* Ref5.make(/* @__PURE__ */ new Set());
-    const feed = (text) => Effect11.gen(function* () {
-      const chunks = yield* Ref5.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* Ref5.set(chunksRef, [
+        yield* Ref8.set(chunksRef, [
           buffer.slice(buffer.length - MAX_BUFFER_SIZE)
         ]);
       }
       const signals = signalSpecRegistry.parseAll(buffer);
-      const emitted = yield* Ref5.get(emittedRef);
+      const emitted = yield* Ref8.get(emittedRef);
       const newSignals = signals.filter((signal) => {
         const key = signalSpecRegistry.getSignalKey(signal);
         if (emitted.has(key)) {
@@ -4089,55 +5111,64 @@ function createAccumulatorImpl() {
       if (newSignals.length > 0) {
         const lastEndPos = signalSpecRegistry.findLastCompleteSignalEnd(buffer);
         if (lastEndPos > 0 && lastEndPos < buffer.length) {
-          yield* Ref5.set(chunksRef, [buffer.slice(lastEndPos)]);
+          yield* Ref8.set(chunksRef, [buffer.slice(lastEndPos)]);
         }
       }
-      yield* Ref5.set(emittedRef, emitted);
+      yield* Ref8.set(emittedRef, emitted);
       return newSignals;
     });
-    const flush = () => Effect11.gen(function* () {
-      const chunks = yield* Ref5.get(chunksRef);
+    const flush = () => Effect17.gen(function* () {
+      const chunks = yield* Ref8.get(chunksRef);
       const buffer = chunks.join("");
-      yield* Ref5.set(chunksRef, []);
-      const emitted = yield* Ref5.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* Ref5.set(emittedRef, /* @__PURE__ */ new Set());
+      yield* Ref8.set(emittedRef, /* @__PURE__ */ new Set());
       return result;
     });
     return { feed, flush };
   });
 }
-var make4 = {
-  parse: (text) => Effect11.succeed(signalSpecRegistry.parseAll(text)),
+var make7 = {
+  parse: (text) => Effect17.succeed(signalSpecRegistry.parseAll(text)),
   createAccumulator: createAccumulatorImpl
 };
-var Live7 = Layer7.succeed(SignalParser, make4);
+var Live13 = Layer13.succeed(SignalParser, make7);
 var FerixParser = {
-  Live: Live7
+  Live: Live13
 };
 
 // src/layers/index.ts
-var ProductionLayers = Layer8.mergeAll(
+var ProductionLayers = Layer14.mergeAll(
   ClaudeCLI.Live,
   FerixParser.Live,
   FileSystemPlan.Live,
-  FileSystemSession.Live
+  FileSystemSession.Live,
+  FileSystemProgress.Live,
+  FileSystemGuardrails.Live,
+  FileSystemGit.Live
 );
-var TestLayers = Layer8.mergeAll(
+var TestLayers = Layer14.mergeAll(
   Mock.Live,
   FerixParser.Live,
   MemoryPlan.Live,
-  MemorySession.Live
+  MemorySession.Live,
+  MemoryProgress.Live,
+  MemoryGuardrails.Live,
+  MemoryGit.Live
 );
 function createTestLayers(events) {
-  return Layer8.mergeAll(
+  return Layer14.mergeAll(
     Mock.layer({ events }),
     FerixParser.Live,
     MemoryPlan.layer(),
-    MemorySession.layer()
+    MemorySession.layer(),
+    MemoryProgress.layer(),
+    MemoryGuardrails.layer(),
+    MemoryGit.layer()
   );
 }
 
@@ -4146,42 +5177,42 @@ init_esm_shims();
 
 // src/orchestrator/loop.ts
 init_esm_shims();
-import { DateTime as DateTime6, Effect as Effect16, Option, pipe as pipe3, Ref as Ref9, 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 DateTime4, Effect as Effect14, pipe, Ref as Ref7, 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 mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { join as join3 } from "path";
-import { Effect as Effect12 } from "effect";
-var PLANS_DIR2 = ".ferix/plans";
-function ensureDir3(dirPath) {
-  return Effect12.tryPromise({
-    try: () => mkdir3(dirPath, { recursive: true }),
+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 Effect18.tryPromise({
+    try: () => mkdir6(dirPath, { recursive: true }),
     catch: (error) => new PlanStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "create",
       cause: error
     })
-  }).pipe(Effect12.asVoid);
+  }).pipe(Effect18.asVoid);
 }
-function getSessionDir2(sessionId) {
-  return join3(process.cwd(), PLANS_DIR2, sessionId);
+function getSessionDir4(sessionId) {
+  return join6(process.cwd(), PLANS_DIR4, sessionId);
 }
 function getTasksMdPath(sessionId) {
-  return join3(getSessionDir2(sessionId), "tasks.md");
+  return join6(getSessionDir4(sessionId), "tasks.md");
 }
 function writeTasksMd(sessionId, tasks) {
-  return Effect12.gen(function* () {
-    const sessionDir = getSessionDir2(sessionId);
-    yield* ensureDir3(sessionDir);
+  return Effect18.gen(function* () {
+    const sessionDir = getSessionDir4(sessionId);
+    yield* ensureDir5(sessionDir);
     const tasksMdPath = getTasksMdPath(sessionId);
     const content = formatTasksMd(tasks);
-    yield* Effect12.tryPromise({
-      try: () => writeFile3(tasksMdPath, content, "utf-8"),
+    yield* Effect18.tryPromise({
+      try: () => writeFile5(tasksMdPath, content, "utf-8"),
       catch: (error) => new PlanStoreError({
         message: `Failed to write tasks.md: ${tasksMdPath}`,
         operation: "create",
@@ -4325,6 +5356,32 @@ eventMappingRegistry.registerSignalMapper({
     }
   })
 });
+eventMappingRegistry.registerSignalMapper({
+  tag: "Learning",
+  map: (signal, context) => ({
+    _tag: "LearningRecorded",
+    iteration: 0,
+    // Will be overwritten by iteration stream
+    content: signal.content,
+    category: signal.category,
+    timestamp: context.timestamp
+  })
+});
+eventMappingRegistry.registerSignalMapper({
+  tag: "Guardrail",
+  map: (signal, context) => ({
+    _tag: "GuardrailAdded",
+    id: `gr-pending-${context.timestamp}`,
+    // Temp ID, real one assigned in iteration
+    iteration: 0,
+    // Will be overwritten by iteration stream
+    pattern: signal.pattern,
+    sign: signal.sign,
+    avoidance: signal.avoidance,
+    severity: signal.severity,
+    timestamp: context.timestamp
+  })
+});
 
 // src/orchestrator/mapping/index.ts
 function mapLLMEventToDomain(event, context) {
@@ -4336,7 +5393,7 @@ function mapSignalToDomain(signal, context) {
 
 // src/orchestrator/plan-updates.ts
 init_esm_shims();
-import { DateTime as DateTime3, Effect as Effect13, Ref as Ref6 } from "effect";
+import { DateTime as DateTime7, Effect as Effect19, Ref as Ref9 } from "effect";
 
 // src/orchestrator/plan-updates/index.ts
 init_esm_shims();
@@ -4548,6 +5605,20 @@ planUpdateRegistry.register({
   } : void 0
 });
 
+// src/orchestrator/plan-updates/handlers/guardrail.ts
+init_esm_shims();
+planUpdateRegistry.register({
+  tag: "Guardrail",
+  handle: (_signal, _currentPlan, _context) => void 0
+});
+
+// src/orchestrator/plan-updates/handlers/learning.ts
+init_esm_shims();
+planUpdateRegistry.register({
+  tag: "Learning",
+  handle: (_signal, _currentPlan, _context) => void 0
+});
+
 // src/orchestrator/plan-updates/handlers/phase-lifecycle.ts
 init_esm_shims();
 planUpdateRegistry.register({
@@ -4627,9 +5698,9 @@ function persistPlanUpdate(planStore, plan, operation) {
     tasks: plan.tasks
   }) : planStore.update(plan.id, plan);
   return storeOp.pipe(
-    Effect13.map(() => null),
-    Effect13.catchAll(
-      (error) => Effect13.succeed({
+    Effect19.map(() => null),
+    Effect19.catchAll(
+      (error) => Effect19.succeed({
         _tag: "PlanUpdateFailed",
         operation,
         error: error.message,
@@ -4639,10 +5710,10 @@ function persistPlanUpdate(planStore, plan, operation) {
   );
 }
 function updatePlanFromSignal(currentPlanRef, persistenceStateRef, signal, sessionId, originalTask) {
-  return Effect13.gen(function* () {
-    const currentPlan = yield* Ref6.get(currentPlanRef);
-    const now = yield* DateTime3.now;
-    const timestamp = DateTime3.formatIso(now);
+  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, {
       sessionId,
       originalTask,
@@ -4652,8 +5723,8 @@ function updatePlanFromSignal(currentPlanRef, persistenceStateRef, signal, sessi
       return [];
     }
     const { plan, operation, eventTag } = updateResult;
-    yield* Ref6.set(currentPlanRef, plan);
-    yield* Ref6.update(persistenceStateRef, (state) => ({
+    yield* Ref9.set(currentPlanRef, plan);
+    yield* Ref9.update(persistenceStateRef, (state) => ({
       dirty: true,
       pendingOperation: state.pendingOperation === "create" ? "create" : operation
     }));
@@ -4661,12 +5732,12 @@ function updatePlanFromSignal(currentPlanRef, persistenceStateRef, signal, sessi
   });
 }
 function flushPlanPersistence(planStore, currentPlanRef, persistenceStateRef) {
-  return Effect13.gen(function* () {
-    const state = yield* Ref6.get(persistenceStateRef);
+  return Effect19.gen(function* () {
+    const state = yield* Ref9.get(persistenceStateRef);
     if (!(state.dirty && state.pendingOperation)) {
       return [];
     }
-    const plan = yield* Ref6.get(currentPlanRef);
+    const plan = yield* Ref9.get(currentPlanRef);
     if (!plan) {
       return [];
     }
@@ -4679,7 +5750,7 @@ function flushPlanPersistence(planStore, currentPlanRef, persistenceStateRef) {
     if (failureEvent) {
       events.push(failureEvent);
     }
-    yield* Ref6.set(persistenceStateRef, {
+    yield* Ref9.set(persistenceStateRef, {
       dirty: false,
       pendingOperation: null
     });
@@ -4738,9 +5809,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.
 
@@ -4781,14 +5855,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;
 }
@@ -4929,12 +6006,12 @@ Begin.`);
 
 // src/orchestrator/discovery.ts
 function processTextSignals(signalParser, text, context) {
-  return Effect14.gen(function* () {
+  return Effect20.gen(function* () {
     const events = [];
     const parsedSignals = [];
     const signals = yield* signalParser.parse(text).pipe(
-      Effect14.tapError(
-        (error) => Effect14.logDebug(
+      Effect20.tapError(
+        (error) => Effect20.logDebug(
           "Signal parsing failed, continuing with empty signals",
           {
             error: String(error),
@@ -4942,7 +6019,7 @@ function processTextSignals(signalParser, text, context) {
           }
         )
       ),
-      Effect14.orElseSucceed(() => [])
+      Effect20.orElseSucceed(() => [])
     );
     for (const signal of signals) {
       events.push(mapSignalToDomain(signal, context));
@@ -4952,7 +6029,7 @@ function processTextSignals(signalParser, text, context) {
   });
 }
 function processLLMEvent(signalParser, llmEvent, context) {
-  return Effect14.gen(function* () {
+  return Effect20.gen(function* () {
     const domainEvent = mapLLMEventToDomain(llmEvent, context);
     const events = [domainEvent];
     const allSignals = [];
@@ -4995,12 +6072,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(
-    Effect14.gen(function* () {
-      const startTimeUtc = yield* DateTime4.now;
-      const startTime = DateTime4.toEpochMillis(startTimeUtc);
-      const persistenceStateRef = yield* Ref7.make({
+    Effect20.gen(function* () {
+      const startTimeUtc = yield* DateTime8.now;
+      const startTime = DateTime8.toEpochMillis(startTimeUtc);
+      const persistenceStateRef = yield* Ref10.make({
         dirty: false,
         pendingOperation: null
       });
@@ -5014,7 +6091,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)}`,
@@ -5024,10 +6101,10 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
         ),
         Stream7.flatMap(
           (llmEvent) => Stream7.unwrap(
-            Effect14.gen(function* () {
-              const now = yield* DateTime4.now;
+            Effect20.gen(function* () {
+              const now = yield* DateTime8.now;
               const context = {
-                timestamp: DateTime4.toEpochMillis(now)
+                timestamp: DateTime8.toEpochMillis(now)
               };
               const result = yield* processLLMEvent(
                 signalParser,
@@ -5061,27 +6138,27 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
         )
       );
       const completionStream = Stream7.fromEffect(
-        Effect14.gen(function* () {
+        Effect20.gen(function* () {
           const persistEvents = yield* flushPlanPersistence(
             planStore,
             currentPlanRef,
             persistenceStateRef
           );
-          const plan = yield* Ref7.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(
-              Effect14.tapError(
-                (error) => Effect14.logDebug("Failed to write tasks.md, continuing", {
+              Effect20.tapError(
+                (error) => Effect20.logDebug("Failed to write tasks.md, continuing", {
                   error: String(error)
                 })
               ),
-              Effect14.orElseSucceed(() => void 0)
+              Effect20.orElseSucceed(() => void 0)
             );
           }
-          const endTimeUtc = yield* DateTime4.now;
-          const endTime = DateTime4.toEpochMillis(endTimeUtc);
+          const endTimeUtc = yield* DateTime8.now;
+          const endTime = DateTime8.toEpochMillis(endTimeUtc);
           const discoveryCompleted = {
             _tag: "DiscoveryCompleted",
             taskCount,
@@ -5102,15 +6179,15 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
 
 // src/orchestrator/iteration.ts
 init_esm_shims();
-import { DateTime as DateTime5, Effect as Effect15, pipe as pipe2, Ref as Ref8, 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 Effect15.gen(function* () {
+  return Effect21.gen(function* () {
     const events = [];
     let completed = false;
     const parsedSignals = [];
     const signals = yield* signalParser.parse(text).pipe(
-      Effect15.tapError(
-        (error) => Effect15.logDebug(
+      Effect21.tapError(
+        (error) => Effect21.logDebug(
           "Signal parsing failed, continuing with empty signals",
           {
             error: String(error),
@@ -5118,7 +6195,7 @@ function processTextSignals2(signalParser, text, context) {
           }
         )
       ),
-      Effect15.orElseSucceed(() => [])
+      Effect21.orElseSucceed(() => [])
     );
     for (const signal of signals) {
       events.push(mapSignalToDomain(signal, context));
@@ -5131,7 +6208,7 @@ function processTextSignals2(signalParser, text, context) {
   });
 }
 function processLLMEvent2(signalParser, llmEvent, context) {
-  return Effect15.gen(function* () {
+  return Effect21.gen(function* () {
     const domainEvent = mapLLMEventToDomain(llmEvent, context);
     const events = [domainEvent];
     let completed = false;
@@ -5162,11 +6239,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(
-    Effect15.gen(function* () {
-      const currentPlan = yield* Ref8.get(currentPlanRef);
-      const persistenceStateRef = yield* Ref8.make({
+    Effect21.gen(function* () {
+      const currentPlan = yield* Ref11.get(currentPlanRef);
+      const persistenceStateRef = yield* Ref11.make({
         dirty: false,
         pendingOperation: null
       });
@@ -5174,7 +6251,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)}`,
@@ -5184,10 +6264,10 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
         ),
         Stream8.flatMap(
           (llmEvent) => Stream8.unwrap(
-            Effect15.gen(function* () {
-              const now = yield* DateTime5.now;
+            Effect21.gen(function* () {
+              const now = yield* DateTime9.now;
               const context = {
-                timestamp: DateTime5.toEpochMillis(now)
+                timestamp: DateTime9.toEpochMillis(now)
               };
               const result = yield* processLLMEvent2(
                 signalParser,
@@ -5206,7 +6286,7 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
                 events.push(...planEvents);
               }
               if (result.completed) {
-                yield* Ref8.set(loopCompletedRef, true);
+                yield* Ref11.set(loopCompletedRef, true);
               }
               return Stream8.fromIterable(events);
             })
@@ -5225,7 +6305,7 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
         )
       );
       const completionStream = Stream8.fromEffect(
-        Effect15.gen(function* () {
+        Effect21.gen(function* () {
           const persistEvents = yield* flushPlanPersistence(
             planStore,
             currentPlanRef,
@@ -5250,13 +6330,14 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
 // src/orchestrator/loop.ts
 function runLoop(config) {
   return Stream9.unwrap(
-    Effect16.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(
-        Effect16.mapError(
+        Effect22.mapError(
           (e) => new OrchestratorError({
             message: `Failed to create session: ${e.message}`,
             phase: "setup",
@@ -5264,10 +6345,39 @@ function runLoop(config) {
           })
         )
       );
-      const startTimeUtc = yield* DateTime6.now;
-      const startTime = DateTime6.toEpochMillis(startTimeUtc);
-      const loopCompletedRef = yield* Ref9.make(false);
-      const currentPlanRef = yield* Ref9.make(void 0);
+      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 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",
@@ -5280,12 +6390,13 @@ function runLoop(config) {
         planStore,
         currentPlanRef,
         config,
-        session.id
+        session.id,
+        worktreePath
       );
       const iterationsStream = Stream9.unfoldEffect(
         1,
-        (iteration) => Effect16.gen(function* () {
-          const completed = yield* Ref9.get(loopCompletedRef);
+        (iteration) => Effect22.gen(function* () {
+          const completed = yield* Ref12.get(loopCompletedRef);
           if (completed || iteration > maxIterations) {
             return Option.none();
           }
@@ -5301,27 +6412,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)
-      Effect16.catchAll(
-        (error) => Effect16.succeed(
+      Effect22.catchAll(
+        (error) => Effect22.succeed(
           Stream9.succeed({
             _tag: "LoopFailed",
             error: {
@@ -5334,12 +6449,21 @@ function runLoop(config) {
     )
   );
 }
-function createCompletionStream(sessionStore, session, config, startTime, loopCompletedRef) {
-  return Stream9.fromEffect(
-    Effect16.gen(function* () {
-      const endTimeUtc = yield* DateTime6.now;
-      const durationMs = DateTime6.toEpochMillis(endTimeUtc) - startTime;
-      const completed = yield* Ref9.get(loopCompletedRef);
+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* Ref12.get(loopCompletedRef);
+      yield* git.commitChanges(session.id, `feat: complete session ${session.id}`).pipe(
+        Effect22.tapError(
+          (error) => Effect22.logDebug("Final commit failed, continuing", {
+            sessionId: session.id,
+            error: String(error)
+          })
+        ),
+        Effect22.orElseSucceed(() => void 0)
+      );
       const summary = {
         iterations: config.maxIterations,
         success: completed,
@@ -5351,16 +6475,16 @@ function createCompletionStream(sessionStore, session, config, startTime, loopCo
         ...session,
         status: completed ? "completed" : "paused"
       }).pipe(
-        Effect16.tapError(
-          (error) => Effect16.logDebug("Session update failed, continuing", {
+        Effect22.tapError(
+          (error) => Effect22.logDebug("Session update failed, continuing", {
             sessionId: session.id,
             error: String(error)
           })
         ),
-        Effect16.orElseSucceed(() => void 0)
+        Effect22.orElseSucceed(() => void 0)
       );
-      const event = { _tag: "LoopCompleted", summary };
-      return event;
+      const loopCompleted = { _tag: "LoopCompleted", summary };
+      return Stream9.succeed(loopCompleted);
     })
   );
 }
@@ -5369,7 +6493,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) => Effect17.sync(() => onEvent(event)))) : events;
+  const eventsWithCallback = onEvent ? events.pipe(Stream10.tap((event) => Effect23.sync(() => onEvent(event)))) : events;
   const eventsWithLayers = eventsWithCallback.pipe(
     Stream10.provideLayer(ProductionLayers)
   );
@@ -5382,7 +6506,7 @@ function run(options) {
 function runTest(options, mockEvents) {
   const { config, onEvent } = options;
   const events = runLoop(config);
-  const eventsWithCallback = onEvent ? events.pipe(Stream10.tap((event) => Effect17.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);
@@ -5390,11 +6514,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(Effect17.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(Effect17.runPromise);
+  return run({ config, consumer: consumerType }).pipe(Effect23.runPromise);
 }
 
 // src/services/index.ts
@@ -5402,7 +6526,7 @@ init_esm_shims();
 
 // src/index.ts
 var program = new Command();
-program.name("ferix-code").description("Composable RALPH loops for AI coding agents").version(package_default.version).argument("<task>", "Task description or path to PRD file").option("-i, --iterations <n>", "Maximum iterations", "1").option("-v, --verify <commands...>", "Verification commands").option("--branch <name>", "Git branch to create").option("--push", "Push branch after completion").option("--pr", "Create PR after pushing").action(async (task, options) => {
+program.name("ferix-code").description("Composable RALPH loops for AI coding agents").version(package_default.version, "-v, --version", "Output the version number").argument("<task>", "Task description or path to PRD file").option("-i, --iterations <n>", "Maximum iterations", "1").option("-c, --verify <commands...>", "Verification commands to run").option("--branch <name>", "Git branch to create").option("--push", "Push branch after completion").option("--pr", "Create PR after pushing").action(async (task, options) => {
   const config = {
     task,
     maxIterations: Number.parseInt(options.iterations, 10),
@@ -5447,11 +6571,23 @@ export {
   ExecutionModeSchema,
   FerixParser,
   FileLoggerConfigSchema,
+  FileSystemGit,
+  FileSystemGuardrails,
   FileSystemPlan,
+  FileSystemProgress,
   FileSystemSession,
   GeneratedTaskListSchema,
   GeneratedTaskSchema,
   GeneratedTaskStatusSchema,
+  Git,
+  GitError,
+  GuardrailAddedEventSchema,
+  GuardrailSchema,
+  GuardrailSeveritySchema,
+  GuardrailSignalSchema,
+  GuardrailsFileSchema,
+  GuardrailsStore,
+  GuardrailsStoreError,
   IterationCompletedEventSchema,
   IterationStartedEventSchema,
   LLM,
@@ -5461,6 +6597,9 @@ export {
   LLMToolEndEventSchema,
   LLMToolStartEventSchema,
   LLMToolUseEventSchema,
+  LearningCategorySchema,
+  LearningRecordedEventSchema,
+  LearningSignalSchema,
   LogEntrySchema,
   LogLevelSchema,
   LoopCompleteSignalSchema,
@@ -5471,7 +6610,10 @@ export {
   LoopStartedEventSchema,
   LoopStatusSchema,
   LoopSummarySchema,
+  MemoryGit,
+  MemoryGuardrails,
   MemoryPlan,
+  MemoryProgress,
   MemorySession,
   Mock,
   Mock as MockLLM,
@@ -5501,6 +6643,12 @@ export {
   PlanUpdateFailedEventSchema,
   PlanUpdatedEventSchema,
   ProductionLayers,
+  ProgressActionSchema,
+  ProgressEntrySchema,
+  ProgressFileSchema,
+  ProgressStore,
+  ProgressStoreError,
+  ProgressUpdatedEventSchema,
   PromptConfigSchema,
   ReviewCompleteDataSchema,
   ReviewCompleteEventSchema,
@@ -5535,15 +6683,21 @@ export {
   ToolStartEventSchema,
   ToolUseEventSchema,
   ViewModeSchema,
+  WorktreeCreatedEventSchema,
+  WorktreeRemovedEventSchema,
   buildPrompt,
   collectEvents,
   createHeadlessConsumer,
   createTUIConsumer,
   createTestLayers,
+  decodeGuardrail,
+  decodeGuardrailsFile,
   decodeLLMEvent,
   decodeLoopConfig,
   decodePlan,
   decodePlanData,
+  decodeProgressEntry,
+  decodeProgressFile,
   decodeSession,
   decodeSignal,
   decodeSignalSync,