ferix-code 0.0.2 → 0.0.3

package/dist/index.js

@@ -20,11 +20,11 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../../node_modules/.bun/tsup@8.5.1+f2002c7b4d902bba/node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/.bun/tsup@8.5.1+7ba260eccd18f7a2/node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
 var init_esm_shims = __esm({
-  "../../node_modules/.bun/tsup@8.5.1+f2002c7b4d902bba/node_modules/tsup/assets/esm_shims.js"() {
+  "../../node_modules/.bun/tsup@8.5.1+7ba260eccd18f7a2/node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
   }
 });
@@ -32,7 +32,6 @@ var init_esm_shims = __esm({
 // src/commands/code/consumers/tui/tags/registry.ts
 var registry_exports = {};
 __export(registry_exports, {
-  createTagRendererRegistry: () => createTagRendererRegistry,
   tagRendererRegistry: () => tagRendererRegistry
 });
 function createTagRendererRegistry() {
@@ -71,7 +70,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "ferix-code",
-  version: "0.0.2",
+  version: "0.0.3",
   description: "Composable RALPH loops for AI coding agents - v2 with Effect",
   type: "module",
   bin: {
@@ -87,6 +86,10 @@ var package_default = {
     "check-types": "tsc --noEmit",
     test: "bun test",
     "test:watch": "bun test --watch",
+    "test:unit": "bun test tests/unit",
+    "test:integration": "bun test tests/integration",
+    "test:errors": "bun test tests/error-paths",
+    "test:properties": "bun test tests/properties",
     bump: "npm version prerelease --preid=beta --workspaces=false && bun run build && bun publish --tag beta",
     patch: "npm version patch --workspaces=false && bun run build && bun publish --tag latest"
   },
@@ -103,6 +106,7 @@ var package_default = {
     "@ferix/server": "*",
     "@types/bun": "latest",
     "@types/node": "^22.15.3",
+    "fast-check": "^3.22.0",
     tsup: "^8.4.0",
     typescript: "5.9.2"
   },
@@ -126,7 +130,8 @@ init_esm_shims();
 
 // src/commands/code/action.ts
 init_esm_shims();
-import { Effect as Effect24, Stream as Stream10 } from "effect";
+import { Effect as Effect20, Layer as Layer12, Stream as Stream9 } from "effect";
+import { humanId as humanId2 } from "human-id";
 
 // src/commands/code/consumers/index.ts
 init_esm_shims();
@@ -953,7 +958,6 @@ tagRendererRegistry.register({
 });
 
 // src/commands/code/consumers/tui/tags/index.ts
-init_registry();
 function styleFerixTags(line, width) {
   const { tagRendererRegistry: registry } = (init_registry(), __toCommonJS(registry_exports));
   return registry.style(line, width);
@@ -1169,15 +1173,6 @@ function validateToolInput(tool, input) {
   }
   return S.decodeUnknownEither(schema)(input);
 }
-var isReadToolInput = S.is(ReadToolInputSchema);
-var isEditToolInput = S.is(EditToolInputSchema);
-var isWriteToolInput = S.is(WriteToolInputSchema);
-var isBashToolInput = S.is(BashToolInputSchema);
-var isGlobToolInput = S.is(GlobToolInputSchema);
-var isGrepToolInput = S.is(GrepToolInputSchema);
-var isTaskToolInput = S.is(TaskToolInputSchema);
-var isWebFetchToolInput = S.is(WebFetchToolInputSchema);
-var isWebSearchToolInput = S.is(WebSearchToolInputSchema);
 
 // src/commands/code/consumers/tui/tools/registry.ts
 var brightWhite = (s) => pc13.bold(pc13.white(s));
@@ -1480,7 +1475,9 @@ var loopStartedReducer = {
     task: event.config.task,
     maxIterations: event.config.maxIterations,
     status: "running",
-    startTime: event.timestamp
+    startTime: event.timestamp,
+    yolo: event.config.yolo ?? false,
+    debug: event.config.debug ?? false
   })
 };
 var loopCompletedReducer = {
@@ -1663,7 +1660,9 @@ function createInitialState() {
     selectedTaskIndex: 0,
     scrollOffset: 0,
     userScrolled: false,
-    gitPushed: false
+    gitPushed: false,
+    yolo: false,
+    debug: false
   };
 }
 function scroll(state, direction, lines, maxOffset) {
@@ -1795,6 +1794,12 @@ function renderStatusBar(state, width) {
   parts.push(
     `${colors.brand(symbols.diamond)} ${colors.brightWhite("FERIX")} ${colors.brand(symbols.diamond)}`
   );
+  if (state.yolo) {
+    parts.push(colors.warning("\u26A0 YOLO"));
+  }
+  if (state.debug) {
+    parts.push(colors.brightMagenta("DEBUG"));
+  }
   if (state.status === "running") {
     const spinner = getSpinner();
     const mode = getModeDisplay(state.executionMode, state.currentTaskId);
@@ -2445,9 +2450,6 @@ var ANSIOutput = class {
   }
 };
 
-// src/commands/code/consumers/tui/output/buffer.ts
-init_esm_shims();
-
 // src/commands/code/consumers/tui/consumer.ts
 var activeOutput = null;
 function setupSignalHandlers() {
@@ -2601,7 +2603,7 @@ ${errorText}
 
 // src/commands/code/layers/index.ts
 init_esm_shims();
-import { Layer as Layer14 } from "effect";
+import { Layer as Layer11 } from "effect";
 
 // src/commands/code/layers/git/file-system.ts
 init_esm_shims();
@@ -2645,7 +2647,9 @@ var RetryExhaustedError = class extends Data.TaggedError(
   "RetryExhaustedError"
 ) {
 };
-var MetricsError = class extends Data.TaggedError("MetricsError") {
+var StateStoreError = class extends Data.TaggedError("StateStoreError") {
+};
+var PromptStoreError = class extends Data.TaggedError("PromptStoreError") {
 };
 
 // src/commands/code/services/git.ts
@@ -3008,140 +3012,11 @@ var FileSystemGit = {
   Live
 };
 
-// src/commands/code/layers/git/memory.ts
-init_esm_shims();
-import { Effect as Effect5, Layer as Layer2, Ref as Ref3 } from "effect";
-var BRANCH_PREFIX2 = "ferix";
-function getBranchName2(sessionId) {
-  return `${BRANCH_PREFIX2}/${sessionId}`;
-}
-function createMemoryGitService(stateRef, commitCounterRef) {
-  return {
-    createWorktree: (sessionId, _baseBranch) => Effect5.gen(function* () {
-      const state = yield* Ref3.get(stateRef);
-      const existing = state.get(sessionId);
-      if (existing) {
-        return existing.path;
-      }
-      const path2 = `.ferix/worktrees/${sessionId}`;
-      const branch = getBranchName2(sessionId);
-      const worktree = {
-        path: path2,
-        branch,
-        commits: []
-      };
-      state.set(sessionId, worktree);
-      yield* Ref3.set(stateRef, state);
-      return path2;
-    }),
-    removeWorktree: (sessionId) => Effect5.gen(function* () {
-      const state = yield* Ref3.get(stateRef);
-      state.delete(sessionId);
-      yield* Ref3.set(stateRef, state);
-    }),
-    removeWorktreeKeepBranch: (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, _baseBranch) => 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}`;
-    }),
-    getCurrentBranch: () => Effect5.succeed("main"),
-    // Default to main for tests
-    renameBranch: (sessionId, displayName) => 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: "renameBranch"
-          })
-        );
-      }
-      const newBranchName = `${BRANCH_PREFIX2}/${displayName}`;
-      const updatedWorktree = {
-        ...worktree,
-        branch: newBranchName
-      };
-      state.set(sessionId, updatedWorktree);
-      yield* Ref3.set(stateRef, state);
-      return newBranchName;
-    }),
-    getBranchName: getBranchName2
-  };
-}
-function layer() {
-  return Layer2.effect(
-    Git,
-    Effect5.gen(function* () {
-      const stateRef = yield* Ref3.make(/* @__PURE__ */ new Map());
-      const commitCounterRef = yield* Ref3.make(0);
-      return createMemoryGitService(stateRef, commitCounterRef);
-    })
-  );
-}
-var Live2 = layer();
-var MemoryGit = {
-  Live: Live2,
-  layer
-};
-
 // src/commands/code/layers/guardrails/file-system.ts
 init_esm_shims();
 import { mkdir as mkdir2, readFile as readFile2, writeFile } from "fs/promises";
 import { join as join2 } from "path";
-import { DateTime, Effect as Effect6, Layer as Layer3 } from "effect";
+import { DateTime, Effect as Effect5, Layer as Layer2 } from "effect";
 
 // src/commands/code/domain/index.ts
 init_esm_shims();
@@ -3210,13 +3085,6 @@ var StreamEventEnvelopeSchema = S2.Struct({
   type: S2.Literal("stream_event"),
   event: S2.Unknown
 });
-var ClaudeCliEventSchema = S2.Union(
-  ContentBlockStartSchema,
-  ContentBlockDeltaSchema,
-  ContentBlockStopSchema,
-  AssistantMessageSchema,
-  StreamEventEnvelopeSchema
-);
 var isContentBlockStart = S2.is(ContentBlockStartSchema);
 var isContentBlockDelta = S2.is(ContentBlockDeltaSchema);
 var isContentBlockStop = S2.is(ContentBlockStopSchema);
@@ -3226,8 +3094,6 @@ var isTextDelta = S2.is(TextDeltaSchema);
 var isInputJsonDelta = S2.is(InputJsonDeltaSchema);
 var isToolUseContentBlock = S2.is(ToolUseContentBlockSchema);
 var isTextContentBlock = S2.is(TextContentBlockSchema);
-var decodeClaudeCliEvent = S2.decodeUnknown(ClaudeCliEventSchema);
-var decodeClaudeCliEventSync = S2.decodeUnknownSync(ClaudeCliEventSchema);
 
 // src/commands/code/domain/schemas/cli-output-opencode.ts
 init_esm_shims();
@@ -3250,15 +3116,6 @@ var OpenCodeToolUseEventSchema = S3.Struct({
   type: S3.Literal("tool_use"),
   part: OpenCodeToolPartSchema
 });
-var OpenCodeStepPartSchema = S3.Struct({}).pipe(
-  S3.extend(S3.Record({ key: S3.String, value: S3.Unknown }))
-);
-var OpenCodeStepStartSchema = S3.Struct({
-  type: S3.Literal("step_start"),
-  timestamp: S3.Number,
-  sessionID: S3.String,
-  part: S3.optional(OpenCodeStepPartSchema)
-});
 var OpenCodeTokensSchema = S3.Struct({}).pipe(
   S3.extend(S3.Record({ key: S3.String, value: S3.Unknown }))
 );
@@ -3270,20 +3127,9 @@ var OpenCodeStepFinishSchema = S3.Struct({
   tokens: S3.optional(OpenCodeTokensSchema),
   cost: S3.optional(OpenCodeCostSchema)
 });
-var OpenCodeCliEventSchema = S3.Union(
-  OpenCodeTextEventSchema,
-  OpenCodeToolUseEventSchema,
-  OpenCodeStepStartSchema,
-  OpenCodeStepFinishSchema
-);
 var isOpenCodeTextEvent = S3.is(OpenCodeTextEventSchema);
 var isOpenCodeToolUseEvent = S3.is(OpenCodeToolUseEventSchema);
-var isOpenCodeStepStart = S3.is(OpenCodeStepStartSchema);
 var isOpenCodeStepFinish = S3.is(OpenCodeStepFinishSchema);
-var decodeOpenCodeCliEvent = S3.decodeUnknown(OpenCodeCliEventSchema);
-var decodeOpenCodeCliEventSync = S3.decodeUnknownSync(
-  OpenCodeCliEventSchema
-);
 
 // src/commands/code/domain/schemas/config.ts
 init_esm_shims();
@@ -3314,7 +3160,11 @@ var LoopConfigSchema = S4.Struct({
   verbose: S4.optional(S4.Boolean),
   prompts: S4.optional(PromptConfigSchema),
   /** LLM provider to use. Defaults to "claude". */
-  provider: S4.optional(ProviderNameSchema)
+  provider: S4.optional(ProviderNameSchema),
+  /** Skip all permission prompts (YOLO mode). Use with caution. */
+  yolo: S4.optional(S4.Boolean),
+  /** Enable debug logging to .ferix/logs/<session>.log */
+  debug: S4.optional(S4.Boolean)
 });
 var LoopSummarySchema = S4.Struct({
   iterations: S4.Number,
@@ -3330,7 +3180,6 @@ var LoopErrorSchema = S4.Struct({
   phase: S4.String,
   iteration: S4.optional(S4.Number)
 });
-var decodeLoopConfig = S4.decodeUnknown(LoopConfigSchema);
 
 // src/commands/code/domain/schemas/events.ts
 init_esm_shims();
@@ -3348,12 +3197,7 @@ var TaskStatusSchema = S5.Literal(
   "failed",
   "skipped"
 );
-var PhaseStatusSchema = S5.Literal(
-  "pending",
-  "in_progress",
-  "done",
-  "failed"
-);
+var PhaseStatusSchema = S5.Literal("pending", "in_progress", "done", "failed");
 var CriterionStatusSchema = S5.Literal("pending", "passed", "failed");
 var PhaseSchema = S5.Struct({
   id: S5.String,
@@ -3392,7 +3236,6 @@ var PlanSchema = S5.Struct({
   context: S5.optional(S5.String),
   tasks: S5.Array(TaskSchema)
 });
-var decodePlan = S5.decodeUnknown(PlanSchema);
 var decodePlanData = S5.decodeUnknown(PlanDataSchema);
 
 // src/commands/code/domain/schemas/shared.ts
@@ -3591,51 +3434,12 @@ var PRCreatedEventSchema = taggedEvent("PRCreated", {
   title: S7.String,
   timestamp: S7.Number
 });
-var SessionNameGeneratedEventSchema = taggedEvent(
-  "SessionNameGenerated",
-  {
-    sessionId: S7.String,
-    /** Task-based descriptive name (kebab-case slug, e.g., "add-dark-mode-toggle") */
-    displayName: S7.String,
-    timestamp: S7.Number
-  }
-);
-var DomainEventSchema = S7.Union(
-  LoopStartedEventSchema,
-  LoopCompletedEventSchema,
-  LoopFailedEventSchema,
-  DiscoveryStartedEventSchema,
-  DiscoveryCompletedEventSchema,
-  IterationStartedEventSchema,
-  IterationCompletedEventSchema,
-  LLMTextEventSchema,
-  LLMToolStartEventSchema,
-  LLMToolUseEventSchema,
-  LLMToolEndEventSchema,
-  TasksDefinedEventSchema,
-  PhasesDefinedEventSchema,
-  CriteriaDefinedEventSchema,
-  PhaseStartedEventSchema,
-  PhaseCompletedEventSchema,
-  PhaseFailedEventSchema,
-  CriterionPassedEventSchema,
-  CriterionFailedEventSchema,
-  CheckPassedEventSchema,
-  CheckFailedEventSchema,
-  ReviewCompleteEventSchema,
-  TaskCompletedEventSchema,
-  PlanCreatedEventSchema,
-  PlanUpdatedEventSchema,
-  PlanUpdateFailedEventSchema,
-  LearningRecordedEventSchema,
-  GuardrailAddedEventSchema,
-  ProgressUpdatedEventSchema,
-  WorktreeCreatedEventSchema,
-  WorktreeRemovedEventSchema,
-  BranchPushedEventSchema,
-  PRCreatedEventSchema,
-  SessionNameGeneratedEventSchema
-);
+var SessionNameGeneratedEventSchema = taggedEvent("SessionNameGenerated", {
+  sessionId: S7.String,
+  /** Task-based descriptive name (kebab-case slug, e.g., "add-dark-mode-toggle") */
+  displayName: S7.String,
+  timestamp: S7.Number
+});
 
 // src/commands/code/domain/schemas/guardrails.ts
 init_esm_shims();
@@ -3655,12 +3459,11 @@ var GuardrailsFileSchema = S8.Struct({
   createdAt: S8.String,
   guardrails: S8.Array(GuardrailSchema)
 });
-var decodeGuardrail = S8.decodeUnknown(GuardrailSchema);
 var decodeGuardrailsFile = S8.decodeUnknown(GuardrailsFileSchema);
 
 // src/commands/code/domain/schemas/llm.ts
 init_esm_shims();
-import { Either as Either3, Schema as S9 } from "effect";
+import { Schema as S9 } from "effect";
 var TextEventSchema = S9.TaggedStruct("Text", {
   text: S9.String
 });
@@ -3671,10 +3474,6 @@ var ToolUseEventSchema = S9.TaggedStruct("ToolUse", {
   tool: S9.String,
   input: S9.Unknown
 });
-var ValidatedToolUseEventSchema = S9.TaggedStruct("ToolUse", {
-  tool: S9.String,
-  input: AnyToolInputSchema
-});
 var ToolEndEventSchema = S9.TaggedStruct("ToolEnd", {
   tool: S9.String
 });
@@ -3688,95 +3487,108 @@ var LLMEventSchema = S9.Union(
   ToolEndEventSchema,
   DoneEventSchema
 );
-var decodeLLMEvent = S9.decodeUnknown(LLMEventSchema);
 
 // src/commands/code/domain/schemas/logger.ts
 init_esm_shims();
-import { Schema as S10 } from "effect";
-var LogLevelSchema = S10.Literal("debug", "info", "warn", "error");
-var LogEntrySchema = S10.Struct({
-  level: LogLevelSchema,
-  message: S10.String,
-  timestamp: S10.String,
-  context: S10.optional(S10.Record({ key: S10.String, value: S10.Unknown }))
-});
-var ConsoleLoggerConfigSchema = S10.Struct({
-  level: S10.optional(LogLevelSchema),
-  colors: S10.optional(S10.Boolean)
-});
-var FileLoggerConfigSchema = S10.Struct({
-  path: S10.optional(S10.String),
-  level: S10.optional(LogLevelSchema)
-});
 
 // src/commands/code/domain/schemas/program.ts
 init_esm_shims();
-import { Schema as S11 } from "effect";
-var ConsumerTypeSchema = S11.Literal("tui", "headless", "none");
-var RunOptionsDataSchema = S11.Struct({
-  config: LoopConfigSchema,
-  consumer: S11.optional(ConsumerTypeSchema)
-});
+import { Schema as S10 } from "effect";
+var ConsumerTypeSchema = S10.Literal("tui", "headless", "none");
 
 // src/commands/code/domain/schemas/progress.ts
 init_esm_shims();
-import { Schema as S12 } from "effect";
-var ProgressActionSchema = S12.Literal(
+import { Schema as S11 } from "effect";
+var ProgressActionSchema = S11.Literal(
   "started",
   "completed",
   "failed",
   "learning"
 );
-var ProgressEntrySchema = S12.Struct({
-  iteration: S12.Number,
-  timestamp: S12.String,
-  taskId: S12.String,
+var ProgressEntrySchema = S11.Struct({
+  iteration: S11.Number,
+  timestamp: S11.String,
+  taskId: S11.String,
   action: ProgressActionSchema,
-  summary: S12.String,
-  learnings: S12.optional(S12.Array(S12.String)),
-  filesModified: S12.optional(S12.Array(S12.String))
+  summary: S11.String,
+  learnings: S11.optional(S11.Array(S11.String)),
+  filesModified: S11.optional(S11.Array(S11.String))
 });
-var ProgressFileSchema = S12.Struct({
-  sessionId: S12.String,
-  createdAt: S12.String,
-  entries: S12.Array(ProgressEntrySchema)
+var ProgressFileSchema = S11.Struct({
+  sessionId: S11.String,
+  createdAt: S11.String,
+  entries: S11.Array(ProgressEntrySchema)
 });
-var decodeProgressEntry = S12.decodeUnknown(ProgressEntrySchema);
-var decodeProgressFile = S12.decodeUnknown(ProgressFileSchema);
+var decodeProgressFile = S11.decodeUnknown(ProgressFileSchema);
+function formatProgressMd(progress, originalTask) {
+  const lines = [];
+  lines.push("# Session Progress Log");
+  lines.push("");
+  lines.push(`## Session: ${progress.sessionId}`);
+  lines.push(`Started: ${progress.createdAt}`);
+  if (originalTask) {
+    lines.push(`Task: ${originalTask}`);
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  for (const entry of progress.entries) {
+    lines.push(`### Iteration ${entry.iteration} - ${entry.timestamp}`);
+    lines.push(`**Task**: ${entry.taskId}`);
+    lines.push(`**Status**: ${capitalizeFirst(entry.action)}`);
+    lines.push(`**Summary**: ${entry.summary}`);
+    if (entry.filesModified && entry.filesModified.length > 0) {
+      lines.push(`**Files Modified**: ${entry.filesModified.join(", ")}`);
+    }
+    if (entry.learnings && entry.learnings.length > 0) {
+      lines.push("**Learnings**:");
+      for (const learning of entry.learnings) {
+        lines.push(`- ${learning}`);
+      }
+    }
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function capitalizeFirst(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
 
 // src/commands/code/domain/schemas/session.ts
 init_esm_shims();
-import { Schema as S13 } from "effect";
-var SessionStatusSchema = S13.Literal(
+import { Schema as S12 } from "effect";
+var SessionStatusSchema = S12.Literal(
   "active",
   "completed",
   "failed",
   "paused"
 );
-var SessionSchema = S13.Struct({
-  id: S13.String,
-  createdAt: S13.String,
+var SessionSchema = S12.Struct({
+  id: S12.String,
+  createdAt: S12.String,
   status: SessionStatusSchema,
-  originalTask: S13.String,
-  completedTasks: S13.Array(S13.String),
-  currentTaskId: S13.optional(S13.String),
-  worktreePath: S13.optional(S13.String),
-  branchName: S13.optional(S13.String),
+  originalTask: S12.String,
+  completedTasks: S12.Array(S12.String),
+  currentTaskId: S12.optional(S12.String),
+  worktreePath: S12.optional(S12.String),
+  branchName: S12.optional(S12.String),
   /** Task-based descriptive name (kebab-case slug, e.g., "add-dark-mode-toggle") */
-  displayName: S13.optional(S13.String),
+  displayName: S12.optional(S12.String),
   /** The branch ferix was started from - used as PR base branch */
-  baseBranch: S13.optional(S13.String)
+  baseBranch: S12.optional(S12.String)
 });
-var decodeSession = S13.decodeUnknown(SessionSchema);
+var decodeSession = S12.decodeUnknown(SessionSchema);
 
 // src/commands/code/domain/schemas/signal-factories.ts
 init_esm_shims();
-import { Schema as S15 } from "effect";
+import { Schema as S14 } from "effect";
 
 // src/commands/code/domain/schemas/signals.ts
 init_esm_shims();
-import { Schema as S14 } from "effect";
-var taggedFromData2 = (tag, dataSchema) => S14.TaggedStruct(tag, dataSchema.fields);
+import { Schema as S13 } from "effect";
+var taggedFromData2 = (tag, dataSchema) => S13.TaggedStruct(tag, dataSchema.fields);
 var TasksDefinedSignalSchema = taggedFromData2(
   "TasksDefined",
   TasksDefinedDataSchema
@@ -3809,8 +3621,8 @@ var CriterionFailedSignalSchema = taggedFromData2(
   "CriterionFailed",
   CriterionFailedDataSchema
 );
-var CheckPassedSignalSchema = S14.TaggedStruct("CheckPassed", {});
-var CheckFailedSignalSchema = S14.TaggedStruct("CheckFailed", {});
+var CheckPassedSignalSchema = S13.TaggedStruct("CheckPassed", {});
+var CheckFailedSignalSchema = S13.TaggedStruct("CheckFailed", {});
 var ReviewCompleteSignalSchema = taggedFromData2(
   "ReviewComplete",
   ReviewCompleteDataSchema
@@ -3819,30 +3631,26 @@ var TaskCompleteSignalSchema = taggedFromData2(
   "TaskComplete",
   TaskCompleteSignalDataSchema
 );
-var LoopCompleteSignalSchema = S14.TaggedStruct("LoopComplete", {});
-var SessionNameDefinedSignalSchema = S14.TaggedStruct(
+var LoopCompleteSignalSchema = S13.TaggedStruct("LoopComplete", {});
+var SessionNameDefinedSignalSchema = S13.TaggedStruct(
   "SessionNameDefined",
   {
     /** Kebab-case slug, e.g., "add-dark-mode-toggle" */
-    name: S14.String
+    name: S13.String
   }
 );
-var LearningCategorySchema = S14.Literal(
-  "success",
-  "failure",
-  "optimization"
-);
-var LearningSignalSchema = S14.TaggedStruct("Learning", {
-  content: S14.String,
-  category: S14.optional(LearningCategorySchema)
-});
-var GuardrailSignalSchema = S14.TaggedStruct("Guardrail", {
-  pattern: S14.String,
-  sign: S14.String,
-  avoidance: S14.String,
-  severity: S14.Literal("warning", "critical")
-});
-var SignalSchema = S14.Union(
+var LearningCategorySchema = S13.Literal("success", "failure", "optimization");
+var LearningSignalSchema = S13.TaggedStruct("Learning", {
+  content: S13.String,
+  category: S13.optional(LearningCategorySchema)
+});
+var GuardrailSignalSchema = S13.TaggedStruct("Guardrail", {
+  pattern: S13.String,
+  sign: S13.String,
+  avoidance: S13.String,
+  severity: S13.Literal("warning", "critical")
+});
+var SignalSchema = S13.Union(
   TasksDefinedSignalSchema,
   PhasesDefinedSignalSchema,
   CriteriaDefinedSignalSchema,
@@ -3860,81 +3668,79 @@ var SignalSchema = S14.Union(
   GuardrailSignalSchema,
   SessionNameDefinedSignalSchema
 );
-var decodeSignal = S14.decodeUnknown(SignalSchema);
-var decodeSignalSync = S14.decodeUnknownSync(SignalSchema);
 
 // src/commands/code/domain/schemas/signal-factories.ts
 function createTasksDefinedSignal(input) {
-  return S15.decodeUnknownEither(TasksDefinedSignalSchema)({
+  return S14.decodeUnknownEither(TasksDefinedSignalSchema)({
     _tag: "TasksDefined",
     tasks: input.tasks
   });
 }
 function createPhasesDefinedSignal(input) {
-  return S15.decodeUnknownEither(PhasesDefinedSignalSchema)({
+  return S14.decodeUnknownEither(PhasesDefinedSignalSchema)({
     _tag: "PhasesDefined",
     taskId: input.taskId,
     phases: input.phases
   });
 }
 function createCriteriaDefinedSignal(input) {
-  return S15.decodeUnknownEither(CriteriaDefinedSignalSchema)({
+  return S14.decodeUnknownEither(CriteriaDefinedSignalSchema)({
     _tag: "CriteriaDefined",
     taskId: input.taskId,
     criteria: input.criteria
   });
 }
 function createPhaseStartedSignal(input) {
-  return S15.decodeUnknownEither(PhaseStartedSignalSchema)({
+  return S14.decodeUnknownEither(PhaseStartedSignalSchema)({
     _tag: "PhaseStarted",
     phaseId: input.phaseId
   });
 }
 function createPhaseCompletedSignal(input) {
-  return S15.decodeUnknownEither(PhaseCompletedSignalSchema)({
+  return S14.decodeUnknownEither(PhaseCompletedSignalSchema)({
     _tag: "PhaseCompleted",
     phaseId: input.phaseId
   });
 }
 function createPhaseFailedSignal(input) {
-  return S15.decodeUnknownEither(PhaseFailedSignalSchema)({
+  return S14.decodeUnknownEither(PhaseFailedSignalSchema)({
     _tag: "PhaseFailed",
     phaseId: input.phaseId,
     reason: input.reason
   });
 }
 function createCriterionPassedSignal(input) {
-  return S15.decodeUnknownEither(CriterionPassedSignalSchema)({
+  return S14.decodeUnknownEither(CriterionPassedSignalSchema)({
     _tag: "CriterionPassed",
     criterionId: input.criterionId
   });
 }
 function createCriterionFailedSignal(input) {
-  return S15.decodeUnknownEither(CriterionFailedSignalSchema)({
+  return S14.decodeUnknownEither(CriterionFailedSignalSchema)({
     _tag: "CriterionFailed",
     criterionId: input.criterionId,
     reason: input.reason
   });
 }
 function createCheckPassedSignal(_input) {
-  return S15.decodeUnknownEither(CheckPassedSignalSchema)({
+  return S14.decodeUnknownEither(CheckPassedSignalSchema)({
     _tag: "CheckPassed"
   });
 }
 function createCheckFailedSignal(_input) {
-  return S15.decodeUnknownEither(CheckFailedSignalSchema)({
+  return S14.decodeUnknownEither(CheckFailedSignalSchema)({
     _tag: "CheckFailed"
   });
 }
 function createLearningSignal(input) {
-  return S15.decodeUnknownEither(LearningSignalSchema)({
+  return S14.decodeUnknownEither(LearningSignalSchema)({
     _tag: "Learning",
     content: input.content,
     category: input.category
   });
 }
 function createGuardrailSignal(input) {
-  return S15.decodeUnknownEither(GuardrailSignalSchema)({
+  return S14.decodeUnknownEither(GuardrailSignalSchema)({
     _tag: "Guardrail",
     pattern: input.pattern,
     sign: input.sign,
@@ -3943,12 +3749,49 @@ function createGuardrailSignal(input) {
   });
 }
 function createSessionNameDefinedSignal(input) {
-  return S15.decodeUnknownEither(SessionNameDefinedSignalSchema)({
+  return S14.decodeUnknownEither(SessionNameDefinedSignalSchema)({
     _tag: "SessionNameDefined",
     name: input.name
   });
 }
 
+// src/commands/code/domain/schemas/state.ts
+init_esm_shims();
+import { Schema as S15 } from "effect";
+var TaskSummarySchema = S15.Struct({
+  total: S15.Number,
+  done: S15.Number,
+  inProgress: S15.Number,
+  pending: S15.Number
+});
+var PhaseStateSchema = S15.Struct({
+  id: S15.String,
+  description: S15.String,
+  status: S15.Literal("pending", "in_progress", "done", "failed")
+});
+var CriterionStateSchema = S15.Struct({
+  id: S15.String,
+  description: S15.String,
+  status: S15.Literal("pending", "passed", "failed")
+});
+var CurrentTaskSchema = S15.Struct({
+  id: S15.String,
+  title: S15.String,
+  description: S15.String,
+  phases: S15.Array(PhaseStateSchema),
+  criteria: S15.Array(CriterionStateSchema)
+});
+var SessionStateSchema = S15.Struct({
+  sessionId: S15.String,
+  originalTask: S15.String,
+  iteration: S15.Number,
+  maxIterations: S15.Number,
+  taskSummary: TaskSummarySchema,
+  currentTask: S15.NullOr(CurrentTaskSchema),
+  recentProgress: S15.Array(S15.String)
+});
+var decodeSessionState = S15.decodeUnknown(SessionStateSchema);
+
 // src/commands/code/domain/schemas/task-generation.ts
 init_esm_shims();
 import { Schema as S16 } from "effect";
@@ -3961,49 +3804,24 @@ var GeneratedTaskStatusSchema = S16.Literal(
 var GeneratedTaskSchema = S16.Struct({
   id: S16.String,
   title: S16.String,
-  status: GeneratedTaskStatusSchema
+  description: S16.String,
+  status: GeneratedTaskStatusSchema,
+  steps: S16.Array(S16.String)
 });
-var GeneratedTaskListSchema = S16.Array(GeneratedTaskSchema);
-var STATUS_ICONS = {
-  done: "[x]",
-  in_progress: "[~]",
-  pending: "[ ]",
-  failed: "[!]"
-};
-function formatTasksMd(tasks) {
-  const completedCount = tasks.filter((t) => t.status === "done").length;
-  const totalCount = tasks.length;
-  const lines = [
-    "# Tasks",
-    "",
-    `## Status: ${completedCount}/${totalCount} complete`,
-    ""
-  ];
-  const currentTaskId = tasks.find(
-    (t) => t.status === "in_progress" || t.status === "pending"
-  )?.id;
-  for (const task of tasks) {
-    const icon = STATUS_ICONS[task.status];
-    const currentMarker = task.id === currentTaskId ? " \u2190 current" : "";
-    lines.push(`- ${icon} **Task ${task.id}**: ${task.title}${currentMarker}`);
-  }
-  lines.push("");
-  lines.push("---");
-  lines.push("");
-  lines.push(`*Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}*`);
-  return lines.join("\n");
+var TasksFileSchema = S16.Struct({
+  sessionId: S16.String,
+  originalTask: S16.String,
+  tasks: S16.Array(GeneratedTaskSchema)
+});
+function formatTasksJson(tasksFile) {
+  return JSON.stringify(tasksFile, null, 2);
 }
 
 // src/commands/code/domain/schemas/tui.ts
 init_esm_shims();
 import { Schema as S17 } from "effect";
 var ViewModeSchema = S17.Literal("logs", "tasks", "detail");
-var LoopStatusSchema = S17.Literal(
-  "idle",
-  "running",
-  "complete",
-  "error"
-);
+var LoopStatusSchema = S17.Literal("idle", "running", "complete", "error");
 var ExecutionModeSchema = S17.Literal(
   "idle",
   "discovery",
@@ -4020,11 +3838,7 @@ var TUIPhaseStatusSchema = S17.Literal(
   "done",
   "failed"
 );
-var TUICriterionStatusSchema = S17.Literal(
-  "pending",
-  "passed",
-  "failed"
-);
+var TUICriterionStatusSchema = S17.Literal("pending", "passed", "failed");
 var TUITaskStatusSchema = S17.Literal(
   "pending",
   "in_progress",
@@ -4080,7 +3894,11 @@ var TUIStateSchema = S17.Struct({
   // Git
   gitBranch: S17.optional(S17.String),
   gitPushed: S17.Boolean,
-  prUrl: S17.optional(S17.String)
+  prUrl: S17.optional(S17.String),
+  // YOLO mode (skip permission prompts)
+  yolo: S17.Boolean,
+  // Debug mode (logging enabled)
+  debug: S17.Boolean
 });
 
 // src/commands/code/services/guardrails-store.ts
@@ -4092,14 +3910,14 @@ var GuardrailsStore = class extends Context2.Tag("@ferix/GuardrailsStore")() {
 // src/commands/code/layers/guardrails/file-system.ts
 var PLANS_DIR = ".ferix/plans";
 function ensureDir(dirPath) {
-  return Effect6.tryPromise({
+  return Effect5.tryPromise({
     try: () => mkdir2(dirPath, { recursive: true }),
     catch: (error) => new GuardrailsStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "add",
       cause: error
     })
-  }).pipe(Effect6.asVoid);
+  }).pipe(Effect5.asVoid);
 }
 function getSessionDir(sessionId) {
   return join2(process.cwd(), PLANS_DIR, sessionId);
@@ -4111,8 +3929,8 @@ function serializeGuardrails(guardrails) {
   return JSON.stringify(guardrails, null, 2);
 }
 function deserializeGuardrails(json) {
-  return Effect6.gen(function* () {
-    const parsed = yield* Effect6.try({
+  return Effect5.gen(function* () {
+    const parsed = yield* Effect5.try({
       try: () => JSON.parse(json),
       catch: (error) => new GuardrailsStoreError({
         message: `Invalid JSON in guardrails file: ${String(error)}`,
@@ -4121,7 +3939,7 @@ function deserializeGuardrails(json) {
       })
     });
     const validated = yield* decodeGuardrailsFile(parsed).pipe(
-      Effect6.mapError(
+      Effect5.mapError(
         (error) => new GuardrailsStoreError({
           message: `Guardrails validation failed: ${String(error)}`,
           operation: "load",
@@ -4140,11 +3958,11 @@ function createEmptyGuardrails(sessionId, createdAt) {
   };
 }
 var make2 = {
-  add: (sessionId, guardrail) => Effect6.gen(function* () {
+  add: (sessionId, guardrail) => Effect5.gen(function* () {
     const sessionDir = getSessionDir(sessionId);
     yield* ensureDir(sessionDir);
     const guardrailsPath = getGuardrailsPath(sessionId);
-    const existing = yield* Effect6.tryPromise({
+    const existing = yield* Effect5.tryPromise({
       try: async () => {
         try {
           const content = await readFile2(guardrailsPath, "utf-8");
@@ -4162,7 +3980,7 @@ var make2 = {
     let guardrails;
     if (existing) {
       guardrails = yield* deserializeGuardrails(existing).pipe(
-        Effect6.mapError(
+        Effect5.mapError(
           (err) => new GuardrailsStoreError({
             message: err.message,
             operation: "add",
@@ -4178,7 +3996,7 @@ var make2 = {
       ...guardrails,
       guardrails: [...guardrails.guardrails, guardrail]
     };
-    yield* Effect6.tryPromise({
+    yield* Effect5.tryPromise({
       try: () => writeFile(
         guardrailsPath,
         serializeGuardrails(updatedGuardrails),
@@ -4191,9 +4009,9 @@ var make2 = {
       })
     });
   }),
-  load: (sessionId) => Effect6.gen(function* () {
+  load: (sessionId) => Effect5.gen(function* () {
     const guardrailsPath = getGuardrailsPath(sessionId);
-    const content = yield* Effect6.tryPromise({
+    const content = yield* Effect5.tryPromise({
       try: async () => {
         try {
           return await readFile2(guardrailsPath, "utf-8");
@@ -4213,146 +4031,39 @@ var make2 = {
     }
     return yield* deserializeGuardrails(content);
   }),
-  getActive: (sessionId) => Effect6.gen(function* () {
+  getActive: (sessionId) => Effect5.gen(function* () {
     const guardrails = yield* make2.load(sessionId);
     return guardrails.guardrails;
   })
 };
-var Live3 = Layer3.succeed(GuardrailsStore, make2);
+var Live2 = Layer2.succeed(GuardrailsStore, make2);
 var FileSystemGuardrails = {
-  Live: Live3
-};
-
-// src/commands/code/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/commands/code/layers/llm/mock.ts
-init_esm_shims();
-import { Effect as Effect8, Layer as Layer5, Schema as S18, Stream as Stream4 } from "effect";
-
-// src/commands/code/services/llm.ts
-init_esm_shims();
-import { Context as Context3 } from "effect";
-var LLM = class extends Context3.Tag("@ferix/LLM")() {
-};
-
-// src/commands/code/layers/llm/mock.ts
-var MockLLMConfigSchema = S18.Struct({
-  events: S18.Array(LLMEventSchema),
-  delayMs: S18.optional(S18.Number)
-});
-function createMockLLM(config) {
-  return {
-    execute: (_prompt, _options) => {
-      const baseStream = Stream4.fromIterable(config.events);
-      if (config.delayMs !== void 0 && config.delayMs > 0) {
-        const delay = config.delayMs;
-        return baseStream.pipe(Stream4.tap(() => Effect8.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 Live5 = Layer5.succeed(LLM, defaultMock);
-function layer3(config) {
-  return Layer5.succeed(LLM, createMockLLM(config));
-}
-var Mock = {
-  Live: Live5,
-  layer: layer3,
-  createMockLLM
+  Live: Live2
 };
 
 // src/commands/code/layers/llm/providers/index.ts
 init_esm_shims();
-import { Effect as Effect11 } from "effect";
+import { Effect as Effect8 } from "effect";
 
 // src/commands/code/layers/llm/types.ts
 init_esm_shims();
-import { Schema as S19 } from "effect";
-var PermissionModeSchema = S19.Literal("acceptEdits", "yolo", "prompt");
-var ProviderConfigSchema = S19.Struct({
+import { Schema as S18 } from "effect";
+var PermissionModeSchema = S18.Literal("acceptEdits", "yolo", "prompt");
+var ProviderConfigSchema = S18.Struct({
   /** Provider name */
   name: ProviderNameSchema,
   /** CLI command to execute */
-  cliCommand: S19.String,
+  cliCommand: S18.String,
   /** Default arguments for the CLI */
-  args: S19.Array(S19.String),
+  args: S18.Array(S18.String),
   /** Environment variables to pass */
-  env: S19.optional(S19.Record({ key: S19.String, value: S19.String })),
+  env: S18.optional(S18.Record({ key: S18.String, value: S18.String })),
   /** Permission mode for the CLI */
-  permissions: S19.optional(PermissionModeSchema),
+  permissions: S18.optional(PermissionModeSchema),
   /** URL for installation instructions */
-  installUrl: S19.String
+  installUrl: S18.String,
+  /** Arguments to pass when YOLO mode is enabled */
+  yoloArgs: S18.optional(S18.Array(S18.String))
 });
 var RAW_PROVIDER_CONFIGS = {
   claude: {
@@ -4367,28 +4078,31 @@ var RAW_PROVIDER_CONFIGS = {
       "--include-partial-messages"
     ],
     permissions: "acceptEdits",
-    installUrl: "https://docs.anthropic.com/claude-code"
+    installUrl: "https://docs.anthropic.com/claude-code",
+    yoloArgs: ["--dangerously-skip-permissions"]
   },
   cursor: {
     name: "cursor",
     cliCommand: "cursor-agent",
     args: ["--print", "--force", "--output-format", "stream-json"],
     permissions: "acceptEdits",
-    installUrl: "https://cursor.sh/agent"
+    installUrl: "https://cursor.sh/agent",
+    yoloArgs: ["--yolo"]
   },
   opencode: {
     name: "opencode",
     cliCommand: "opencode",
     args: ["run", "--format", "json"],
-    installUrl: "https://opencode.ai/docs/"
+    installUrl: "https://opencode.ai/docs/",
+    yoloArgs: ["--yolo"]
   }
 };
-var ProviderConfigsSchema = S19.Record({
+var ProviderConfigsSchema = S18.Record({
   key: ProviderNameSchema,
   value: ProviderConfigSchema
 });
 var validateProviderConfigs = () => {
-  const decoded = S19.decodeUnknownSync(ProviderConfigsSchema)(
+  const decoded = S18.decodeUnknownSync(ProviderConfigsSchema)(
     RAW_PROVIDER_CONFIGS
   );
   return decoded;
@@ -4401,16 +4115,28 @@ init_esm_shims();
 // src/commands/code/layers/llm/provider-factory.ts
 init_esm_shims();
 import { spawn } from "child_process";
-import { Effect as Effect9, Layer as Layer6, Stream as Stream5 } from "effect";
+import { Effect as Effect6, Layer as Layer3, Stream as Stream4 } from "effect";
+
+// src/commands/code/services/llm.ts
+init_esm_shims();
+import { Context as Context3 } from "effect";
+var LLM = class extends Context3.Tag("@ferix/LLM")() {
+};
+
+// src/commands/code/layers/llm/provider-factory.ts
 function createProvider(name, createStream, checkAvailable) {
   const config = PROVIDER_CONFIGS[name];
   return {
     name,
     execute: (prompt, options) => {
-      return Stream5.unwrap(
+      return Stream4.unwrap(
         checkAvailable(name).pipe(
-          Effect9.map(() => {
-            const args = name === "opencode" ? [...config.args, prompt] : [...config.args, "-p", prompt];
+          Effect6.map(() => {
+            let args = [...config.args];
+            if (options?.yolo && config.yoloArgs) {
+              args.push(...config.yoloArgs);
+            }
+            args = name === "opencode" ? [...args, prompt] : [...args, "-p", prompt];
             const child = spawn(config.cliCommand, args, {
               stdio: ["inherit", "pipe", "pipe"],
               cwd: options?.cwd,
@@ -4428,7 +4154,7 @@ function createProvider(name, createStream, checkAvailable) {
   };
 }
 function createProviderLayer(provider) {
-  return Layer6.succeed(LLM, provider);
+  return Layer3.succeed(LLM, provider);
 }
 
 // src/commands/code/layers/llm/stream.ts
@@ -4439,13 +4165,13 @@ init_esm_shims();
 
 // src/commands/code/layers/llm/providers/parsers/stream-json.ts
 init_esm_shims();
-import { Either as Either4 } from "effect";
+import { Either as Either3 } from "effect";
 function parseJsonLine(line) {
   if (!line.startsWith("{")) {
     return null;
   }
-  return Either4.getOrNull(
-    Either4.try({ try: () => JSON.parse(line), catch: () => null })
+  return Either3.getOrNull(
+    Either3.try({ try: () => JSON.parse(line), catch: () => null })
   );
 }
 function extractText(json) {
@@ -4484,8 +4210,8 @@ function extractToolInfo(json) {
   return null;
 }
 function safeParseJson(jsonStr) {
-  return Either4.getOrNull(
-    Either4.try({ try: () => JSON.parse(jsonStr), catch: () => null })
+  return Either3.getOrNull(
+    Either3.try({ try: () => JSON.parse(jsonStr), catch: () => null })
   );
 }
 function unwrapStreamEvent(json) {
@@ -4498,7 +4224,7 @@ function unwrapStreamEvent(json) {
 // src/commands/code/layers/llm/stream-factory.ts
 init_esm_shims();
 import { createInterface } from "readline";
-import { Effect as Effect10, Stream as Stream6 } from "effect";
+import { Effect as Effect7, Stream as Stream5 } from "effect";
 function handleToolEvent(toolInfo, toolState, emit) {
   if (toolInfo.type === "start") {
     toolState.currentTool = toolInfo.name;
@@ -4522,7 +4248,7 @@ function handleToolEvent(toolInfo, toolState, emit) {
   }
 }
 function createLLMEventStream(child, parser, providerName) {
-  return Stream6.async((emit) => {
+  return Stream5.async((emit) => {
     const outputChunks = [];
     const toolState = { currentTool: "", inputChunks: [] };
     const stdout = child.stdout;
@@ -4530,7 +4256,7 @@ function createLLMEventStream(child, parser, providerName) {
       emit.fail(
         new LLMError({ message: "Failed to get stdout from child process" })
       );
-      return Effect10.void;
+      return Effect7.void;
     }
     const rl = createInterface({
       input: stdout,
@@ -4569,7 +4295,7 @@ function createLLMEventStream(child, parser, providerName) {
         })
       );
     });
-    return Effect10.sync(() => {
+    return Effect7.sync(() => {
       child.kill("SIGTERM");
     });
   });
@@ -4603,9 +4329,9 @@ var ClaudeProvider = createProvider(
   (child) => createEventStream(child, "Claude"),
   checkProviderAvailable
 );
-var Live6 = createProviderLayer(ClaudeProvider);
+var Live3 = createProviderLayer(ClaudeProvider);
 var ClaudeCLI = {
-  Live: Live6,
+  Live: Live3,
   Provider: ClaudeProvider
 };
 
@@ -4616,9 +4342,9 @@ var CursorProvider = createProvider(
   (child) => createEventStream(child, "Cursor"),
   checkProviderAvailable
 );
-var Live7 = createProviderLayer(CursorProvider);
+var Live4 = createProviderLayer(CursorProvider);
 var CursorCLI = {
-  Live: Live7,
+  Live: Live4,
   Provider: CursorProvider
 };
 
@@ -4630,13 +4356,13 @@ init_esm_shims();
 
 // src/commands/code/layers/llm/providers/parsers/opencode.ts
 init_esm_shims();
-import { Either as Either5 } from "effect";
+import { Either as Either4 } from "effect";
 function parseJsonLine2(line) {
   if (!line.startsWith("{")) {
     return null;
   }
-  return Either5.getOrNull(
-    Either5.try({ try: () => JSON.parse(line), catch: () => null })
+  return Either4.getOrNull(
+    Either4.try({ try: () => JSON.parse(line), catch: () => null })
   );
 }
 function isStepFinish(json) {
@@ -4697,16 +4423,16 @@ var OpenCodeProvider = createProvider(
   (child) => createOpenCodeEventStream(child, "OpenCode"),
   checkProviderAvailable
 );
-var Live8 = createProviderLayer(OpenCodeProvider);
+var Live5 = createProviderLayer(OpenCodeProvider);
 var OpenCodeCLI = {
-  Live: Live8,
+  Live: Live5,
   Provider: OpenCodeProvider
 };
 
 // src/commands/code/layers/llm/providers/index.ts
 var OpenCodeCLI2 = OpenCodeCLI;
 function isCommandAvailable(command) {
-  return Effect11.tryPromise({
+  return Effect8.tryPromise({
     try: async () => {
       const { execSync } = await import("child_process");
       try {
@@ -4717,13 +4443,13 @@ function isCommandAvailable(command) {
       }
     },
     catch: () => false
-  }).pipe(Effect11.orElseSucceed(() => false));
+  }).pipe(Effect8.orElseSucceed(() => false));
 }
 function checkProviderAvailable(name) {
   const config = PROVIDER_CONFIGS[name];
   return isCommandAvailable(config.cliCommand).pipe(
-    Effect11.flatMap(
-      (available) => available ? Effect11.void : Effect11.fail(
+    Effect8.flatMap(
+      (available) => available ? Effect8.void : Effect8.fail(
         new LLMError({
           message: `Provider "${name}" is not available. The CLI command "${config.cliCommand}" was not found.
 
@@ -4753,7 +4479,7 @@ function createProviderLayer2(name) {
 init_esm_shims();
 import { access as access2, mkdir as mkdir3, readdir, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
 import { join as join3 } from "path";
-import { Effect as Effect12, Layer as Layer7 } from "effect";
+import { Effect as Effect9, Layer as Layer4 } from "effect";
 
 // src/commands/code/services/plan-store.ts
 init_esm_shims();
@@ -4764,14 +4490,14 @@ var PlanStore = class extends Context4.Tag("@ferix/PlanStore")() {
 // src/commands/code/layers/plan/file-system.ts
 var PLANS_DIR2 = ".ferix/plans";
 function ensureDir2(dirPath) {
-  return Effect12.tryPromise({
+  return Effect9.tryPromise({
     try: () => mkdir3(dirPath, { recursive: true }),
     catch: (error) => new PlanStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "create",
       cause: error
     })
-  }).pipe(Effect12.asVoid);
+  }).pipe(Effect9.asVoid);
 }
 function getSessionDir2(sessionId) {
   return join3(process.cwd(), PLANS_DIR2, sessionId);
@@ -4786,8 +4512,8 @@ function serializePlan(plan) {
   return JSON.stringify(plan, null, 2);
 }
 function deserializePlan(json, planId) {
-  return Effect12.gen(function* () {
-    const parsed = yield* Effect12.try({
+  return Effect9.gen(function* () {
+    const parsed = yield* Effect9.try({
       try: () => JSON.parse(json),
       catch: (error) => new PlanStoreError({
         message: `Invalid JSON in plan file: ${String(error)}`,
@@ -4796,7 +4522,7 @@ function deserializePlan(json, planId) {
       })
     });
     const validated = yield* decodePlanData(parsed).pipe(
-      Effect12.mapError(
+      Effect9.mapError(
         (error) => new PlanStoreError({
           message: `Plan validation failed: ${String(error)}`,
           operation: "load",
@@ -4811,10 +4537,10 @@ function deserializePlan(json, planId) {
   });
 }
 var make3 = {
-  create: (sessionId, plan) => Effect12.gen(function* () {
+  create: (sessionId, plan) => Effect9.gen(function* () {
     const sessionDir = getSessionDir2(sessionId);
     yield* ensureDir2(sessionDir);
-    const existingPlans = yield* Effect12.tryPromise({
+    const existingPlans = yield* Effect9.tryPromise({
       try: async () => {
         try {
           const files = await readdir(sessionDir);
@@ -4831,7 +4557,7 @@ var make3 = {
     const planId = generatePlanId(existingPlans + 1);
     const planPath = getPlanPath(sessionId, planId);
     const fullPlan = { ...plan, id: planId };
-    yield* Effect12.tryPromise({
+    yield* Effect9.tryPromise({
       try: () => writeFile2(planPath, serializePlan(fullPlan), "utf-8"),
       catch: (error) => new PlanStoreError({
         message: `Failed to write plan file: ${planPath}`,
@@ -4841,10 +4567,10 @@ var make3 = {
     });
     return planId;
   }),
-  load: (planId, sessionId) => Effect12.gen(function* () {
+  load: (planId, sessionId) => Effect9.gen(function* () {
     if (sessionId) {
       const planPath = getPlanPath(sessionId, planId);
-      const content = yield* Effect12.tryPromise({
+      const content = yield* Effect9.tryPromise({
         try: () => readFile3(planPath, "utf-8"),
         catch: (error) => new PlanStoreError({
           message: `Failed to read plan file: ${planPath}`,
@@ -4854,7 +4580,7 @@ var make3 = {
       });
       return yield* deserializePlan(content, planId);
     }
-    const sessionDirs = yield* Effect12.tryPromise({
+    const sessionDirs = yield* Effect9.tryPromise({
       try: async () => {
         const plansDir = join3(process.cwd(), PLANS_DIR2);
         const dirs = await readdir(plansDir);
@@ -4868,7 +4594,7 @@ var make3 = {
     });
     for (const sid of sessionDirs) {
       const planPath = getPlanPath(sid, planId);
-      const exists = yield* Effect12.tryPromise({
+      const exists = yield* Effect9.tryPromise({
         try: async () => {
           await access2(planPath);
           return true;
@@ -4877,9 +4603,9 @@ var make3 = {
           message: "File not found",
           operation: "load"
         })
-      }).pipe(Effect12.orElseSucceed(() => false));
+      }).pipe(Effect9.orElseSucceed(() => false));
       if (exists) {
-        const content = yield* Effect12.tryPromise({
+        const content = yield* Effect9.tryPromise({
           try: () => readFile3(planPath, "utf-8"),
           catch: (error) => new PlanStoreError({
             message: `Failed to read plan file: ${planPath}`,
@@ -4890,16 +4616,16 @@ var make3 = {
         return yield* deserializePlan(content, planId);
       }
     }
-    return yield* Effect12.fail(
+    return yield* Effect9.fail(
       new PlanStoreError({
         message: `Plan not found: ${planId}`,
         operation: "load"
       })
     );
   }),
-  update: (planId, plan) => Effect12.gen(function* () {
+  update: (planId, plan) => Effect9.gen(function* () {
     const planPath = getPlanPath(plan.sessionId, planId);
-    yield* Effect12.tryPromise({
+    yield* Effect9.tryPromise({
       try: () => writeFile2(planPath, serializePlan(plan), "utf-8"),
       catch: (error) => new PlanStoreError({
         message: `Failed to update plan file: ${planPath}`,
@@ -4908,9 +4634,9 @@ var make3 = {
       })
     });
   }),
-  list: (sessionId) => Effect12.gen(function* () {
+  list: (sessionId) => Effect9.gen(function* () {
     const sessionDir = getSessionDir2(sessionId);
-    const files = yield* Effect12.tryPromise({
+    const files = yield* Effect9.tryPromise({
       try: async () => {
         try {
           return await readdir(sessionDir);
@@ -4927,103 +4653,16 @@ var make3 = {
     return files.filter((f) => f.endsWith(".json")).map((f) => PlanId(f.replace(".json", "")));
   })
 };
-var Live9 = Layer7.succeed(PlanStore, make3);
+var Live6 = Layer4.succeed(PlanStore, make3);
 var FileSystemPlan = {
-  Live: Live9
-};
-
-// src/commands/code/layers/plan/memory.ts
-init_esm_shims();
-import { Effect as Effect13, Layer as Layer8, Ref as Ref5 } from "effect";
-function createMemoryPlanStore(stateRef) {
-  return {
-    create: (sessionId, plan) => Effect13.gen(function* () {
-      const state = yield* Ref5.get(stateRef);
-      if (!state.has(sessionId)) {
-        state.set(sessionId, /* @__PURE__ */ new Map());
-      }
-      const sessionPlans = state.get(sessionId);
-      if (!sessionPlans) {
-        throw new Error("Session plans map should exist after set");
-      }
-      const planId = PlanId(`task-${sessionPlans.size + 1}`);
-      const fullPlan = { ...plan, id: planId };
-      sessionPlans.set(planId, fullPlan);
-      yield* Ref5.set(stateRef, state);
-      return planId;
-    }),
-    load: (planId, sessionId) => Effect13.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* Effect13.fail(
-          new PlanStoreError({
-            message: `Plan not found: ${planId}`,
-            operation: "load"
-          })
-        );
-      }
-      for (const sessionPlans of state.values()) {
-        const plan = sessionPlans.get(planId);
-        if (plan) {
-          return plan;
-        }
-      }
-      return yield* Effect13.fail(
-        new PlanStoreError({
-          message: `Plan not found: ${planId}`,
-          operation: "load"
-        })
-      );
-    }),
-    update: (planId, plan) => Effect13.gen(function* () {
-      const state = yield* Ref5.get(stateRef);
-      const sessionPlans = state.get(plan.sessionId);
-      if (!sessionPlans) {
-        return yield* Effect13.fail(
-          new PlanStoreError({
-            message: `Session not found: ${plan.sessionId}`,
-            operation: "update"
-          })
-        );
-      }
-      sessionPlans.set(planId, plan);
-      yield* Ref5.set(stateRef, state);
-    }),
-    list: (sessionId) => Effect13.gen(function* () {
-      const state = yield* Ref5.get(stateRef);
-      const sessionPlans = state.get(sessionId);
-      if (!sessionPlans) {
-        return [];
-      }
-      return Array.from(sessionPlans.keys());
-    })
-  };
-}
-function layer4() {
-  return Layer8.effect(
-    PlanStore,
-    Effect13.gen(function* () {
-      const stateRef = yield* Ref5.make(/* @__PURE__ */ new Map());
-      return createMemoryPlanStore(stateRef);
-    })
-  );
-}
-var Live10 = layer4();
-var MemoryPlan = {
-  Live: Live10,
-  layer: layer4
+  Live: Live6
 };
 
 // src/commands/code/layers/progress/file-system.ts
 init_esm_shims();
 import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
 import { join as join4 } from "path";
-import { DateTime as DateTime3, Effect as Effect14, Layer as Layer9 } from "effect";
+import { DateTime as DateTime2, Effect as Effect10, Layer as Layer5 } from "effect";
 
 // src/commands/code/services/progress-store.ts
 init_esm_shims();
@@ -5034,27 +4673,30 @@ var ProgressStore = class extends Context5.Tag("@ferix/ProgressStore")() {
 // src/commands/code/layers/progress/file-system.ts
 var PLANS_DIR3 = ".ferix/plans";
 function ensureDir3(dirPath) {
-  return Effect14.tryPromise({
+  return Effect10.tryPromise({
     try: () => mkdir4(dirPath, { recursive: true }),
     catch: (error) => new ProgressStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "append",
       cause: error
     })
-  }).pipe(Effect14.asVoid);
+  }).pipe(Effect10.asVoid);
 }
 function getSessionDir3(sessionId) {
   return join4(process.cwd(), PLANS_DIR3, sessionId);
 }
-function getProgressPath(sessionId) {
+function getProgressJsonPath(sessionId) {
   return join4(getSessionDir3(sessionId), "progress.json");
 }
+function getProgressMdPath(sessionId) {
+  return join4(getSessionDir3(sessionId), "progress.md");
+}
 function serializeProgress(progress) {
   return JSON.stringify(progress, null, 2);
 }
 function deserializeProgress(json) {
-  return Effect14.gen(function* () {
-    const parsed = yield* Effect14.try({
+  return Effect10.gen(function* () {
+    const parsed = yield* Effect10.try({
       try: () => JSON.parse(json),
       catch: (error) => new ProgressStoreError({
         message: `Invalid JSON in progress file: ${String(error)}`,
@@ -5063,7 +4705,7 @@ function deserializeProgress(json) {
       })
     });
     const validated = yield* decodeProgressFile(parsed).pipe(
-      Effect14.mapError(
+      Effect10.mapError(
         (error) => new ProgressStoreError({
           message: `Progress validation failed: ${String(error)}`,
           operation: "load",
@@ -5081,12 +4723,34 @@ function createEmptyProgress(sessionId, createdAt) {
     entries: []
   };
 }
+function writeProgressFiles(sessionId, progress, originalTask) {
+  return Effect10.gen(function* () {
+    const jsonPath = getProgressJsonPath(sessionId);
+    const mdPath = getProgressMdPath(sessionId);
+    yield* Effect10.tryPromise({
+      try: () => writeFile3(jsonPath, serializeProgress(progress), "utf-8"),
+      catch: (error) => new ProgressStoreError({
+        message: `Failed to write progress.json: ${jsonPath}`,
+        operation: "append",
+        cause: error
+      })
+    });
+    yield* Effect10.tryPromise({
+      try: () => writeFile3(mdPath, formatProgressMd(progress, originalTask), "utf-8"),
+      catch: (error) => new ProgressStoreError({
+        message: `Failed to write progress.md: ${mdPath}`,
+        operation: "append",
+        cause: error
+      })
+    });
+  });
+}
 var make4 = {
-  append: (sessionId, entry) => Effect14.gen(function* () {
+  append: (sessionId, entry) => Effect10.gen(function* () {
     const sessionDir = getSessionDir3(sessionId);
     yield* ensureDir3(sessionDir);
-    const progressPath = getProgressPath(sessionId);
-    const existing = yield* Effect14.tryPromise({
+    const progressPath = getProgressJsonPath(sessionId);
+    const existing = yield* Effect10.tryPromise({
       try: async () => {
         try {
           const content = await readFile4(progressPath, "utf-8");
@@ -5104,7 +4768,7 @@ var make4 = {
     let progress;
     if (existing) {
       progress = yield* deserializeProgress(existing).pipe(
-        Effect14.mapError(
+        Effect10.mapError(
           (err) => new ProgressStoreError({
             message: err.message,
             operation: "append",
@@ -5113,25 +4777,18 @@ var make4 = {
         )
       );
     } else {
-      const now = yield* DateTime3.now;
-      progress = createEmptyProgress(sessionId, DateTime3.formatIso(now));
+      const now = yield* DateTime2.now;
+      progress = createEmptyProgress(sessionId, DateTime2.formatIso(now));
     }
     const updatedProgress = {
       ...progress,
       entries: [...progress.entries, entry]
     };
-    yield* Effect14.tryPromise({
-      try: () => writeFile3(progressPath, serializeProgress(updatedProgress), "utf-8"),
-      catch: (error) => new ProgressStoreError({
-        message: `Failed to write progress file: ${progressPath}`,
-        operation: "append",
-        cause: error
-      })
-    });
+    yield* writeProgressFiles(sessionId, updatedProgress);
   }),
-  load: (sessionId) => Effect14.gen(function* () {
-    const progressPath = getProgressPath(sessionId);
-    const content = yield* Effect14.tryPromise({
+  load: (sessionId) => Effect10.gen(function* () {
+    const progressPath = getProgressJsonPath(sessionId);
+    const content = yield* Effect10.tryPromise({
       try: async () => {
         try {
           return await readFile4(progressPath, "utf-8");
@@ -5146,94 +4803,124 @@ var make4 = {
       })
     });
     if (content === null) {
-      const now = yield* DateTime3.now;
-      return createEmptyProgress(sessionId, DateTime3.formatIso(now));
+      const now = yield* DateTime2.now;
+      return createEmptyProgress(sessionId, DateTime2.formatIso(now));
     }
     return yield* deserializeProgress(content);
   }),
-  getRecent: (sessionId, count) => Effect14.gen(function* () {
+  getRecent: (sessionId, count) => Effect10.gen(function* () {
     const progress = yield* make4.load(sessionId);
     const entries = progress.entries;
     return entries.slice(-count);
   })
 };
-var Live11 = Layer9.succeed(ProgressStore, make4);
+var Live7 = Layer5.succeed(ProgressStore, make4);
 var FileSystemProgress = {
-  Live: Live11
+  Live: Live7
 };
 
-// src/commands/code/layers/progress/memory.ts
+// src/commands/code/layers/prompt/file-system.ts
 init_esm_shims();
-import { DateTime as DateTime4, Effect as Effect15, Layer as Layer10, Ref as Ref6 } from "effect";
-function createMemoryProgressStore(stateRef) {
-  return {
-    append: (sessionId, entry) => Effect15.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) => Effect15.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) => Effect15.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,
-    Effect15.gen(function* () {
-      const stateRef = yield* Ref6.make(/* @__PURE__ */ new Map());
-      return createMemoryProgressStore(stateRef);
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname2, join as join5 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Effect as Effect11, Layer as Layer6 } from "effect";
+
+// src/commands/code/services/prompt-store.ts
+init_esm_shims();
+import { Context as Context6 } from "effect";
+var PromptStore = class extends Context6.Tag("@ferix/PromptStore")() {
+};
+
+// src/commands/code/layers/prompt/file-system.ts
+var PLANS_DIR4 = ".ferix/plans";
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var BUNDLED_TEMPLATE_PATH = join5(__dirname2, "../../templates/PROMPT.md");
+function ensureDir4(dirPath) {
+  return Effect11.tryPromise({
+    try: () => mkdir5(dirPath, { recursive: true }),
+    catch: (error) => new PromptStoreError({
+      message: `Failed to create directory: ${dirPath}`,
+      operation: "copy",
+      cause: error
     })
-  );
+  }).pipe(Effect11.asVoid);
+}
+function getSessionDir4(sessionId) {
+  return join5(process.cwd(), PLANS_DIR4, sessionId);
+}
+function getPromptPath(sessionId) {
+  return join5(getSessionDir4(sessionId), "PROMPT.md");
 }
-var Live12 = layer5();
-var MemoryProgress = {
-  Live: Live12,
-  layer: layer5
+var cachedTemplate = null;
+var make5 = {
+  copyTemplate: (sessionId) => Effect11.gen(function* () {
+    const sessionDir = getSessionDir4(sessionId);
+    yield* ensureDir4(sessionDir);
+    const template = yield* make5.getBundledTemplate();
+    const promptPath = getPromptPath(sessionId);
+    yield* Effect11.tryPromise({
+      try: () => writeFile4(promptPath, template, "utf-8"),
+      catch: (error) => new PromptStoreError({
+        message: `Failed to write PROMPT.md: ${promptPath}`,
+        operation: "copy",
+        cause: error
+      })
+    });
+  }),
+  read: (sessionId) => Effect11.gen(function* () {
+    const promptPath = getPromptPath(sessionId);
+    const sessionTemplate = yield* Effect11.tryPromise({
+      try: async () => {
+        try {
+          return await readFile5(promptPath, "utf-8");
+        } catch {
+          return null;
+        }
+      },
+      catch: (error) => new PromptStoreError({
+        message: `Failed to read PROMPT.md: ${promptPath}`,
+        operation: "read",
+        cause: error
+      })
+    });
+    if (sessionTemplate !== null) {
+      return sessionTemplate;
+    }
+    return yield* make5.getBundledTemplate();
+  }),
+  getBundledTemplate: () => Effect11.gen(function* () {
+    if (cachedTemplate !== null) {
+      return cachedTemplate;
+    }
+    const template = yield* Effect11.tryPromise({
+      try: () => readFile5(BUNDLED_TEMPLATE_PATH, "utf-8"),
+      catch: (error) => new PromptStoreError({
+        message: `Failed to read bundled PROMPT.md: ${BUNDLED_TEMPLATE_PATH}`,
+        operation: "read",
+        cause: error
+      })
+    });
+    cachedTemplate = template;
+    return template;
+  })
+};
+var Live8 = Layer6.succeed(PromptStore, make5);
+var FileSystemPrompt = {
+  Live: Live8
 };
 
 // src/commands/code/layers/session/file-system.ts
 init_esm_shims();
-import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import { join as join5 } from "path";
-import { DateTime as DateTime5, Effect as Effect16, Layer as Layer11 } from "effect";
+import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { join as join6 } from "path";
+import { DateTime as DateTime3, Effect as Effect12, Layer as Layer7 } from "effect";
 import { humanId } from "human-id";
 
 // src/commands/code/services/session-store.ts
 init_esm_shims();
-import { Context as Context6 } from "effect";
-var SessionStore = class extends Context6.Tag("@ferix/SessionStore")() {
+import { Context as Context7 } from "effect";
+var SessionStore = class extends Context7.Tag("@ferix/SessionStore")() {
 };
 
 // src/commands/code/layers/session/file-system.ts
@@ -5242,25 +4929,25 @@ function generateSessionId(timestampMs) {
   const id = humanId({ separator: "-", capitalize: false });
   return `${id}-${timestampMs}`;
 }
-function ensureDir4(dirPath) {
-  return Effect16.tryPromise({
-    try: () => mkdir5(dirPath, { recursive: true }),
+function ensureDir5(dirPath) {
+  return Effect12.tryPromise({
+    try: () => mkdir6(dirPath, { recursive: true }),
     catch: (error) => new SessionStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "create",
       cause: error
     })
-  }).pipe(Effect16.asVoid);
+  }).pipe(Effect12.asVoid);
 }
 function getSessionPath(sessionId) {
-  return join5(process.cwd(), SESSIONS_DIR, `${sessionId}.json`);
+  return join6(process.cwd(), SESSIONS_DIR, `${sessionId}.json`);
 }
 function serializeSession(session) {
   return JSON.stringify(session, null, 2);
 }
 function deserializeSession(json) {
-  return Effect16.gen(function* () {
-    const parsed = yield* Effect16.try({
+  return Effect12.gen(function* () {
+    const parsed = yield* Effect12.try({
       try: () => JSON.parse(json),
       catch: (error) => new SessionStoreError({
         message: `Invalid JSON in session file: ${String(error)}`,
@@ -5269,7 +4956,7 @@ function deserializeSession(json) {
       })
     });
     const validated = yield* decodeSession(parsed).pipe(
-      Effect16.mapError(
+      Effect12.mapError(
         (error) => new SessionStoreError({
           message: `Session validation failed: ${String(error)}`,
           operation: "get",
@@ -5280,23 +4967,23 @@ function deserializeSession(json) {
     return validated;
   });
 }
-var make5 = {
-  create: (originalTask) => Effect16.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);
+var make6 = {
+  create: (originalTask, providedSessionId) => Effect12.gen(function* () {
+    const sessionsDir = join6(process.cwd(), SESSIONS_DIR);
+    yield* ensureDir5(sessionsDir);
+    const now = yield* DateTime3.now;
+    const timestampMs = DateTime3.toEpochMillis(now);
+    const sessionId = providedSessionId ?? generateSessionId(timestampMs);
     const session = {
       id: sessionId,
-      createdAt: DateTime5.formatIso(now),
+      createdAt: DateTime3.formatIso(now),
       status: "active",
       originalTask,
       completedTasks: []
     };
     const sessionPath = getSessionPath(sessionId);
-    yield* Effect16.tryPromise({
-      try: () => writeFile4(sessionPath, serializeSession(session), "utf-8"),
+    yield* Effect12.tryPromise({
+      try: () => writeFile5(sessionPath, serializeSession(session), "utf-8"),
       catch: (error) => new SessionStoreError({
         message: `Failed to write session file: ${sessionPath}`,
         operation: "create",
@@ -5305,10 +4992,10 @@ var make5 = {
     });
     return session;
   }),
-  get: (sessionId) => Effect16.gen(function* () {
+  get: (sessionId) => Effect12.gen(function* () {
     const sessionPath = getSessionPath(sessionId);
-    const content = yield* Effect16.tryPromise({
-      try: () => readFile5(sessionPath, "utf-8"),
+    const content = yield* Effect12.tryPromise({
+      try: () => readFile6(sessionPath, "utf-8"),
       catch: (error) => new SessionStoreError({
         message: `Failed to read session file: ${sessionPath}`,
         operation: "get",
@@ -5317,10 +5004,10 @@ var make5 = {
     });
     return yield* deserializeSession(content);
   }),
-  update: (sessionId, session) => Effect16.gen(function* () {
+  update: (sessionId, session) => Effect12.gen(function* () {
     const sessionPath = getSessionPath(sessionId);
-    yield* Effect16.tryPromise({
-      try: () => writeFile4(sessionPath, serializeSession(session), "utf-8"),
+    yield* Effect12.tryPromise({
+      try: () => writeFile5(sessionPath, serializeSession(session), "utf-8"),
       catch: (error) => new SessionStoreError({
         message: `Failed to update session file: ${sessionPath}`,
         operation: "update",
@@ -5329,84 +5016,19 @@ var make5 = {
     });
   })
 };
-var Live13 = Layer11.succeed(SessionStore, make5);
+var Live9 = Layer7.succeed(SessionStore, make6);
 var FileSystemSession = {
-  Live: Live13
-};
-
-// src/commands/code/layers/session/memory.ts
-init_esm_shims();
-import { DateTime as DateTime6, Effect as Effect17, Layer as Layer12, Ref as Ref7 } from "effect";
-function createMemorySessionStore(stateRef, counterRef) {
-  return {
-    create: (originalTask) => Effect17.gen(function* () {
-      const state = yield* Ref7.get(stateRef);
-      const counter = yield* Ref7.updateAndGet(counterRef, (n) => n + 1);
-      const sessionId = `test-session-${counter}`;
-      const now = yield* DateTime6.now;
-      const session = {
-        id: sessionId,
-        createdAt: DateTime6.formatIso(now),
-        status: "active",
-        originalTask,
-        completedTasks: []
-      };
-      state.set(sessionId, session);
-      yield* Ref7.set(stateRef, state);
-      return session;
-    }),
-    get: (sessionId) => Effect17.gen(function* () {
-      const state = yield* Ref7.get(stateRef);
-      const session = state.get(sessionId);
-      if (!session) {
-        return yield* Effect17.fail(
-          new SessionStoreError({
-            message: `Session not found: ${sessionId}`,
-            operation: "get"
-          })
-        );
-      }
-      return session;
-    }),
-    update: (sessionId, session) => Effect17.gen(function* () {
-      const state = yield* Ref7.get(stateRef);
-      if (!state.has(sessionId)) {
-        return yield* Effect17.fail(
-          new SessionStoreError({
-            message: `Session not found: ${sessionId}`,
-            operation: "update"
-          })
-        );
-      }
-      state.set(sessionId, session);
-      yield* Ref7.set(stateRef, state);
-    })
-  };
-}
-function layer6() {
-  return Layer12.effect(
-    SessionStore,
-    Effect17.gen(function* () {
-      const stateRef = yield* Ref7.make(/* @__PURE__ */ new Map());
-      const counterRef = yield* Ref7.make(0);
-      return createMemorySessionStore(stateRef, counterRef);
-    })
-  );
-}
-var Live14 = layer6();
-var MemorySession = {
-  Live: Live14,
-  layer: layer6
+  Live: Live9
 };
 
 // src/commands/code/layers/signal/ferix-parser.ts
 init_esm_shims();
-import { Effect as Effect18, Layer as Layer13, Ref as Ref8 } from "effect";
+import { Effect as Effect13, Layer as Layer8, Ref as Ref3 } from "effect";
 
 // src/commands/code/services/signal-parser.ts
 init_esm_shims();
-import { Context as Context7 } from "effect";
-var SignalParser = class extends Context7.Tag("@ferix/SignalParser")() {
+import { Context as Context8 } from "effect";
+var SignalParser = class extends Context8.Tag("@ferix/SignalParser")() {
 };
 
 // src/commands/code/layers/signal/specs/index.ts
@@ -5414,7 +5036,7 @@ init_esm_shims();
 
 // src/commands/code/layers/signal/specs/check.ts
 init_esm_shims();
-import { Either as Either6 } from "effect";
+import { Either as Either5 } from "effect";
 
 // src/commands/code/layers/signal/specs/registry.ts
 init_esm_shims();
@@ -5471,7 +5093,7 @@ var checkPassedSpec = {
   parse: (text) => {
     if (CHECK_PASSED.test(text)) {
       const result = createCheckPassedSignal({});
-      if (Either6.isRight(result)) {
+      if (Either5.isRight(result)) {
         return [result.right];
       }
     }
@@ -5486,7 +5108,7 @@ var checkFailedSpec = {
   parse: (text) => {
     if (CHECK_FAILED.test(text)) {
       const result = createCheckFailedSignal({});
-      if (Either6.isRight(result)) {
+      if (Either5.isRight(result)) {
         return [result.right];
       }
     }
@@ -5499,7 +5121,7 @@ signalSpecRegistry.register(checkFailedSpec);
 
 // src/commands/code/layers/signal/specs/criteria.ts
 init_esm_shims();
-import { Either as Either7 } from "effect";
+import { Either as Either6 } 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;
@@ -5529,7 +5151,7 @@ var criteriaDefinedSpec = {
           taskId: match[1],
           criteria
         });
-        if (Either7.isRight(result)) {
+        if (Either6.isRight(result)) {
           signals.push(result.right);
         }
       }
@@ -5547,7 +5169,7 @@ var criterionPassedSpec = {
     for (const m of text.matchAll(resetRegex(CRITERION_PASSED))) {
       if (m[1]) {
         const result = createCriterionPassedSignal({ criterionId: m[1] });
-        if (Either7.isRight(result)) {
+        if (Either6.isRight(result)) {
           signals.push(result.right);
         }
       }
@@ -5568,7 +5190,7 @@ var criterionFailedSpec = {
           criterionId: m[1],
           reason: m[2] || "Unknown reason"
         });
-        if (Either7.isRight(result)) {
+        if (Either6.isRight(result)) {
           signals.push(result.right);
         }
       }
@@ -5583,7 +5205,7 @@ signalSpecRegistry.register(criterionFailedSpec);
 
 // src/commands/code/layers/signal/specs/guardrail.ts
 init_esm_shims();
-import { Either as Either8 } from "effect";
+import { Either as Either7 } 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>/;
@@ -5613,7 +5235,7 @@ var guardrailSpec = {
         avoidance,
         severity
       });
-      if (Either8.isRight(result)) {
+      if (Either7.isRight(result)) {
         signals.push(result.right);
       }
     }
@@ -5625,7 +5247,7 @@ signalSpecRegistry.register(guardrailSpec);
 
 // src/commands/code/layers/signal/specs/learning.ts
 init_esm_shims();
-import { Either as Either9 } from "effect";
+import { Either as Either8 } from "effect";
 var LEARNING = /<ferix:learning(?:\s+category="(success|failure|optimization)")?\s*>([\s\S]*?)<\/ferix:learning>/g;
 var learningSpec = {
   tag: "Learning",
@@ -5641,7 +5263,7 @@ var learningSpec = {
         continue;
       }
       const result = createLearningSignal({ content, category });
-      if (Either9.isRight(result)) {
+      if (Either8.isRight(result)) {
         signals.push(result.right);
       }
     }
@@ -5653,7 +5275,7 @@ signalSpecRegistry.register(learningSpec);
 
 // src/commands/code/layers/signal/specs/loop-complete.ts
 init_esm_shims();
-import { Schema as S20 } from "effect";
+import { Schema as S19 } from "effect";
 var LOOP_COMPLETE = /<ferix:complete>/;
 var loopCompleteSpec = {
   tag: "LoopComplete",
@@ -5662,7 +5284,7 @@ var loopCompleteSpec = {
   parse: (text) => {
     if (LOOP_COMPLETE.test(text)) {
       const raw = { _tag: "LoopComplete" };
-      const result = S20.decodeUnknownEither(LoopCompleteSignalSchema)(raw);
+      const result = S19.decodeUnknownEither(LoopCompleteSignalSchema)(raw);
       if (result._tag === "Right") {
         return [result.right];
       }
@@ -5675,7 +5297,7 @@ signalSpecRegistry.register(loopCompleteSpec);
 
 // src/commands/code/layers/signal/specs/phases.ts
 init_esm_shims();
-import { Either as Either10 } from "effect";
+import { Either as Either9 } 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;
@@ -5704,7 +5326,7 @@ var phasesDefinedSpec = {
       return [];
     }
     const result = createPhasesDefinedSignal({ taskId: match[1], phases });
-    if (Either10.isRight(result)) {
+    if (Either9.isRight(result)) {
       return [result.right];
     }
     return [];
@@ -5720,7 +5342,7 @@ var phaseStartedSpec = {
     for (const m of text.matchAll(resetRegex2(PHASE_START))) {
       if (m[1]) {
         const result = createPhaseStartedSignal({ phaseId: m[1] });
-        if (Either10.isRight(result)) {
+        if (Either9.isRight(result)) {
           signals.push(result.right);
         }
       }
@@ -5738,7 +5360,7 @@ var phaseCompletedSpec = {
     for (const m of text.matchAll(resetRegex2(PHASE_DONE))) {
       if (m[1]) {
         const result = createPhaseCompletedSignal({ phaseId: m[1] });
-        if (Either10.isRight(result)) {
+        if (Either9.isRight(result)) {
           signals.push(result.right);
         }
       }
@@ -5759,7 +5381,7 @@ var phaseFailedSpec = {
           phaseId: m[1],
           reason: m[2] || "Unknown reason"
         });
-        if (Either10.isRight(result)) {
+        if (Either9.isRight(result)) {
           signals.push(result.right);
         }
       }
@@ -5775,7 +5397,7 @@ signalSpecRegistry.register(phaseFailedSpec);
 
 // src/commands/code/layers/signal/specs/review.ts
 init_esm_shims();
-import { Schema as S21 } from "effect";
+import { Schema as S20 } from "effect";
 var REVIEW_COMPLETE = /<ferix:review-complete\/>/;
 var REVIEW_CHANGES = /<ferix:review-changes-made\/>/;
 var reviewCompleteSpec = {
@@ -5788,7 +5410,7 @@ var reviewCompleteSpec = {
     }
     const changesMade = REVIEW_CHANGES.test(text);
     const raw = { _tag: "ReviewComplete", changesMade };
-    const result = S21.decodeUnknownEither(ReviewCompleteSignalSchema)(raw);
+    const result = S20.decodeUnknownEither(ReviewCompleteSignalSchema)(raw);
     if (result._tag === "Right") {
       return [result.right];
     }
@@ -5800,7 +5422,7 @@ signalSpecRegistry.register(reviewCompleteSpec);
 
 // src/commands/code/layers/signal/specs/session-name.ts
 init_esm_shims();
-import { Either as Either11 } from "effect";
+import { Either as Either10 } from "effect";
 var SESSION_NAME = /<ferix:session-name>([\s\S]*?)<\/ferix:session-name>/g;
 function sanitizeSessionName(name) {
   return name.trim().toLowerCase().replace(/[\s_]+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
@@ -5819,7 +5441,7 @@ var sessionNameSpec = {
         continue;
       }
       const result = createSessionNameDefinedSignal({ name });
-      if (Either11.isRight(result)) {
+      if (Either10.isRight(result)) {
         signals.push(result.right);
       }
     }
@@ -5831,7 +5453,7 @@ signalSpecRegistry.register(sessionNameSpec);
 
 // src/commands/code/layers/signal/specs/task-complete.ts
 init_esm_shims();
-import { Schema as S22 } from "effect";
+import { Schema as S21 } 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>/;
@@ -5862,7 +5484,7 @@ var taskCompleteSpec = {
       filesModified: parseFileList(filesModifiedMatch?.[1]),
       filesCreated: parseFileList(filesCreatedMatch?.[1])
     };
-    const result = S22.decodeUnknownEither(TaskCompleteSignalSchema)(raw);
+    const result = S21.decodeUnknownEither(TaskCompleteSignalSchema)(raw);
     if (result._tag === "Right") {
       return [result.right];
     }
@@ -5874,7 +5496,7 @@ signalSpecRegistry.register(taskCompleteSpec);
 
 // src/commands/code/layers/signal/specs/tasks.ts
 init_esm_shims();
-import { Either as Either12 } from "effect";
+import { Either as Either11 } from "effect";
 var TASKS_BLOCK = /<ferix:tasks>([\s\S]*?)<\/ferix:tasks>/;
 var TASK = /<task id="(\d+)">([^<]+)<\/task>/g;
 function resetRegex3(pattern) {
@@ -5904,7 +5526,7 @@ var tasksDefinedSpec = {
       return [];
     }
     const result = createTasksDefinedSignal({ tasks });
-    if (Either12.isRight(result)) {
+    if (Either11.isRight(result)) {
       return [result.right];
     }
     return [];
@@ -5916,20 +5538,20 @@ signalSpecRegistry.register(tasksDefinedSpec);
 // src/commands/code/layers/signal/ferix-parser.ts
 var MAX_BUFFER_SIZE = 1024 * 1024;
 function createAccumulatorImpl() {
-  return Effect18.gen(function* () {
-    const chunksRef = yield* Ref8.make([]);
-    const emittedRef = yield* Ref8.make(/* @__PURE__ */ new Set());
-    const feed = (text) => Effect18.gen(function* () {
-      const chunks = yield* Ref8.get(chunksRef);
+  return Effect13.gen(function* () {
+    const chunksRef = yield* Ref3.make([]);
+    const emittedRef = yield* Ref3.make(/* @__PURE__ */ new Set());
+    const feed = (text) => Effect13.gen(function* () {
+      const chunks = yield* Ref3.get(chunksRef);
       chunks.push(text);
       const buffer = chunks.join("");
       if (buffer.length > MAX_BUFFER_SIZE) {
-        yield* Ref8.set(chunksRef, [
+        yield* Ref3.set(chunksRef, [
           buffer.slice(buffer.length - MAX_BUFFER_SIZE)
         ]);
       }
       const signals = signalSpecRegistry.parseAll(buffer);
-      const emitted = yield* Ref8.get(emittedRef);
+      const emitted = yield* Ref3.get(emittedRef);
       const newSignals = signals.filter((signal) => {
         const key = signalSpecRegistry.getSignalKey(signal);
         if (emitted.has(key)) {
@@ -5941,111 +5563,239 @@ function createAccumulatorImpl() {
       if (newSignals.length > 0) {
         const lastEndPos = signalSpecRegistry.findLastCompleteSignalEnd(buffer);
         if (lastEndPos > 0 && lastEndPos < buffer.length) {
-          yield* Ref8.set(chunksRef, [buffer.slice(lastEndPos)]);
+          yield* Ref3.set(chunksRef, [buffer.slice(lastEndPos)]);
         }
       }
-      yield* Ref8.set(emittedRef, emitted);
+      yield* Ref3.set(emittedRef, emitted);
       return newSignals;
     });
-    const flush = () => Effect18.gen(function* () {
-      const chunks = yield* Ref8.get(chunksRef);
+    const flush = () => Effect13.gen(function* () {
+      const chunks = yield* Ref3.get(chunksRef);
       const buffer = chunks.join("");
-      yield* Ref8.set(chunksRef, []);
-      const emitted = yield* Ref8.get(emittedRef);
+      yield* Ref3.set(chunksRef, []);
+      const emitted = yield* Ref3.get(emittedRef);
       const signals = signalSpecRegistry.parseAll(buffer);
       const result = signals.filter(
         (signal) => !emitted.has(signalSpecRegistry.getSignalKey(signal))
       );
-      yield* Ref8.set(emittedRef, /* @__PURE__ */ new Set());
+      yield* Ref3.set(emittedRef, /* @__PURE__ */ new Set());
       return result;
     });
     return { feed, flush };
   });
 }
-var make6 = {
-  parse: (text) => Effect18.succeed(signalSpecRegistry.parseAll(text)),
+var make7 = {
+  parse: (text) => Effect13.succeed(signalSpecRegistry.parseAll(text)),
   createAccumulator: createAccumulatorImpl
 };
-var Live15 = Layer13.succeed(SignalParser, make6);
+var Live10 = Layer8.succeed(SignalParser, make7);
 var FerixParser = {
-  Live: Live15
+  Live: Live10
+};
+
+// src/commands/code/layers/state/file-system.ts
+init_esm_shims();
+import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
+import { join as join7 } from "path";
+import { Effect as Effect14, Layer as Layer9 } from "effect";
+
+// src/commands/code/services/state-store.ts
+init_esm_shims();
+import { Context as Context9 } from "effect";
+var StateStore = class extends Context9.Tag("@ferix/StateStore")() {
+};
+
+// src/commands/code/layers/state/file-system.ts
+var PLANS_DIR5 = ".ferix/plans";
+function ensureDir6(dirPath) {
+  return Effect14.tryPromise({
+    try: () => mkdir7(dirPath, { recursive: true }),
+    catch: (error) => new StateStoreError({
+      message: `Failed to create directory: ${dirPath}`,
+      operation: "write",
+      cause: error
+    })
+  }).pipe(Effect14.asVoid);
+}
+function getSessionDir5(sessionId) {
+  return join7(process.cwd(), PLANS_DIR5, sessionId);
+}
+function getStatePath(sessionId) {
+  return join7(getSessionDir5(sessionId), "STATE.json");
+}
+function serializeState(state) {
+  return JSON.stringify(state, null, 2);
+}
+function deserializeState(json) {
+  return Effect14.gen(function* () {
+    const parsed = yield* Effect14.try({
+      try: () => JSON.parse(json),
+      catch: (error) => new StateStoreError({
+        message: `Invalid JSON in STATE.json: ${String(error)}`,
+        operation: "read",
+        cause: error
+      })
+    });
+    const validated = yield* decodeSessionState(parsed).pipe(
+      Effect14.mapError(
+        (error) => new StateStoreError({
+          message: `STATE.json validation failed: ${String(error)}`,
+          operation: "read",
+          cause: error
+        })
+      )
+    );
+    return validated;
+  });
+}
+var make8 = {
+  write: (sessionId, state) => Effect14.gen(function* () {
+    const sessionDir = getSessionDir5(sessionId);
+    yield* ensureDir6(sessionDir);
+    const statePath = getStatePath(sessionId);
+    yield* Effect14.tryPromise({
+      try: () => writeFile6(statePath, serializeState(state), "utf-8"),
+      catch: (error) => new StateStoreError({
+        message: `Failed to write STATE.json: ${statePath}`,
+        operation: "write",
+        cause: error
+      })
+    });
+  }),
+  read: (sessionId) => Effect14.gen(function* () {
+    const statePath = getStatePath(sessionId);
+    const content = yield* Effect14.tryPromise({
+      try: () => readFile7(statePath, "utf-8"),
+      catch: (error) => new StateStoreError({
+        message: `Failed to read STATE.json: ${statePath}`,
+        operation: "read",
+        cause: error
+      })
+    });
+    return yield* deserializeState(content);
+  })
+};
+var Live11 = Layer9.succeed(StateStore, make8);
+var FileSystemState = {
+  Live: Live11
 };
 
+// src/commands/code/layers/logger.ts
+init_esm_shims();
+import {
+  createWriteStream,
+  existsSync,
+  mkdirSync
+} from "fs";
+import { join as join8 } from "path";
+import { Layer as Layer10, Logger, LogLevel } from "effect";
+var LOGS_DIR = ".ferix/logs";
+function ensureLogsDir() {
+  const logsDir = join8(process.cwd(), LOGS_DIR);
+  if (!existsSync(logsDir)) {
+    mkdirSync(logsDir, { recursive: true });
+  }
+}
+function formatAnnotations(annotations) {
+  const parts = [];
+  for (const [key, value] of annotations) {
+    parts.push(`${key}=${JSON.stringify(value)}`);
+  }
+  return parts.join(" ");
+}
+function createFileLogger(logStream) {
+  return Logger.make(({ logLevel, message, date, annotations }) => {
+    const annotationsStr = formatAnnotations(annotations);
+    const messageStr = typeof message === "string" ? message : JSON.stringify(message);
+    const entry = `timestamp=${date.toISOString()} level=${logLevel.label} message=${JSON.stringify(messageStr)}${annotationsStr ? ` ${annotationsStr}` : ""}`;
+    logStream.write(`${entry}
+`);
+  });
+}
+function createLoggerLayer(debug, sessionId) {
+  if (!debug) {
+    return Layer10.empty;
+  }
+  ensureLogsDir();
+  const logPath = join8(process.cwd(), LOGS_DIR, `${sessionId}.log`);
+  const logStream = createWriteStream(logPath, { flags: "a" });
+  const fileLogger = createFileLogger(logStream);
+  return Layer10.merge(
+    Logger.minimumLogLevel(LogLevel.Debug),
+    Logger.replace(Logger.defaultLogger, fileLogger)
+  );
+}
+
 // src/commands/code/layers/index.ts
-var ProductionLayers = Layer14.mergeAll(
+var ProductionLayers = Layer11.mergeAll(
   ClaudeCLI.Live,
   FerixParser.Live,
   FileSystemPlan.Live,
   FileSystemSession.Live,
   FileSystemProgress.Live,
   FileSystemGuardrails.Live,
-  FileSystemGit.Live
+  FileSystemGit.Live,
+  FileSystemState.Live,
+  FileSystemPrompt.Live
 );
 function createProductionLayers(provider = "claude") {
   const llmLayer = createProviderLayer2(provider);
-  return Layer14.mergeAll(
+  return Layer11.mergeAll(
     llmLayer,
     FerixParser.Live,
     FileSystemPlan.Live,
     FileSystemSession.Live,
     FileSystemProgress.Live,
     FileSystemGuardrails.Live,
-    FileSystemGit.Live
+    FileSystemGit.Live,
+    FileSystemState.Live,
+    FileSystemPrompt.Live
   );
 }
-var TestLayers = Layer14.mergeAll(
-  Mock.Live,
-  FerixParser.Live,
-  MemoryPlan.Live,
-  MemorySession.Live,
-  MemoryProgress.Live,
-  MemoryGuardrails.Live,
-  MemoryGit.Live
-);
 
 // src/commands/code/orchestrator/index.ts
 init_esm_shims();
 
 // src/commands/code/orchestrator/loop.ts
 init_esm_shims();
-import { DateTime as DateTime10, Effect as Effect23, Option, pipe as pipe3, Ref as Ref12, Stream as Stream9 } from "effect";
+import { DateTime as DateTime7, Effect as Effect19, Option, pipe as pipe3, Ref as Ref7, Stream as Stream8 } from "effect";
 
 // src/commands/code/orchestrator/discovery.ts
 init_esm_shims();
-import { DateTime as DateTime8, Effect as Effect21, pipe, Ref as Ref10, Stream as Stream7 } from "effect";
+import { DateTime as DateTime5, Effect as Effect17, pipe, Ref as Ref5, Stream as Stream6 } from "effect";
 
 // src/commands/code/layers/plan/task-generation.ts
 init_esm_shims();
-import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import { join as join6 } from "path";
-import { Effect as Effect19 } from "effect";
-var PLANS_DIR4 = ".ferix/plans";
-function ensureDir5(dirPath) {
-  return Effect19.tryPromise({
-    try: () => mkdir6(dirPath, { recursive: true }),
+import { mkdir as mkdir8, writeFile as writeFile7 } from "fs/promises";
+import { join as join9 } from "path";
+import { Effect as Effect15 } from "effect";
+var PLANS_DIR6 = ".ferix/plans";
+function ensureDir7(dirPath) {
+  return Effect15.tryPromise({
+    try: () => mkdir8(dirPath, { recursive: true }),
     catch: (error) => new PlanStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "create",
       cause: error
     })
-  }).pipe(Effect19.asVoid);
-}
-function getSessionDir4(sessionId) {
-  return join6(process.cwd(), PLANS_DIR4, sessionId);
-}
-function getTasksMdPath(sessionId) {
-  return join6(getSessionDir4(sessionId), "tasks.md");
-}
-function writeTasksMd(sessionId, tasks) {
-  return Effect19.gen(function* () {
-    const sessionDir = getSessionDir4(sessionId);
-    yield* ensureDir5(sessionDir);
-    const tasksMdPath = getTasksMdPath(sessionId);
-    const content = formatTasksMd(tasks);
-    yield* Effect19.tryPromise({
-      try: () => writeFile5(tasksMdPath, content, "utf-8"),
+  }).pipe(Effect15.asVoid);
+}
+function getSessionDir6(sessionId) {
+  return join9(process.cwd(), PLANS_DIR6, sessionId);
+}
+function getTasksJsonPath(sessionId) {
+  return join9(getSessionDir6(sessionId), "tasks.json");
+}
+function writeTasksJson(sessionId, tasksFile) {
+  return Effect15.gen(function* () {
+    const sessionDir = getSessionDir6(sessionId);
+    yield* ensureDir7(sessionDir);
+    const tasksJsonPath = getTasksJsonPath(sessionId);
+    const content = formatTasksJson(tasksFile);
+    yield* Effect15.tryPromise({
+      try: () => writeFile7(tasksJsonPath, content, "utf-8"),
       catch: (error) => new PlanStoreError({
-        message: `Failed to write tasks.md: ${tasksMdPath}`,
+        message: `Failed to write tasks.json: ${tasksJsonPath}`,
         operation: "create",
         cause: error
       })
@@ -6234,7 +5984,7 @@ function mapSignalToDomain(signal, context) {
 
 // src/commands/code/orchestrator/plan-updates.ts
 init_esm_shims();
-import { DateTime as DateTime7, Effect as Effect20, Ref as Ref9 } from "effect";
+import { DateTime as DateTime4, Effect as Effect16, Ref as Ref4 } from "effect";
 
 // src/commands/code/orchestrator/plan-updates/index.ts
 init_esm_shims();
@@ -6556,9 +6306,9 @@ function persistPlanUpdate(planStore, plan, operation) {
     tasks: plan.tasks
   }) : planStore.update(plan.id, plan);
   return storeOp.pipe(
-    Effect20.map(() => null),
-    Effect20.catchAll(
-      (error) => Effect20.succeed({
+    Effect16.map(() => null),
+    Effect16.catchAll(
+      (error) => Effect16.succeed({
         _tag: "PlanUpdateFailed",
         operation,
         error: error.message,
@@ -6568,10 +6318,10 @@ function persistPlanUpdate(planStore, plan, operation) {
   );
 }
 function updatePlanFromSignal(currentPlanRef, persistenceStateRef, signal, sessionId, originalTask) {
-  return Effect20.gen(function* () {
-    const currentPlan = yield* Ref9.get(currentPlanRef);
-    const now = yield* DateTime7.now;
-    const timestamp = DateTime7.formatIso(now);
+  return Effect16.gen(function* () {
+    const currentPlan = yield* Ref4.get(currentPlanRef);
+    const now = yield* DateTime4.now;
+    const timestamp = DateTime4.formatIso(now);
     const updateResult = computePlanUpdate(signal, currentPlan, {
       sessionId,
       originalTask,
@@ -6581,8 +6331,8 @@ function updatePlanFromSignal(currentPlanRef, persistenceStateRef, signal, sessi
       return [];
     }
     const { plan, operation, eventTag } = updateResult;
-    yield* Ref9.set(currentPlanRef, plan);
-    yield* Ref9.update(persistenceStateRef, (state) => ({
+    yield* Ref4.set(currentPlanRef, plan);
+    yield* Ref4.update(persistenceStateRef, (state) => ({
       dirty: true,
       pendingOperation: state.pendingOperation === "create" ? "create" : operation
     }));
@@ -6590,12 +6340,12 @@ function updatePlanFromSignal(currentPlanRef, persistenceStateRef, signal, sessi
   });
 }
 function flushPlanPersistence(planStore, currentPlanRef, persistenceStateRef) {
-  return Effect20.gen(function* () {
-    const state = yield* Ref9.get(persistenceStateRef);
+  return Effect16.gen(function* () {
+    const state = yield* Ref4.get(persistenceStateRef);
     if (!(state.dirty && state.pendingOperation)) {
       return [];
     }
-    const plan = yield* Ref9.get(currentPlanRef);
+    const plan = yield* Ref4.get(currentPlanRef);
     if (!plan) {
       return [];
     }
@@ -6608,7 +6358,7 @@ function flushPlanPersistence(planStore, currentPlanRef, persistenceStateRef) {
     if (failureEvent) {
       events.push(failureEvent);
     }
-    yield* Ref9.set(persistenceStateRef, {
+    yield* Ref4.set(persistenceStateRef, {
       dirty: false,
       pendingOperation: null
     });
@@ -6678,7 +6428,7 @@ var DISCOVERY_SYSTEM_PROMPT = `You are in the DISCOVERY phase of a ralph loop -
 
 Your goal is to:
 1. Generate a short, descriptive name for this session
-2. Analyze the task and break it into logical subtasks
+2. Analyze the task and break it into SMALL, GRANULAR subtasks
 
 Your output must include these signals that the orchestrator will parse.
 These signals MUST appear on their own lines, not inside code blocks.
@@ -6700,6 +6450,21 @@ Guidelines for session name:
   <task id="2">Brief description of second task</task>
 </ferix:tasks>
 
+## Task Granularity Rules (CRITICAL)
+
+Apply the **"one sentence without 'and'" test**:
+- If describing a task requires "and" to connect unrelated functions, split it
+- Good: "Add login endpoint that validates credentials and returns JWT"
+- Bad: "Handle authentication, user profiles, and billing"
+
+Each task MUST be:
+- Small enough to complete in ONE context window
+- Testable in isolation with automated checks
+- A single logical unit of work
+
+For a typical feature, create 5-15 tasks.
+For complex projects, create 50-200+ discrete tasks.
+
 ## CRITICAL: Task Exclusions
 
 Do NOT create tasks for any of the following - these are handled automatically by the orchestrator:
@@ -6911,15 +6676,51 @@ function areAllTasksComplete(plan) {
   }
   return plan.tasks.every((t) => t.status === "done" || t.status === "skipped");
 }
+function buildSessionState(config, iteration, sessionId, plan, recentProgress = []) {
+  const currentTask = plan?.tasks.find(
+    (t) => t.status === "in_progress" || t.status === "pending"
+  );
+  const taskSummary = plan ? {
+    total: plan.tasks.length,
+    done: plan.tasks.filter((t) => t.status === "done").length,
+    inProgress: plan.tasks.filter((t) => t.status === "in_progress").length,
+    pending: plan.tasks.filter(
+      (t) => t.status === "pending" || t.status === "planning"
+    ).length
+  } : { total: 0, done: 0, inProgress: 0, pending: 0 };
+  return {
+    sessionId,
+    originalTask: config.task,
+    iteration,
+    maxIterations: config.maxIterations,
+    taskSummary,
+    currentTask: currentTask ? {
+      id: currentTask.id,
+      title: currentTask.title,
+      description: currentTask.description,
+      phases: currentTask.phases.map((p) => ({
+        id: p.id,
+        description: p.description,
+        status: p.status
+      })),
+      criteria: currentTask.criteria.map((c) => ({
+        id: c.id,
+        description: c.description,
+        status: c.status
+      }))
+    } : null,
+    recentProgress
+  };
+}
 
 // src/commands/code/orchestrator/discovery.ts
 function processTextSignals(signalParser, text, context) {
-  return Effect21.gen(function* () {
+  return Effect17.gen(function* () {
     const events = [];
     const parsedSignals = [];
     const signals = yield* signalParser.parse(text).pipe(
-      Effect21.tapError(
-        (error) => Effect21.logDebug(
+      Effect17.tapError(
+        (error) => Effect17.logDebug(
           "Signal parsing failed, continuing with empty signals",
           {
             error: String(error),
@@ -6927,7 +6728,7 @@ function processTextSignals(signalParser, text, context) {
           }
         )
       ),
-      Effect21.orElseSucceed(() => [])
+      Effect17.orElseSucceed(() => [])
     );
     for (const signal of signals) {
       events.push(mapSignalToDomain(signal, context));
@@ -6937,7 +6738,7 @@ function processTextSignals(signalParser, text, context) {
   });
 }
 function processLLMEvent(signalParser, llmEvent, context) {
-  return Effect21.gen(function* () {
+  return Effect17.gen(function* () {
     const domainEvent = mapLLMEventToDomain(llmEvent, context);
     const events = [domainEvent];
     const allSignals = [];
@@ -6973,23 +6774,29 @@ function mapTaskStatus(status) {
   }
   return "pending";
 }
-function planTasksToGeneratedTasks(plan) {
-  return plan.tasks.map((task) => ({
-    id: task.id,
-    title: task.title,
-    status: mapTaskStatus(task.status)
-  }));
+function planToTasksFile(plan, sessionId, originalTask) {
+  return {
+    sessionId,
+    originalTask,
+    tasks: plan.tasks.map((task) => ({
+      id: task.id,
+      title: task.title,
+      description: task.description,
+      status: mapTaskStatus(task.status),
+      steps: task.phases.map((p) => p.description)
+    }))
+  };
 }
-function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, config, sessionId, worktreePath, onSessionName) {
-  return Stream7.unwrap(
-    Effect21.gen(function* () {
-      const startTimeUtc = yield* DateTime8.now;
-      const startTime = DateTime8.toEpochMillis(startTimeUtc);
-      const persistenceStateRef = yield* Ref10.make({
+function createDiscoveryStream(llm, signalParser, planStore, stateStore, promptStore, progressStore, currentPlanRef, config, sessionId, worktreePath, onSessionName) {
+  return Stream6.unwrap(
+    Effect17.gen(function* () {
+      const startTimeUtc = yield* DateTime5.now;
+      const startTime = DateTime5.toEpochMillis(startTimeUtc);
+      const persistenceStateRef = yield* Ref5.make({
         dirty: false,
         pendingOperation: null
       });
-      const sessionNameRef = yield* Ref10.make(void 0);
+      const sessionNameRef = yield* Ref5.make(void 0);
       const discoveryStarted = {
         _tag: "DiscoveryStarted",
         timestamp: startTime
@@ -7000,20 +6807,20 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
         input: {}
       };
       const prompt = buildDiscoveryPrompt(config);
-      const llmStream = llm.execute(prompt, worktreePath ? { cwd: worktreePath } : void 0).pipe(
-        Stream7.mapError(
+      const llmStream = llm.execute(prompt, { cwd: worktreePath, yolo: config.yolo }).pipe(
+        Stream6.mapError(
           (e) => new OrchestratorError({
             message: `LLM execution failed during discovery: ${String(e)}`,
             phase: "discovery",
             cause: e
           })
         ),
-        Stream7.flatMap(
-          (llmEvent) => Stream7.unwrap(
-            Effect21.gen(function* () {
-              const now = yield* DateTime8.now;
+        Stream6.flatMap(
+          (llmEvent) => Stream6.unwrap(
+            Effect17.gen(function* () {
+              const now = yield* DateTime5.now;
               const context = {
-                timestamp: DateTime8.toEpochMillis(now)
+                timestamp: DateTime5.toEpochMillis(now)
               };
               const result = yield* processLLMEvent(
                 signalParser,
@@ -7023,7 +6830,7 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
               const events = [...result.events];
               for (const signal of result.signals) {
                 if (signal._tag === "SessionNameDefined") {
-                  yield* Ref10.set(sessionNameRef, signal.name);
+                  yield* Ref5.set(sessionNameRef, signal.name);
                 }
                 const planEvents = yield* updatePlanFromSignal(
                   currentPlanRef,
@@ -7034,13 +6841,13 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
                 );
                 events.push(...planEvents);
               }
-              return Stream7.fromIterable(events);
+              return Stream6.fromIterable(events);
             })
           )
         ),
         // Convert LLM errors to LoopFailed events
-        Stream7.catchAll(
-          (error) => Stream7.succeed({
+        Stream6.catchAll(
+          (error) => Stream6.succeed({
             _tag: "LoopFailed",
             error: {
               message: error.message,
@@ -7049,35 +6856,73 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
           })
         )
       );
-      const completionStream = Stream7.fromEffect(
-        Effect21.gen(function* () {
+      const completionStream = Stream6.fromEffect(
+        Effect17.gen(function* () {
           const persistEvents = yield* flushPlanPersistence(
             planStore,
             currentPlanRef,
             persistenceStateRef
           );
-          const plan = yield* Ref10.get(currentPlanRef);
+          const plan = yield* Ref5.get(currentPlanRef);
           const taskCount = plan?.tasks.length ?? 0;
+          yield* promptStore.copyTemplate(sessionId).pipe(
+            Effect17.tapError(
+              (error) => Effect17.logDebug("Failed to copy PROMPT.md, continuing", {
+                error: String(error)
+              })
+            ),
+            Effect17.orElseSucceed(() => void 0)
+          );
           if (plan && plan.tasks.length > 0) {
-            const generatedTasks = planTasksToGeneratedTasks(plan);
-            yield* writeTasksMd(sessionId, generatedTasks).pipe(
-              Effect21.tapError(
-                (error) => Effect21.logDebug("Failed to write tasks.md, continuing", {
+            const tasksFile = planToTasksFile(plan, sessionId, config.task);
+            yield* writeTasksJson(sessionId, tasksFile).pipe(
+              Effect17.tapError(
+                (error) => Effect17.logDebug("Failed to write tasks.json, continuing", {
                   error: String(error)
                 })
               ),
-              Effect21.orElseSucceed(() => void 0)
+              Effect17.orElseSucceed(() => void 0)
+            );
+            const recentEntries = yield* progressStore.getRecent(sessionId, 5).pipe(
+              Effect17.tapError(
+                (error) => Effect17.logDebug(
+                  "Failed to get recent progress, continuing",
+                  {
+                    error: String(error)
+                  }
+                )
+              ),
+              Effect17.orElseSucceed(() => [])
+            );
+            const recentProgress = recentEntries.map(
+              (entry) => `[${entry.action}] Task ${entry.taskId}: ${entry.summary}`
+            );
+            const initialState = buildSessionState(
+              config,
+              0,
+              // iteration 0 = discovery
+              sessionId,
+              plan,
+              recentProgress
+            );
+            yield* stateStore.write(sessionId, initialState).pipe(
+              Effect17.tapError(
+                (error) => Effect17.logDebug("Failed to write STATE.json, continuing", {
+                  error: String(error)
+                })
+              ),
+              Effect17.orElseSucceed(() => void 0)
             );
           }
-          const endTimeUtc = yield* DateTime8.now;
-          const endTime = DateTime8.toEpochMillis(endTimeUtc);
+          const endTimeUtc = yield* DateTime5.now;
+          const endTime = DateTime5.toEpochMillis(endTimeUtc);
           const events = [...persistEvents];
-          const capturedName = yield* Ref10.get(sessionNameRef);
+          const capturedName = yield* Ref5.get(sessionNameRef);
           if (capturedName) {
             if (onSessionName) {
               yield* onSessionName(capturedName).pipe(
-                Effect21.tapError(
-                  (error) => Effect21.logDebug(
+                Effect17.tapError(
+                  (error) => Effect17.logDebug(
                     "Failed to handle session name, continuing",
                     {
                       error: String(error),
@@ -7085,7 +6930,7 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
                     }
                   )
                 ),
-                Effect21.orElseSucceed(() => void 0)
+                Effect17.orElseSucceed(() => void 0)
               );
             }
             const sessionNameEvent = {
@@ -7104,12 +6949,12 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
           events.push(discoveryCompleted);
           return events;
         })
-      ).pipe(Stream7.flatMap((events) => Stream7.fromIterable(events)));
+      ).pipe(Stream6.flatMap((events) => Stream6.fromIterable(events)));
       return pipe(
-        Stream7.succeed(discoveryStarted),
-        Stream7.concat(Stream7.succeed(analysingToolUse)),
-        Stream7.concat(llmStream),
-        Stream7.concat(completionStream)
+        Stream6.succeed(discoveryStarted),
+        Stream6.concat(Stream6.succeed(analysingToolUse)),
+        Stream6.concat(llmStream),
+        Stream6.concat(completionStream)
       );
     })
   );
@@ -7117,15 +6962,15 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
 
 // src/commands/code/orchestrator/iteration.ts
 init_esm_shims();
-import { DateTime as DateTime9, Effect as Effect22, pipe as pipe2, Ref as Ref11, Stream as Stream8 } from "effect";
+import { DateTime as DateTime6, Effect as Effect18, pipe as pipe2, Ref as Ref6, Stream as Stream7 } from "effect";
 function processTextSignals2(signalParser, text, context) {
-  return Effect22.gen(function* () {
+  return Effect18.gen(function* () {
     const events = [];
     let completed = false;
     const parsedSignals = [];
     const signals = yield* signalParser.parse(text).pipe(
-      Effect22.tapError(
-        (error) => Effect22.logDebug(
+      Effect18.tapError(
+        (error) => Effect18.logDebug(
           "Signal parsing failed, continuing with empty signals",
           {
             error: String(error),
@@ -7133,8 +6978,14 @@ function processTextSignals2(signalParser, text, context) {
           }
         )
       ),
-      Effect22.orElseSucceed(() => [])
+      Effect18.orElseSucceed(() => [])
     );
+    if (signals.length > 0) {
+      yield* Effect18.logDebug("Signals parsed", {
+        signals: signals.map((s) => s._tag),
+        count: signals.length
+      });
+    }
     for (const signal of signals) {
       events.push(mapSignalToDomain(signal, context));
       parsedSignals.push(signal);
@@ -7146,7 +6997,7 @@ function processTextSignals2(signalParser, text, context) {
   });
 }
 function processLLMEvent2(signalParser, llmEvent, context) {
-  return Effect22.gen(function* () {
+  return Effect18.gen(function* () {
     const domainEvent = mapLLMEventToDomain(llmEvent, context);
     const events = [domainEvent];
     let completed = false;
@@ -7177,11 +7028,11 @@ function processLLMEvent2(signalParser, llmEvent, context) {
     return { events, completed, signals: allSignals };
   });
 }
-function createIterationStream(llm, signalParser, planStore, currentPlanRef, loopCompletedRef, config, iteration, sessionId, worktreePath) {
-  return Stream8.unwrap(
-    Effect22.gen(function* () {
-      const currentPlan = yield* Ref11.get(currentPlanRef);
-      const persistenceStateRef = yield* Ref11.make({
+function createIterationStream(llm, signalParser, planStore, stateStore, progressStore, currentPlanRef, loopCompletedRef, config, iteration, sessionId, worktreePath) {
+  return Stream7.unwrap(
+    Effect18.gen(function* () {
+      const currentPlan = yield* Ref6.get(currentPlanRef);
+      const persistenceStateRef = yield* Ref6.make({
         dirty: false,
         pendingOperation: null
       });
@@ -7189,23 +7040,56 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
         _tag: "IterationStarted",
         iteration
       };
-      const llmStream = llm.execute(
-        buildPrompt(config, iteration, currentPlan),
-        worktreePath ? { cwd: worktreePath } : void 0
-      ).pipe(
-        Stream8.mapError(
+      const recentEntries = yield* progressStore.getRecent(sessionId, 5).pipe(
+        Effect18.tapError(
+          (error) => Effect18.logDebug("Failed to get recent progress, continuing", {
+            error: String(error)
+          })
+        ),
+        Effect18.orElseSucceed(() => [])
+      );
+      const recentProgress = recentEntries.map(
+        (entry) => `[${entry.action}] Task ${entry.taskId}: ${entry.summary}`
+      );
+      const state = buildSessionState(
+        config,
+        iteration,
+        sessionId,
+        currentPlan,
+        recentProgress
+      );
+      yield* stateStore.write(sessionId, state).pipe(
+        Effect18.tapError(
+          (error) => Effect18.logDebug("Failed to write STATE.json, continuing", {
+            error: String(error)
+          })
+        ),
+        Effect18.orElseSucceed(() => void 0)
+      );
+      const prompt = buildPrompt(config, iteration, currentPlan);
+      const promptPreview = prompt.slice(0, 200);
+      yield* Effect18.logDebug("Building prompt for iteration", {
+        iteration,
+        promptLength: prompt.length,
+        promptPreview: promptPreview.length < prompt.length ? `${promptPreview}...` : promptPreview
+      });
+      const llmStream = llm.execute(prompt, {
+        cwd: worktreePath,
+        yolo: config.yolo
+      }).pipe(
+        Stream7.mapError(
           (e) => new OrchestratorError({
             message: `LLM execution failed: ${String(e)}`,
             phase: "iteration",
             cause: e
           })
         ),
-        Stream8.flatMap(
-          (llmEvent) => Stream8.unwrap(
-            Effect22.gen(function* () {
-              const now = yield* DateTime9.now;
+        Stream7.flatMap(
+          (llmEvent) => Stream7.unwrap(
+            Effect18.gen(function* () {
+              const now = yield* DateTime6.now;
               const context = {
-                timestamp: DateTime9.toEpochMillis(now)
+                timestamp: DateTime6.toEpochMillis(now)
               };
               const result = yield* processLLMEvent2(
                 signalParser,
@@ -7224,14 +7108,14 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
                 events.push(...planEvents);
               }
               if (result.completed) {
-                yield* Effect22.logInfo(
+                yield* Effect18.logInfo(
                   "[DEBUG] createIterationStream: LLM emitted completion signal"
                 );
-                yield* Ref11.set(loopCompletedRef, true);
+                yield* Ref6.set(loopCompletedRef, true);
               }
-              const updatedPlan = yield* Ref11.get(currentPlanRef);
+              const updatedPlan = yield* Ref6.get(currentPlanRef);
               const allComplete = areAllTasksComplete(updatedPlan);
-              yield* Effect22.logInfo(
+              yield* Effect18.logInfo(
                 "[DEBUG] createIterationStream: Auto-complete check",
                 {
                   llmEmittedComplete: result.completed,
@@ -7243,18 +7127,18 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
                 }
               );
               if (allComplete) {
-                yield* Effect22.logInfo(
+                yield* Effect18.logInfo(
                   "[DEBUG] createIterationStream: All tasks complete - ending loop"
                 );
-                yield* Ref11.set(loopCompletedRef, true);
+                yield* Ref6.set(loopCompletedRef, true);
               }
-              return Stream8.fromIterable(events);
+              return Stream7.fromIterable(events);
             })
           )
         ),
         // Convert LLM errors to LoopFailed events with iteration context
-        Stream8.catchAll(
-          (error) => Stream8.succeed({
+        Stream7.catchAll(
+          (error) => Stream7.succeed({
             _tag: "LoopFailed",
             error: {
               message: error.message,
@@ -7264,8 +7148,8 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
           })
         )
       );
-      const completionStream = Stream8.fromEffect(
-        Effect22.gen(function* () {
+      const completionStream = Stream7.fromEffect(
+        Effect18.gen(function* () {
           const persistEvents = yield* flushPlanPersistence(
             planStore,
             currentPlanRef,
@@ -7277,11 +7161,11 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
           };
           return [...persistEvents, iterCompleted];
         })
-      ).pipe(Stream8.flatMap((events) => Stream8.fromIterable(events)));
+      ).pipe(Stream7.flatMap((events) => Stream7.fromIterable(events)));
       return pipe2(
-        Stream8.succeed(iterStarted),
-        Stream8.concat(llmStream),
-        Stream8.concat(completionStream)
+        Stream7.succeed(iterStarted),
+        Stream7.concat(llmStream),
+        Stream7.concat(completionStream)
       );
     })
   );
@@ -7289,15 +7173,18 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
 
 // src/commands/code/orchestrator/loop.ts
 function runLoop(config) {
-  return Stream9.unwrap(
-    Effect23.gen(function* () {
+  return Stream8.unwrap(
+    Effect19.gen(function* () {
       const llm = yield* LLM;
       const signalParser = yield* SignalParser;
       const sessionStore = yield* SessionStore;
       const planStore = yield* PlanStore;
+      const progressStore = yield* ProgressStore;
       const git = yield* Git;
-      const session = yield* sessionStore.create(config.task).pipe(
-        Effect23.mapError(
+      const stateStore = yield* StateStore;
+      const promptStore = yield* PromptStore;
+      const session = yield* sessionStore.create(config.task, config.sessionId).pipe(
+        Effect19.mapError(
           (e) => new OrchestratorError({
             message: `Failed to create session: ${e.message}`,
             phase: "setup",
@@ -7306,15 +7193,15 @@ function runLoop(config) {
         )
       );
       const baseBranch = yield* git.getCurrentBranch().pipe(
-        Effect23.tapError(
-          (error) => Effect23.logDebug("Failed to get current branch", {
+        Effect19.tapError(
+          (error) => Effect19.logDebug("Failed to get current branch", {
             error: String(error)
           })
         ),
-        Effect23.orElseSucceed(() => void 0)
+        Effect19.orElseSucceed(() => void 0)
       );
       const worktreePath = yield* git.createWorktree(session.id).pipe(
-        Effect23.mapError(
+        Effect19.mapError(
           (e) => new OrchestratorError({
             message: `Failed to create worktree: ${e.message}`,
             phase: "setup",
@@ -7329,15 +7216,15 @@ function runLoop(config) {
         branchName,
         baseBranch
       }).pipe(
-        Effect23.tapError(
-          (error) => Effect23.logDebug("Failed to update session with worktree info", {
+        Effect19.tapError(
+          (error) => Effect19.logDebug("Failed to update session with worktree info", {
             error: String(error)
           })
         ),
-        Effect23.orElseSucceed(() => void 0)
+        Effect19.orElseSucceed(() => void 0)
       );
-      const startTimeUtc = yield* DateTime10.now;
-      const startTime = DateTime10.toEpochMillis(startTimeUtc);
+      const startTimeUtc = yield* DateTime7.now;
+      const startTime = DateTime7.toEpochMillis(startTimeUtc);
       const worktreeCreated = {
         _tag: "WorktreeCreated",
         sessionId: session.id,
@@ -7345,18 +7232,18 @@ function runLoop(config) {
         branchName,
         timestamp: startTime
       };
-      const loopCompletedRef = yield* Ref12.make(false);
-      const currentPlanRef = yield* Ref12.make(void 0);
+      const loopCompletedRef = yield* Ref7.make(false);
+      const currentPlanRef = yield* Ref7.make(void 0);
       const initialSession = { ...session, baseBranch };
-      const sessionRef = yield* Ref12.make(initialSession);
+      const sessionRef = yield* Ref7.make(initialSession);
       const maxIterations = config.maxIterations === 0 ? Number.POSITIVE_INFINITY : config.maxIterations;
       const loopStarted = {
         _tag: "LoopStarted",
         config,
         timestamp: startTime
       };
-      const handleSessionName = (displayName) => Effect23.gen(function* () {
-        const currentSession = yield* Ref12.get(sessionRef);
+      const handleSessionName = (displayName) => Effect19.gen(function* () {
+        const currentSession = yield* Ref7.get(sessionRef);
         const newBranchName = yield* git.renameBranch(
           session.id,
           displayName
@@ -7367,33 +7254,38 @@ function runLoop(config) {
           branchName: newBranchName
         };
         yield* sessionStore.update(session.id, updatedSession);
-        yield* Ref12.set(sessionRef, updatedSession);
+        yield* Ref7.set(sessionRef, updatedSession);
       });
       const discoveryStream = createDiscoveryStream(
         llm,
         signalParser,
         planStore,
+        stateStore,
+        promptStore,
+        progressStore,
         currentPlanRef,
         config,
         session.id,
         worktreePath,
         handleSessionName
       );
-      const iterationsStream = Stream9.unfoldEffect(
+      const iterationsStream = Stream8.unfoldEffect(
         1,
-        (iteration) => Effect23.gen(function* () {
-          const completed = yield* Ref12.get(loopCompletedRef);
+        (iteration) => Effect19.gen(function* () {
+          const completed = yield* Ref7.get(loopCompletedRef);
           if (completed || iteration > maxIterations) {
             return Option.none();
           }
           return Option.some([iteration, iteration + 1]);
         })
       ).pipe(
-        Stream9.flatMap(
+        Stream8.flatMap(
           (iteration) => createIterationStream(
             llm,
             signalParser,
             planStore,
+            stateStore,
+            progressStore,
             currentPlanRef,
             loopCompletedRef,
             config,
@@ -7419,17 +7311,17 @@ function runLoop(config) {
         worktreePath
       );
       return pipe3(
-        Stream9.succeed(loopStarted),
-        Stream9.concat(Stream9.succeed(worktreeCreated)),
-        Stream9.concat(discoveryStream),
-        Stream9.concat(iterationsStream),
-        Stream9.concat(completionStream)
+        Stream8.succeed(loopStarted),
+        Stream8.concat(Stream8.succeed(worktreeCreated)),
+        Stream8.concat(discoveryStream),
+        Stream8.concat(iterationsStream),
+        Stream8.concat(completionStream)
       );
     }).pipe(
       // Also catch setup errors (e.g., session creation failure)
-      Effect23.catchAll(
-        (error) => Effect23.succeed(
-          Stream9.succeed({
+      Effect19.catchAll(
+        (error) => Effect19.succeed(
+          Stream8.succeed({
             _tag: "LoopFailed",
             error: {
               message: error.message,
@@ -7453,33 +7345,33 @@ ${completedTasks}
 Generated by Ferix`;
 }
 function createCompletionStream(sessionStore, git, sessionRef, config, startTime, loopCompletedRef, _worktreePath) {
-  return Stream9.unwrap(
-    Effect23.gen(function* () {
-      const session = yield* Ref12.get(sessionRef);
-      const endTimeUtc = yield* DateTime10.now;
-      const endTime = DateTime10.toEpochMillis(endTimeUtc);
+  return Stream8.unwrap(
+    Effect19.gen(function* () {
+      const session = yield* Ref7.get(sessionRef);
+      const endTimeUtc = yield* DateTime7.now;
+      const endTime = DateTime7.toEpochMillis(endTimeUtc);
       const durationMs = endTime - startTime;
-      const completed = yield* Ref12.get(loopCompletedRef);
+      const completed = yield* Ref7.get(loopCompletedRef);
       yield* git.commitChanges(session.id, `feat: complete session ${session.id}`).pipe(
-        Effect23.tapError(
-          (error) => Effect23.logDebug("Final commit failed, continuing", {
+        Effect19.tapError(
+          (error) => Effect19.logDebug("Final commit failed, continuing", {
             sessionId: session.id,
             error: String(error)
           })
         ),
-        Effect23.orElseSucceed(() => void 0)
+        Effect19.orElseSucceed(() => void 0)
       );
       let branchPushed = false;
       if (config.push === true) {
         const pushResult = yield* git.pushBranch(session.id).pipe(
-          Effect23.map(() => true),
-          Effect23.tapError(
-            (error) => Effect23.logDebug("Push failed, continuing", {
+          Effect19.map(() => true),
+          Effect19.tapError(
+            (error) => Effect19.logDebug("Push failed, continuing", {
               sessionId: session.id,
               error: String(error)
             })
           ),
-          Effect23.orElseSucceed(() => false)
+          Effect19.orElseSucceed(() => false)
         );
         branchPushed = pushResult;
       }
@@ -7488,25 +7380,25 @@ function createCompletionStream(sessionStore, git, sessionRef, config, startTime
         const title = `feat: ${session.originalTask.slice(0, 50)}`;
         const body = buildPRBody(session, config);
         const prResult = yield* git.createPR(session.id, title, body, session.baseBranch).pipe(
-          Effect23.map((url) => url),
-          Effect23.tapError(
-            (error) => Effect23.logDebug("PR creation failed, continuing", {
+          Effect19.map((url) => url),
+          Effect19.tapError(
+            (error) => Effect19.logDebug("PR creation failed, continuing", {
               sessionId: session.id,
               error: String(error)
             })
           ),
-          Effect23.orElseSucceed(() => void 0)
+          Effect19.orElseSucceed(() => void 0)
         );
         prUrl = prResult;
       }
       yield* git.removeWorktreeKeepBranch(session.id).pipe(
-        Effect23.tapError(
-          (error) => Effect23.logDebug("Worktree cleanup failed, continuing", {
+        Effect19.tapError(
+          (error) => Effect19.logDebug("Worktree cleanup failed, continuing", {
             sessionId: session.id,
             error: String(error)
           })
         ),
-        Effect23.orElseSucceed(() => void 0)
+        Effect19.orElseSucceed(() => void 0)
       );
       const worktreeRemoved = {
         _tag: "WorktreeRemoved",
@@ -7527,13 +7419,13 @@ function createCompletionStream(sessionStore, git, sessionRef, config, startTime
         status: completed ? "completed" : "paused",
         worktreePath: void 0
       }).pipe(
-        Effect23.tapError(
-          (error) => Effect23.logDebug("Session update failed, continuing", {
+        Effect19.tapError(
+          (error) => Effect19.logDebug("Session update failed, continuing", {
             sessionId: session.id,
             error: String(error)
           })
         ),
-        Effect23.orElseSucceed(() => void 0)
+        Effect19.orElseSucceed(() => void 0)
       );
       const events = [worktreeRemoved];
       if (branchPushed) {
@@ -7554,27 +7446,35 @@ function createCompletionStream(sessionStore, git, sessionRef, config, startTime
         });
       }
       events.push({ _tag: "LoopCompleted", summary });
-      return Stream9.fromIterable(events);
+      return Stream8.fromIterable(events);
     })
   );
 }
 
 // src/commands/code/action.ts
+function generateSessionId2() {
+  const id = humanId2({ separator: "-", capitalize: false });
+  return `${id}-${Date.now()}`;
+}
 function run(options) {
   const { config, consumer: consumerType = "headless", onEvent } = options;
-  const events = runLoop(config);
-  const eventsWithCallback = onEvent ? events.pipe(Stream10.tap((event) => Effect24.sync(() => onEvent(event)))) : events;
-  const layers = config.provider ? createProductionLayers(config.provider) : ProductionLayers;
-  const eventsWithLayers = eventsWithCallback.pipe(Stream10.provideLayer(layers));
+  const sessionId = config.sessionId ?? generateSessionId2();
+  const configWithSession = { ...config, sessionId };
+  const events = runLoop(configWithSession);
+  const eventsWithCallback = onEvent ? events.pipe(Stream9.tap((event) => Effect20.sync(() => onEvent(event)))) : events;
+  const baseLayers = config.provider ? createProductionLayers(config.provider) : ProductionLayers;
+  const loggerLayer = createLoggerLayer(config.debug ?? false, sessionId);
+  const layers = Layer12.merge(baseLayers, loggerLayer);
+  const eventsWithLayers = eventsWithCallback.pipe(Stream9.provideLayer(layers));
   if (consumerType === "none") {
-    return eventsWithLayers.pipe(Stream10.runDrain);
+    return eventsWithLayers.pipe(Stream9.runDrain);
   }
   const consumer = consumerType === "tui" ? createTUIConsumer() : createHeadlessConsumer();
   return consumer.consume(eventsWithLayers);
 }
 function main(config) {
   const consumerType = process.stdout.isTTY ? "tui" : "headless";
-  return run({ config, consumer: consumerType }).pipe(Effect24.runPromise);
+  return run({ config, consumer: consumerType }).pipe(Effect20.runPromise);
 }
 
 // src/commands/code/services/index.ts
@@ -7586,7 +7486,10 @@ var registerCodeCommand = (program2) => {
     "--provider <name>",
     "LLM provider to use (claude, cursor, opencode)",
     "claude"
-  ).action(async (task, options) => {
+  ).option(
+    "--no-yolo",
+    "Require permission prompts (default runs in yolo mode on isolated worktree)"
+  ).option("-d, --debug", "Enable debug logging to .ferix/logs/<session>.log").action(async (task, options) => {
     const config = {
       task,
       maxIterations: Number.parseInt(options.iterations, 10),
@@ -7594,7 +7497,9 @@ var registerCodeCommand = (program2) => {
       branch: options.branch,
       push: options.push,
       pr: options.pr,
-      provider: options.provider
+      provider: options.provider,
+      yolo: options.yolo ?? true,
+      debug: options.debug
     };
     try {
       await main(config);
@@ -7652,16 +7557,16 @@ var createSpinner = (text) => {
 // src/commands/sync/action.ts
 init_esm_shims();
 import { access as access5 } from "fs/promises";
-import { dirname as dirname3, resolve } from "path";
+import { dirname as dirname4, resolve } from "path";
 import { cancel } from "@clack/prompts";
-import { Effect as Effect29 } from "effect";
+import { Effect as Effect25 } from "effect";
 import pc19 from "picocolors";
 
 // src/commands/sync/detect-agents.ts
 init_esm_shims();
 import { access as access3 } from "fs/promises";
-import { join as join7 } from "path";
-import { Effect as Effect25 } from "effect";
+import { join as join10 } from "path";
+import { Effect as Effect21 } from "effect";
 var AGENT_DIRECTORIES = {
   opencode: [".opencode"],
   "claude-code": [".claude"],
@@ -7674,7 +7579,7 @@ var AGENT_DIRECTORIES = {
 var SUPPORTED_AGENTS = Object.keys(
   AGENT_DIRECTORIES
 );
-var directoryExists2 = (dirPath) => Effect25.promise(async () => {
+var directoryExists2 = (dirPath) => Effect21.promise(async () => {
   try {
     await access3(dirPath);
     return true;
@@ -7684,18 +7589,18 @@ var directoryExists2 = (dirPath) => Effect25.promise(async () => {
 });
 var isAgentPresent = (projectDir, agent) => {
   const directories = AGENT_DIRECTORIES[agent];
-  return Effect25.forEach(
+  return Effect21.forEach(
     directories,
-    (dir) => directoryExists2(join7(projectDir, dir))
-  ).pipe(Effect25.map((results) => results.some((exists) => exists)));
+    (dir) => directoryExists2(join10(projectDir, dir))
+  ).pipe(Effect21.map((results) => results.some((exists) => exists)));
 };
-var detectAgents = (projectDir) => Effect25.forEach(
+var detectAgents = (projectDir) => Effect21.forEach(
   SUPPORTED_AGENTS,
   (agent) => isAgentPresent(projectDir, agent).pipe(
-    Effect25.map((present) => present ? agent : null)
+    Effect21.map((present) => present ? agent : null)
   )
 ).pipe(
-  Effect25.map(
+  Effect21.map(
     (results) => results.filter((agent) => agent !== null)
   )
 );
@@ -7713,28 +7618,24 @@ var components = componentsGeneric();
 
 // src/commands/sync/find-skills.ts
 import { ConvexHttpClient } from "convex/browser";
-import { Effect as Effect26, Schema as S24 } from "effect";
+import { Effect as Effect22, Schema as S23 } from "effect";
 
 // src/commands/sync/errors.ts
 init_esm_shims();
 import { Data as Data2 } from "effect";
-var PackageJsonError = class extends Data2.TaggedError("PackageJsonError") {
-};
 var SchemaValidationError = class extends Data2.TaggedError(
   "SchemaValidationError"
 ) {
 };
 var ConvexError = class extends Data2.TaggedError("ConvexError") {
 };
-var NpmResolveError = class extends Data2.TaggedError("NpmResolveError") {
-};
 var SkillInstallError = class extends Data2.TaggedError("SkillInstallError") {
 };
 
 // src/commands/sync/types.ts
 init_esm_shims();
-import { Schema as S23 } from "effect";
-var AgentNameSchema = S23.Literal(
+import { Schema as S22 } from "effect";
+var AgentNameSchema = S22.Literal(
   "opencode",
   "claude-code",
   "cursor",
@@ -7743,73 +7644,22 @@ var AgentNameSchema = S23.Literal(
   "openhands",
   "windsurf"
 );
-var PackageNameSchema = S23.String.pipe(
-  S23.pattern(/^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/),
-  S23.brand("PackageName")
-);
-var GitHubOwnerSchema = S23.String.pipe(
-  S23.pattern(/^[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$/),
-  S23.brand("GitHubOwner")
-);
-var GitHubRepoSchema = S23.String.pipe(
-  S23.pattern(/^[a-zA-Z0-9._-]+$/),
-  S23.brand("GitHubRepo")
-);
-var GitHubUrlSchema = S23.String.pipe(
-  S23.pattern(/^https:\/\/github\.com\/[^/]+\/[^/]+$/),
-  S23.brand("GitHubUrl")
-);
-var SkillRepoSchema = S23.Struct({
-  owner: S23.String,
-  repo: S23.String,
-  githubUrl: S23.String
-});
-var PackageOrgSchema = S23.Struct({
-  packageName: S23.String,
-  githubOrg: S23.NullOr(S23.String)
-});
-var PackageOrgsResponseSchema = S23.Array(PackageOrgSchema);
-var SkillReposResponseSchema = S23.Array(SkillRepoSchema);
-var DependencyVersionSchema = S23.String;
-var DependenciesSchema = S23.Record({
-  key: S23.String,
-  value: DependencyVersionSchema
-});
-var WorkspacesSchema = S23.Union(
-  S23.Array(S23.String),
-  S23.Struct({ packages: S23.Array(S23.String) })
-);
-var PackageJsonSchema = S23.Struct({
-  name: S23.optional(S23.String),
-  version: S23.optional(S23.String),
-  dependencies: S23.optional(DependenciesSchema),
-  devDependencies: S23.optional(DependenciesSchema),
-  workspaces: S23.optional(WorkspacesSchema)
-});
-var SyncOptionsSchema = S23.Struct({
-  dryRun: S23.optional(S23.Boolean),
-  global: S23.optional(S23.Boolean),
-  dev: S23.optional(S23.Boolean)
-});
-var InstallOptionsSchema = S23.Struct({
-  dryRun: S23.optional(S23.Boolean),
-  global: S23.optional(S23.Boolean),
-  agents: S23.optional(S23.Array(AgentNameSchema))
-});
-var SyncResultSchema = S23.Struct({
-  dependencies: S23.Array(S23.String),
-  orgs: S23.Array(S23.String),
-  skillRepos: S23.Array(SkillRepoSchema),
-  installed: S23.Array(S23.String),
-  packageJsonCount: S23.Number
-});
-var decodePackageJson = S23.decodeUnknown(PackageJsonSchema);
-var decodePackageOrgsResponse = S23.decodeUnknown(
-  PackageOrgsResponseSchema
-);
-var decodeSkillReposResponse = S23.decodeUnknown(
-  SkillReposResponseSchema
-);
+var SkillRepoSchema = S22.Struct({
+  owner: S22.String,
+  repo: S22.String,
+  githubUrl: S22.String
+});
+var PackageOrgSchema = S22.Struct({
+  packageName: S22.String,
+  githubOrg: S22.NullOr(S22.String)
+});
+var PackageOrgsResponseSchema = S22.Array(PackageOrgSchema);
+var SkillReposResponseSchema = S22.Array(SkillRepoSchema);
+var InstallOptionsSchema = S22.Struct({
+  dryRun: S22.optional(S22.Boolean),
+  global: S22.optional(S22.Boolean),
+  agents: S22.optional(S22.Array(AgentNameSchema))
+});
 var CONVEX_URL_PROD = "https://groovy-mallard-649.convex.cloud";
 var CONVEX_URL_DEV = "https://majestic-gnu-964.convex.cloud";
 var getConvexUrl = (dev) => dev ? CONVEX_URL_DEV : CONVEX_URL_PROD;
@@ -7821,8 +7671,8 @@ var NON_NPM_VERSION_PREFIXES = [
 ];
 
 // src/commands/sync/find-skills.ts
-var findSkillRepos = (orgs, dev) => Effect26.gen(function* () {
-  const response = yield* Effect26.tryPromise({
+var findSkillRepos = (orgs, dev) => Effect22.gen(function* () {
+  const response = yield* Effect22.tryPromise({
     try: async () => {
       const client = new ConvexHttpClient(getConvexUrl(dev));
       return await client.query(api.directories.getByOwners, {
@@ -7835,10 +7685,10 @@ var findSkillRepos = (orgs, dev) => Effect26.gen(function* () {
       cause: error
     })
   });
-  const validated = yield* S24.decodeUnknown(SkillReposResponseSchema)(
+  const validated = yield* S23.decodeUnknown(SkillReposResponseSchema)(
     response
   ).pipe(
-    Effect26.mapError(
+    Effect22.mapError(
       (error) => new SchemaValidationError({
         message: "Invalid response from directories.getByOwners",
         context: "findSkillRepos",
@@ -7851,8 +7701,8 @@ var findSkillRepos = (orgs, dev) => Effect26.gen(function* () {
 
 // src/commands/sync/helpers.ts
 init_esm_shims();
-import { access as access4, readdir as readdir2, readFile as readFile7 } from "fs/promises";
-import { dirname as dirname2, join as join8 } from "path";
+import { access as access4, readdir as readdir2, readFile as readFile8 } from "fs/promises";
+import { dirname as dirname3, join as join11 } from "path";
 var isNonNpmDependency = (version) => NON_NPM_VERSION_PREFIXES.some((prefix) => version.startsWith(prefix));
 var extractDependencies = (pkg) => {
   const deps = pkg.dependencies ?? {};
@@ -7890,15 +7740,15 @@ var GLOB_SUFFIX_PATTERN = /\/\*+$/;
 var expandGlobPattern = async (rootDir, pattern) => {
   if (pattern.endsWith("/*") || pattern.endsWith("/**")) {
     const baseDir = pattern.replace(GLOB_SUFFIX_PATTERN, "");
-    const fullPath2 = join8(rootDir, baseDir);
+    const fullPath2 = join11(rootDir, baseDir);
     try {
       const entries = await readdir2(fullPath2, { withFileTypes: true });
-      return entries.filter((entry) => entry.isDirectory()).map((entry) => join8(fullPath2, entry.name));
+      return entries.filter((entry) => entry.isDirectory()).map((entry) => join11(fullPath2, entry.name));
     } catch {
       return [];
     }
   }
-  const fullPath = join8(rootDir, pattern);
+  const fullPath = join11(rootDir, pattern);
   try {
     await access4(fullPath);
     return [fullPath];
@@ -7907,11 +7757,11 @@ var expandGlobPattern = async (rootDir, pattern) => {
   }
 };
 var readPackageJsonFile = async (filePath) => {
-  const content = await readFile7(filePath, "utf-8");
+  const content = await readFile8(filePath, "utf-8");
   return JSON.parse(content);
 };
 var discoverPackageJsonFiles = async (rootPath, rootPkg) => {
-  const rootDir = dirname2(rootPath);
+  const rootDir = dirname3(rootPath);
   const patterns = extractWorkspacePatterns(rootPkg);
   if (patterns.length === 0) {
     return [rootPath];
@@ -7920,7 +7770,7 @@ var discoverPackageJsonFiles = async (rootPath, rootPkg) => {
   for (const pattern of patterns) {
     const dirs = await expandGlobPattern(rootDir, pattern);
     for (const dir of dirs) {
-      const pkgPath = join8(dir, "package.json");
+      const pkgPath = join11(dir, "package.json");
       try {
         await access4(pkgPath);
         packageJsonPaths.push(pkgPath);
@@ -7935,9 +7785,9 @@ var discoverPackageJsonFiles = async (rootPath, rootPkg) => {
 init_esm_shims();
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { Effect as Effect27 } from "effect";
+import { Effect as Effect23 } from "effect";
 var execAsync2 = promisify2(exec2);
-var installSingleSkill = (repo, options) => Effect27.tryPromise({
+var installSingleSkill = (repo, options) => Effect23.tryPromise({
   try: async () => {
     const repoId = `${repo.owner}/${repo.repo}`;
     const globalFlag = options.global === true ? " --global" : "";
@@ -7957,9 +7807,9 @@ var installSingleSkill = (repo, options) => Effect27.tryPromise({
 });
 var installSkills = (repos, options = {}) => {
   if (options.dryRun === true) {
-    return Effect27.succeed(repos.map((r) => `${r.owner}/${r.repo}`));
+    return Effect23.succeed(repos.map((r) => `${r.owner}/${r.repo}`));
   }
-  return Effect27.forEach(repos, (repo) => installSingleSkill(repo, options), {
+  return Effect23.forEach(repos, (repo) => installSingleSkill(repo, options), {
     concurrency: 1
   });
 };
@@ -7967,9 +7817,9 @@ var installSkills = (repos, options = {}) => {
 // src/commands/sync/resolve-orgs.ts
 init_esm_shims();
 import { ConvexHttpClient as ConvexHttpClient2 } from "convex/browser";
-import { Effect as Effect28, Schema as S25 } from "effect";
-var resolvePackageOrgs = (packageNames, dev) => Effect28.gen(function* () {
-  const response = yield* Effect28.tryPromise({
+import { Effect as Effect24, Schema as S24 } from "effect";
+var resolvePackageOrgs = (packageNames, dev) => Effect24.gen(function* () {
+  const response = yield* Effect24.tryPromise({
     try: async () => {
       const client = new ConvexHttpClient2(getConvexUrl(dev));
       return await client.action(api.packageOrg.resolve, {
@@ -7982,10 +7832,10 @@ var resolvePackageOrgs = (packageNames, dev) => Effect28.gen(function* () {
       cause: error
     })
   });
-  const validated = yield* S25.decodeUnknown(PackageOrgsResponseSchema)(
+  const validated = yield* S24.decodeUnknown(PackageOrgsResponseSchema)(
     response
   ).pipe(
-    Effect28.mapError(
+    Effect24.mapError(
       (error) => new SchemaValidationError({
         message: "Invalid response from packageOrg.resolve",
         context: "resolvePackageOrgs",
@@ -8150,7 +8000,7 @@ var extractAllDependencies = async (state) => {
 var resolveOrganizations = async (state, isDev) => {
   state.spinner = createSpinner("Resolving GitHub organizations...").start();
   try {
-    const packageOrgs = await Effect29.runPromise(
+    const packageOrgs = await Effect25.runPromise(
       resolvePackageOrgs(state.dependencies, isDev)
     );
     state.orgs = Array.from(
@@ -8175,7 +8025,7 @@ var resolveOrganizations = async (state, isDev) => {
 var findRepositories = async (state, isDev) => {
   state.spinner = createSpinner("Searching for skill repositories...").start();
   try {
-    state.skillRepos = await Effect29.runPromise(
+    state.skillRepos = await Effect25.runPromise(
       findSkillRepos(state.orgs, isDev)
     );
     if (state.skillRepos.length === 0) {
@@ -8197,7 +8047,7 @@ var findRepositories = async (state, isDev) => {
 var detectProjectAgents = async (state, projectDir) => {
   state.spinner = createSpinner("Detecting coding agents...").start();
   try {
-    state.detectedAgents = await Effect29.runPromise(detectAgents(projectDir));
+    state.detectedAgents = await Effect25.runPromise(detectAgents(projectDir));
     if (state.detectedAgents.length === 0) {
       state.spinner.info("No coding agents detected");
     } else {
@@ -8224,7 +8074,7 @@ var determineAgents = async (state, packagePath, manualAgents, skipSelection) =>
     printSuccess(`Using specified agents: ${pc19.cyan(manualAgents.join(", "))}`);
     return manualAgents;
   }
-  const projectDir = dirname3(resolve(packagePath));
+  const projectDir = dirname4(resolve(packagePath));
   await detectProjectAgents(state, projectDir);
   if (skipSelection) {
     if (state.detectedAgents.length === 0) {
@@ -8284,7 +8134,7 @@ var installRepositories = async (state, reposToInstall, isGlobal, agents) => {
       `Installing ${pc19.cyan(repo.owner)}${pc19.dim("/")}${pc19.white(repo.repo)}...`
     ).start();
     try {
-      await Effect29.runPromise(
+      await Effect25.runPromise(
         installSkills([repo], {
           dryRun: false,
           global: isGlobal,