ferix-code 0.0.3-beta.1 → 0.0.3

package/dist/index.js

@@ -1,26 +1,33 @@
 #!/usr/bin/env node
-import {
-  areAllTasksComplete,
-  buildDiscoveryPrompt,
-  buildPrompt
-} from "./chunk-XIEB473E.js";
-import {
-  GitError,
-  GuardrailsStoreError,
-  LLMError,
-  OrchestratorError,
-  PlanStoreError,
-  ProgressStoreError,
-  PromptStoreError,
-  SessionStoreError,
-  StateStoreError
-} from "./chunk-ENDDBBCW.js";
-import {
-  __esm,
-  __export,
-  __toCommonJS,
-  init_esm_shims
-} from "./chunk-ILHJ3OBF.js";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../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+7ba260eccd18f7a2/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
 
 // src/commands/code/consumers/tui/tags/registry.ts
 var registry_exports = {};
@@ -63,7 +70,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "ferix-code",
-  version: "0.0.3-beta.1",
+  version: "0.0.3",
   description: "Composable RALPH loops for AI coding agents - v2 with Effect",
   type: "module",
   bin: {
@@ -123,7 +130,7 @@ init_esm_shims();
 
 // src/commands/code/action.ts
 init_esm_shims();
-import { Effect as Effect19, Layer as Layer12, Stream as Stream9 } 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
@@ -2613,6 +2620,38 @@ import { dirname, join } from "path";
 import { promisify } from "util";
 import { Effect as Effect4, Layer } from "effect";
 
+// src/commands/code/domain/errors.ts
+init_esm_shims();
+import { Data } from "effect";
+var LLMError = class extends Data.TaggedError("LLMError") {
+};
+var ParseError = class extends Data.TaggedError("ParseError") {
+};
+var PlanStoreError = class extends Data.TaggedError("PlanStoreError") {
+};
+var SessionStoreError = class extends Data.TaggedError("SessionStoreError") {
+};
+var ProgressStoreError = class extends Data.TaggedError("ProgressStoreError") {
+};
+var GuardrailsStoreError = class extends Data.TaggedError(
+  "GuardrailsStoreError"
+) {
+};
+var OrchestratorError = class extends Data.TaggedError("OrchestratorError") {
+};
+var GitError = class extends Data.TaggedError("GitError") {
+};
+var TokenBudgetError = class extends Data.TaggedError("TokenBudgetError") {
+};
+var RetryExhaustedError = class extends Data.TaggedError(
+  "RetryExhaustedError"
+) {
+};
+var StateStoreError = class extends Data.TaggedError("StateStoreError") {
+};
+var PromptStoreError = class extends Data.TaggedError("PromptStoreError") {
+};
+
 // src/commands/code/services/git.ts
 init_esm_shims();
 import { Context } from "effect";
@@ -3753,12 +3792,37 @@ var SessionStateSchema = S15.Struct({
 });
 var decodeSessionState = S15.decodeUnknown(SessionStateSchema);
 
-// src/commands/code/domain/schemas/tui.ts
+// src/commands/code/domain/schemas/task-generation.ts
 init_esm_shims();
 import { Schema as S16 } from "effect";
-var ViewModeSchema = S16.Literal("logs", "tasks", "detail");
-var LoopStatusSchema = S16.Literal("idle", "running", "complete", "error");
-var ExecutionModeSchema = S16.Literal(
+var GeneratedTaskStatusSchema = S16.Literal(
+  "pending",
+  "in_progress",
+  "done",
+  "failed"
+);
+var GeneratedTaskSchema = S16.Struct({
+  id: S16.String,
+  title: S16.String,
+  description: S16.String,
+  status: GeneratedTaskStatusSchema,
+  steps: S16.Array(S16.String)
+});
+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 ExecutionModeSchema = S17.Literal(
   "idle",
   "discovery",
   "breakdown",
@@ -3768,73 +3832,73 @@ var ExecutionModeSchema = S16.Literal(
   "verifying",
   "reviewing"
 );
-var TUIPhaseStatusSchema = S16.Literal(
+var TUIPhaseStatusSchema = S17.Literal(
   "pending",
   "in_progress",
   "done",
   "failed"
 );
-var TUICriterionStatusSchema = S16.Literal("pending", "passed", "failed");
-var TUITaskStatusSchema = S16.Literal(
+var TUICriterionStatusSchema = S17.Literal("pending", "passed", "failed");
+var TUITaskStatusSchema = S17.Literal(
   "pending",
   "in_progress",
   "done",
   "failed"
 );
-var TUIPhaseSchema = S16.Struct({
-  id: S16.String,
-  description: S16.String,
+var TUIPhaseSchema = S17.Struct({
+  id: S17.String,
+  description: S17.String,
   status: TUIPhaseStatusSchema,
-  startedAt: S16.optional(S16.Number),
-  completedAt: S16.optional(S16.Number)
+  startedAt: S17.optional(S17.Number),
+  completedAt: S17.optional(S17.Number)
 });
-var TUICriterionSchema = S16.Struct({
-  id: S16.String,
-  description: S16.String,
+var TUICriterionSchema = S17.Struct({
+  id: S17.String,
+  description: S17.String,
   status: TUICriterionStatusSchema,
-  failureReason: S16.optional(S16.String)
+  failureReason: S17.optional(S17.String)
 });
-var TUITaskSchema = S16.Struct({
-  id: S16.String,
-  title: S16.String,
+var TUITaskSchema = S17.Struct({
+  id: S17.String,
+  title: S17.String,
   status: TUITaskStatusSchema,
-  phases: S16.Array(TUIPhaseSchema),
-  criteria: S16.Array(TUICriterionSchema),
-  startedAt: S16.optional(S16.Number),
-  completedAt: S16.optional(S16.Number)
+  phases: S17.Array(TUIPhaseSchema),
+  criteria: S17.Array(TUICriterionSchema),
+  startedAt: S17.optional(S17.Number),
+  completedAt: S17.optional(S17.Number)
 });
-var TUIStateSchema = S16.Struct({
+var TUIStateSchema = S17.Struct({
   // Loop info
-  task: S16.String,
-  iteration: S16.Number,
-  maxIterations: S16.Number,
+  task: S17.String,
+  iteration: S17.Number,
+  maxIterations: S17.Number,
   status: LoopStatusSchema,
-  startTime: S16.Number,
+  startTime: S17.Number,
   // Discovery phase
-  discoveryInProgress: S16.Boolean,
-  discoveryCompleted: S16.Boolean,
+  discoveryInProgress: S17.Boolean,
+  discoveryCompleted: S17.Boolean,
   // Current activity
   executionMode: ExecutionModeSchema,
-  currentTool: S16.optional(S16.String),
-  currentTaskId: S16.optional(S16.String),
+  currentTool: S17.optional(S17.String),
+  currentTaskId: S17.optional(S17.String),
   // Output
-  outputLines: S16.Array(S16.String),
-  partialLine: S16.String,
+  outputLines: S17.Array(S17.String),
+  partialLine: S17.String,
   // Tasks
-  tasks: S16.Array(TUITaskSchema),
+  tasks: S17.Array(TUITaskSchema),
   // Navigation
   viewMode: ViewModeSchema,
-  selectedTaskIndex: S16.Number,
-  scrollOffset: S16.Number,
-  userScrolled: S16.Boolean,
+  selectedTaskIndex: S17.Number,
+  scrollOffset: S17.Number,
+  userScrolled: S17.Boolean,
   // Git
-  gitBranch: S16.optional(S16.String),
-  gitPushed: S16.Boolean,
-  prUrl: S16.optional(S16.String),
+  gitBranch: S17.optional(S17.String),
+  gitPushed: S17.Boolean,
+  prUrl: S17.optional(S17.String),
   // YOLO mode (skip permission prompts)
-  yolo: S16.Boolean,
+  yolo: S17.Boolean,
   // Debug mode (logging enabled)
-  debug: S16.Boolean
+  debug: S17.Boolean
 });
 
 // src/commands/code/services/guardrails-store.ts
@@ -3983,23 +4047,23 @@ import { Effect as Effect8 } from "effect";
 
 // src/commands/code/layers/llm/types.ts
 init_esm_shims();
-import { Schema as S17 } from "effect";
-var PermissionModeSchema = S17.Literal("acceptEdits", "yolo", "prompt");
-var ProviderConfigSchema = S17.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: S17.String,
+  cliCommand: S18.String,
   /** Default arguments for the CLI */
-  args: S17.Array(S17.String),
+  args: S18.Array(S18.String),
   /** Environment variables to pass */
-  env: S17.optional(S17.Record({ key: S17.String, value: S17.String })),
+  env: S18.optional(S18.Record({ key: S18.String, value: S18.String })),
   /** Permission mode for the CLI */
-  permissions: S17.optional(PermissionModeSchema),
+  permissions: S18.optional(PermissionModeSchema),
   /** URL for installation instructions */
-  installUrl: S17.String,
+  installUrl: S18.String,
   /** Arguments to pass when YOLO mode is enabled */
-  yoloArgs: S17.optional(S17.Array(S17.String))
+  yoloArgs: S18.optional(S18.Array(S18.String))
 });
 var RAW_PROVIDER_CONFIGS = {
   claude: {
@@ -4033,12 +4097,12 @@ var RAW_PROVIDER_CONFIGS = {
     yoloArgs: ["--yolo"]
   }
 };
-var ProviderConfigsSchema = S17.Record({
+var ProviderConfigsSchema = S18.Record({
   key: ProviderNameSchema,
   value: ProviderConfigSchema
 });
 var validateProviderConfigs = () => {
-  const decoded = S17.decodeUnknownSync(ProviderConfigsSchema)(
+  const decoded = S18.decodeUnknownSync(ProviderConfigsSchema)(
     RAW_PROVIDER_CONFIGS
   );
   return decoded;
@@ -4759,7 +4823,7 @@ var FileSystemProgress = {
 init_esm_shims();
 import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
 import { dirname as dirname2, join as join5 } from "path";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { Effect as Effect11, Layer as Layer6 } from "effect";
 
 // src/commands/code/services/prompt-store.ts
@@ -4770,7 +4834,7 @@ var PromptStore = class extends Context6.Tag("@ferix/PromptStore")() {
 
 // src/commands/code/layers/prompt/file-system.ts
 var PLANS_DIR4 = ".ferix/plans";
-var __dirname2 = dirname2(fileURLToPath(import.meta.url));
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
 var BUNDLED_TEMPLATE_PATH = join5(__dirname2, "../../templates/PROMPT.md");
 function ensureDir4(dirPath) {
   return Effect11.tryPromise({
@@ -5211,7 +5275,7 @@ signalSpecRegistry.register(learningSpec);
 
 // src/commands/code/layers/signal/specs/loop-complete.ts
 init_esm_shims();
-import { Schema as S18 } from "effect";
+import { Schema as S19 } from "effect";
 var LOOP_COMPLETE = /<ferix:complete>/;
 var loopCompleteSpec = {
   tag: "LoopComplete",
@@ -5220,7 +5284,7 @@ var loopCompleteSpec = {
   parse: (text) => {
     if (LOOP_COMPLETE.test(text)) {
       const raw = { _tag: "LoopComplete" };
-      const result = S18.decodeUnknownEither(LoopCompleteSignalSchema)(raw);
+      const result = S19.decodeUnknownEither(LoopCompleteSignalSchema)(raw);
       if (result._tag === "Right") {
         return [result.right];
       }
@@ -5333,7 +5397,7 @@ signalSpecRegistry.register(phaseFailedSpec);
 
 // src/commands/code/layers/signal/specs/review.ts
 init_esm_shims();
-import { Schema as S19 } from "effect";
+import { Schema as S20 } from "effect";
 var REVIEW_COMPLETE = /<ferix:review-complete\/>/;
 var REVIEW_CHANGES = /<ferix:review-changes-made\/>/;
 var reviewCompleteSpec = {
@@ -5346,7 +5410,7 @@ var reviewCompleteSpec = {
     }
     const changesMade = REVIEW_CHANGES.test(text);
     const raw = { _tag: "ReviewComplete", changesMade };
-    const result = S19.decodeUnknownEither(ReviewCompleteSignalSchema)(raw);
+    const result = S20.decodeUnknownEither(ReviewCompleteSignalSchema)(raw);
     if (result._tag === "Right") {
       return [result.right];
     }
@@ -5389,7 +5453,7 @@ signalSpecRegistry.register(sessionNameSpec);
 
 // src/commands/code/layers/signal/specs/task-complete.ts
 init_esm_shims();
-import { Schema as S20 } 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>/;
@@ -5420,7 +5484,7 @@ var taskCompleteSpec = {
       filesModified: parseFileList(filesModifiedMatch?.[1]),
       filesCreated: parseFileList(filesCreatedMatch?.[1])
     };
-    const result = S20.decodeUnknownEither(TaskCompleteSignalSchema)(raw);
+    const result = S21.decodeUnknownEither(TaskCompleteSignalSchema)(raw);
     if (result._tag === "Right") {
       return [result.right];
     }
@@ -5694,11 +5758,50 @@ init_esm_shims();
 
 // src/commands/code/orchestrator/loop.ts
 init_esm_shims();
-import { DateTime as DateTime7, Effect as Effect18, Option, pipe as pipe3, Ref as Ref7, Stream as Stream8 } 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 DateTime5, Effect as Effect16, pipe, Ref as Ref5, Stream as Stream6 } 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 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(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.json: ${tasksJsonPath}`,
+        operation: "create",
+        cause: error
+      })
+    });
+  });
+}
 
 // src/commands/code/orchestrator/event-mapping.ts
 init_esm_shims();
@@ -5881,7 +5984,7 @@ function mapSignalToDomain(signal, context) {
 
 // src/commands/code/orchestrator/plan-updates.ts
 init_esm_shims();
-import { DateTime as DateTime4, Effect as Effect15, Ref as Ref4 } 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();
@@ -6203,9 +6306,9 @@ function persistPlanUpdate(planStore, plan, operation) {
     tasks: plan.tasks
   }) : planStore.update(plan.id, plan);
   return storeOp.pipe(
-    Effect15.map(() => null),
-    Effect15.catchAll(
-      (error) => Effect15.succeed({
+    Effect16.map(() => null),
+    Effect16.catchAll(
+      (error) => Effect16.succeed({
         _tag: "PlanUpdateFailed",
         operation,
         error: error.message,
@@ -6215,7 +6318,7 @@ function persistPlanUpdate(planStore, plan, operation) {
   );
 }
 function updatePlanFromSignal(currentPlanRef, persistenceStateRef, signal, sessionId, originalTask) {
-  return Effect15.gen(function* () {
+  return Effect16.gen(function* () {
     const currentPlan = yield* Ref4.get(currentPlanRef);
     const now = yield* DateTime4.now;
     const timestamp = DateTime4.formatIso(now);
@@ -6237,7 +6340,7 @@ function updatePlanFromSignal(currentPlanRef, persistenceStateRef, signal, sessi
   });
 }
 function flushPlanPersistence(planStore, currentPlanRef, persistenceStateRef) {
-  return Effect15.gen(function* () {
+  return Effect16.gen(function* () {
     const state = yield* Ref4.get(persistenceStateRef);
     if (!(state.dirty && state.pendingOperation)) {
       return [];
@@ -6263,14 +6366,361 @@ function flushPlanPersistence(planStore, currentPlanRef, persistenceStateRef) {
   });
 }
 
+// src/commands/code/orchestrator/prompt.ts
+init_esm_shims();
+var DEFAULT_SYSTEM_PROMPT = `You are executing a ralph loop - an iterative AI coding workflow.
+
+Your output must include structured signals that the orchestrator will parse.
+These signals MUST appear on their own lines, not inside code blocks.
+
+## Signal Format
+
+Use these XML-like tags to communicate structured information:
+
+### Task Breakdown (discovery phase only)
+<ferix:tasks>
+  <task id="1">Brief description of first task</task>
+  <task id="2">Brief description of second task</task>
+</ferix:tasks>
+
+### Phase Planning
+<ferix:phases task="1">
+  <phase id="1.1">First phase description</phase>
+  <phase id="1.2">Second phase description</phase>
+</ferix:phases>
+
+### Success Criteria
+<ferix:criteria task="1">
+  <criterion id="1.c1">First criterion</criterion>
+  <criterion id="1.c2">Second criterion</criterion>
+</ferix:criteria>
+
+### Phase Lifecycle
+<ferix:phase-start id="1.1"/>
+<ferix:phase-done id="1.1"/>
+<ferix:phase-failed id="1.1">reason</ferix:phase-failed>
+
+### Criterion Verification
+<ferix:criterion-passed id="1.c1"/>
+<ferix:criterion-failed id="1.c1" reason="Explanation"/>
+
+### Stage Completion
+<ferix:check-passed/>
+<ferix:check-failed/>
+<ferix:review-complete/>
+<ferix:review-changes-made/>
+
+### Task Completion
+<ferix:task-complete id="1">
+  <summary>Brief summary of what was done</summary>
+  <files-modified>file1.ts, file2.ts</files-modified>
+  <files-created>new-file.ts</files-created>
+</ferix:task-complete>
+
+### Loop Completion (use ONLY when ALL tasks are done)
+<ferix:complete>
+
+\u26A0\uFE0F IMPORTANT: Only emit <ferix:complete> after ALL tasks in the plan are complete.
+After completing a single task, emit <ferix:task-complete> and continue to the next task.
+
+IMPORTANT: Always emit signals on their own lines, never inside markdown code blocks.`;
+var DISCOVERY_SYSTEM_PROMPT = `You are in the DISCOVERY phase of a ralph loop - an iterative AI coding workflow.
+
+Your goal is to:
+1. Generate a short, descriptive name for this session
+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.
+
+## Signal Format
+
+### Session Name (REQUIRED - emit first)
+<ferix:session-name>short-descriptive-name</ferix:session-name>
+
+Guidelines for session name:
+- Use 2-5 words in kebab-case (lowercase with hyphens)
+- Describe the main purpose/feature being worked on
+- Keep it concise but meaningful
+- Examples: "add-dark-mode", "fix-auth-flow", "refactor-api-endpoints", "update-user-profile-ui"
+
+### Task Breakdown (REQUIRED)
+<ferix:tasks>
+  <task id="1">Brief description of first task</task>
+  <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:
+- Running verification commands (bun lint, bun format, eslint, prettier, etc.)
+- Running tests (bun test, jest, vitest, etc.)
+- Running build commands (bun build, tsc, etc.)
+- Any "Verification", "Testing", or "Testing Plan" sections from PRDs
+- Final cleanup, validation, or quality check steps
+- Commands that just run and check output without changing code
+
+Tasks should ONLY be for implementation work that creates or modifies source code files.
+Verification commands are run automatically after each task completes - do not create tasks for them.
+
+IMPORTANT: Always emit signals on their own lines, never inside markdown code blocks.`;
+var DEFAULT_PLANNING_PROMPT = `## Phase 2: PLANNING
+
+If no phases are defined for the current task, define them now.
+Emit a <ferix:phases> block with the execution phases.`;
+var DEFAULT_EXECUTION_PROMPT = `## Phase 3: EXECUTION
+
+Execute each phase in order:
+1. Emit <ferix:phase-start id="X.Y"/>
+2. Do the work for that phase
+3. Emit <ferix:phase-done id="X.Y"/> or <ferix:phase-failed id="X.Y">reason</ferix:phase-failed>`;
+var DEFAULT_CHECK_PROMPT = `## Phase 4: CHECK
+
+Verify all success criteria are met:
+- For each criterion, emit <ferix:criterion-passed id="X.cY"/> or <ferix:criterion-failed id="X.cY" reason="..."/>
+- Then emit <ferix:check-passed/> or <ferix:check-failed/>`;
+var DEFAULT_REVIEW_PROMPT = `## Phase 6: REVIEW
+
+Review the code for quality:
+- Is it clean and well-organized?
+- Are there any obvious improvements?
+- If you make changes, emit <ferix:review-changes-made/>
+- When done, emit <ferix:review-complete/>`;
+var DEFAULT_COMPLETION_PROMPT = `## Completion
+
+When you finish the CURRENT task, emit:
+<ferix:task-complete id="N">
+  <summary>What was accomplished</summary>
+  <files-modified>list of modified files</files-modified>
+  <files-created>list of new files</files-created>
+</ferix:task-complete>
+
+After emitting task-complete, CONTINUE working on the next pending task.
+
+\u26A0\uFE0F ONLY emit <ferix:complete> when ALL tasks in the plan are done.
+Do NOT emit <ferix:complete> after completing just one task - continue to the next task instead.`;
+function getPhasePrompt(phase, prompts, defaultPrompt) {
+  return prompts?.phases?.[phase] ?? defaultPrompt;
+}
+function buildSystemPrompt(prompts) {
+  return prompts?.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+}
+function buildVerifyPrompt(verifyCommands, prompts) {
+  const defaultVerifyPrompt = `## Phase 5: VERIFY
+
+Run these verification commands:
+${verifyCommands.map((cmd) => `- ${cmd}`).join("\n")}
+
+If any fail, fix the issues and re-verify.
+
+IMPORTANT: Once ALL verification commands pass:
+- Emit <ferix:task-complete id="N"> with a summary of what was done
+- If this was the last task, also emit <ferix:complete>
+- Do NOT run verification again after it passes`;
+  return prompts?.phases?.verify ?? defaultVerifyPrompt;
+}
+var TASK_STATUS_ICONS = {
+  done: "[x]",
+  in_progress: "[~]",
+  pending: "[ ]",
+  planning: "[~]",
+  failed: "[!]",
+  skipped: "[-]"
+};
+function buildTaskListSection(plan) {
+  if (plan.tasks.length === 0) {
+    return "";
+  }
+  const completedCount = plan.tasks.filter((t) => t.status === "done").length;
+  const totalCount = plan.tasks.length;
+  const lines = [
+    "## Task Progress",
+    "",
+    `Status: ${completedCount}/${totalCount} complete`,
+    ""
+  ];
+  const currentTaskId = plan.tasks.find(
+    (t) => t.status === "in_progress" || t.status === "pending"
+  )?.id;
+  for (const task of plan.tasks) {
+    const icon = TASK_STATUS_ICONS[task.status];
+    const currentMarker = task.id === currentTaskId ? " \u2190 current" : "";
+    lines.push(
+      `- ${icon} Task ${task.id}: ${task.title} (${task.status})${currentMarker}`
+    );
+  }
+  return lines.join("\n");
+}
+function buildCurrentTaskSection(plan) {
+  const currentTask = plan.tasks.find(
+    (t) => t.status === "in_progress" || t.status === "pending"
+  );
+  if (!currentTask) {
+    return void 0;
+  }
+  const phasesSection = currentTask.phases.length > 0 ? `### Phases
+${currentTask.phases.map((p) => `- ${p.id}: ${p.description} (${p.status})`).join("\n")}` : "No phases defined yet. Emit a <ferix:phases> block to define phases.";
+  const criteriaSection = currentTask.criteria.length > 0 ? `### Success Criteria
+${currentTask.criteria.map((c) => `- ${c.id}: ${c.description} (${c.status})`).join("\n")}` : "";
+  return `## Current Task
+
+Task ${currentTask.id}: ${currentTask.title}
+
+${currentTask.description}
+
+${phasesSection}
+
+${criteriaSection}`;
+}
+function buildDiscoveryPrompt(config) {
+  const sections = [];
+  sections.push(DISCOVERY_SYSTEM_PROMPT);
+  if (config.prompts?.additionalContext) {
+    sections.push(
+      `## Additional Context
+
+${config.prompts.additionalContext}`
+    );
+  }
+  sections.push(`## Task
+
+${config.task}`);
+  sections.push(`## Instructions
+
+Analyze the task above and:
+
+1. **Generate a session name** (2-5 words, kebab-case)
+   - Should describe the main purpose of this work
+   - Emit: <ferix:session-name>your-descriptive-name</ferix:session-name>
+
+2. **Break the task into logical subtasks** (2-6 tasks)
+   - Read and understand what needs to be done
+   - Identify the main components or steps
+   - Emit: <ferix:tasks>...</ferix:tasks>
+
+Each task should be:
+- Self-contained and independently verifiable
+- Clear and specific
+- Ordered logically (dependencies first)
+- ONLY for code implementation (NOT for running lint/test/build commands)
+
+REMINDER: Do NOT create tasks for verification steps like "Run lint", "Run tests", "Verify changes", etc.
+The orchestrator handles verification automatically after each task completes.
+If the PRD has a "Verification" or "Testing" section, IGNORE it when creating tasks.
+
+Begin your analysis now.`);
+  return sections.join("\n\n");
+}
+function buildPrompt(config, iteration, plan) {
+  const prompts = config.prompts;
+  const sections = [];
+  sections.push(buildSystemPrompt(prompts));
+  if (prompts?.additionalContext) {
+    sections.push(`## Additional Context
+
+${prompts.additionalContext}`);
+  }
+  sections.push(`## Task
+
+${config.task}`);
+  if (plan && plan.tasks.length > 0) {
+    const taskListSection = buildTaskListSection(plan);
+    if (taskListSection) {
+      sections.push(taskListSection);
+    }
+    const taskSection = buildCurrentTaskSection(plan);
+    if (taskSection) {
+      sections.push(taskSection);
+    }
+  }
+  sections.push(getPhasePrompt("planning", prompts, DEFAULT_PLANNING_PROMPT));
+  sections.push(getPhasePrompt("execution", prompts, DEFAULT_EXECUTION_PROMPT));
+  sections.push(getPhasePrompt("check", prompts, DEFAULT_CHECK_PROMPT));
+  if (config.verifyCommands.length > 0 && plan && !areAllTasksComplete(plan)) {
+    const currentTask = plan.tasks.find(
+      (t) => t.status === "in_progress" || t.status === "pending"
+    );
+    if (currentTask) {
+      sections.push(buildVerifyPrompt(config.verifyCommands, prompts));
+    }
+  }
+  sections.push(getPhasePrompt("review", prompts, DEFAULT_REVIEW_PROMPT));
+  sections.push(
+    getPhasePrompt("completion", prompts, DEFAULT_COMPLETION_PROMPT)
+  );
+  sections.push(`---
+
+Iteration ${iteration} of ${config.maxIterations || "unlimited"}
+
+Begin.`);
+  return sections.join("\n\n");
+}
+function areAllTasksComplete(plan) {
+  if (!plan || plan.tasks.length === 0) {
+    return false;
+  }
+  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 Effect16.gen(function* () {
+  return Effect17.gen(function* () {
     const events = [];
     const parsedSignals = [];
     const signals = yield* signalParser.parse(text).pipe(
-      Effect16.tapError(
-        (error) => Effect16.logDebug(
+      Effect17.tapError(
+        (error) => Effect17.logDebug(
           "Signal parsing failed, continuing with empty signals",
           {
             error: String(error),
@@ -6278,7 +6728,7 @@ function processTextSignals(signalParser, text, context) {
           }
         )
       ),
-      Effect16.orElseSucceed(() => [])
+      Effect17.orElseSucceed(() => [])
     );
     for (const signal of signals) {
       events.push(mapSignalToDomain(signal, context));
@@ -6288,7 +6738,7 @@ function processTextSignals(signalParser, text, context) {
   });
 }
 function processLLMEvent(signalParser, llmEvent, context) {
-  return Effect16.gen(function* () {
+  return Effect17.gen(function* () {
     const domainEvent = mapLLMEventToDomain(llmEvent, context);
     const events = [domainEvent];
     const allSignals = [];
@@ -6339,7 +6789,7 @@ function planToTasksFile(plan, sessionId, originalTask) {
 }
 function createDiscoveryStream(llm, signalParser, planStore, stateStore, promptStore, progressStore, currentPlanRef, config, sessionId, worktreePath, onSessionName) {
   return Stream6.unwrap(
-    Effect16.gen(function* () {
+    Effect17.gen(function* () {
       const startTimeUtc = yield* DateTime5.now;
       const startTime = DateTime5.toEpochMillis(startTimeUtc);
       const persistenceStateRef = yield* Ref5.make({
@@ -6367,7 +6817,7 @@ function createDiscoveryStream(llm, signalParser, planStore, stateStore, promptS
         ),
         Stream6.flatMap(
           (llmEvent) => Stream6.unwrap(
-            Effect16.gen(function* () {
+            Effect17.gen(function* () {
               const now = yield* DateTime5.now;
               const context = {
                 timestamp: DateTime5.toEpochMillis(now)
@@ -6407,7 +6857,7 @@ function createDiscoveryStream(llm, signalParser, planStore, stateStore, promptS
         )
       );
       const completionStream = Stream6.fromEffect(
-        Effect16.gen(function* () {
+        Effect17.gen(function* () {
           const persistEvents = yield* flushPlanPersistence(
             planStore,
             currentPlanRef,
@@ -6416,44 +6866,38 @@ function createDiscoveryStream(llm, signalParser, planStore, stateStore, promptS
           const plan = yield* Ref5.get(currentPlanRef);
           const taskCount = plan?.tasks.length ?? 0;
           yield* promptStore.copyTemplate(sessionId).pipe(
-            Effect16.tapError(
-              (error) => Effect16.logDebug("Failed to copy PROMPT.md, continuing", {
+            Effect17.tapError(
+              (error) => Effect17.logDebug("Failed to copy PROMPT.md, continuing", {
                 error: String(error)
               })
             ),
-            Effect16.orElseSucceed(() => void 0)
+            Effect17.orElseSucceed(() => void 0)
           );
           if (plan && plan.tasks.length > 0) {
-            const taskGenModule = yield* Effect16.promise(
-              () => import("./task-generation-YN2MKKY4.js")
-            );
             const tasksFile = planToTasksFile(plan, sessionId, config.task);
-            yield* taskGenModule.writeTasksJson(sessionId, tasksFile).pipe(
-              Effect16.tapError(
-                (error) => Effect16.logDebug("Failed to write tasks.json, continuing", {
+            yield* writeTasksJson(sessionId, tasksFile).pipe(
+              Effect17.tapError(
+                (error) => Effect17.logDebug("Failed to write tasks.json, continuing", {
                   error: String(error)
                 })
               ),
-              Effect16.orElseSucceed(() => void 0)
-            );
-            const promptModule = yield* Effect16.promise(
-              () => import("./prompt-YXBU2FXF.js")
+              Effect17.orElseSucceed(() => void 0)
             );
             const recentEntries = yield* progressStore.getRecent(sessionId, 5).pipe(
-              Effect16.tapError(
-                (error) => Effect16.logDebug(
+              Effect17.tapError(
+                (error) => Effect17.logDebug(
                   "Failed to get recent progress, continuing",
                   {
                     error: String(error)
                   }
                 )
               ),
-              Effect16.orElseSucceed(() => [])
+              Effect17.orElseSucceed(() => [])
             );
             const recentProgress = recentEntries.map(
               (entry) => `[${entry.action}] Task ${entry.taskId}: ${entry.summary}`
             );
-            const initialState = promptModule.buildSessionState(
+            const initialState = buildSessionState(
               config,
               0,
               // iteration 0 = discovery
@@ -6462,12 +6906,12 @@ function createDiscoveryStream(llm, signalParser, planStore, stateStore, promptS
               recentProgress
             );
             yield* stateStore.write(sessionId, initialState).pipe(
-              Effect16.tapError(
-                (error) => Effect16.logDebug("Failed to write STATE.json, continuing", {
+              Effect17.tapError(
+                (error) => Effect17.logDebug("Failed to write STATE.json, continuing", {
                   error: String(error)
                 })
               ),
-              Effect16.orElseSucceed(() => void 0)
+              Effect17.orElseSucceed(() => void 0)
             );
           }
           const endTimeUtc = yield* DateTime5.now;
@@ -6477,8 +6921,8 @@ function createDiscoveryStream(llm, signalParser, planStore, stateStore, promptS
           if (capturedName) {
             if (onSessionName) {
               yield* onSessionName(capturedName).pipe(
-                Effect16.tapError(
-                  (error) => Effect16.logDebug(
+                Effect17.tapError(
+                  (error) => Effect17.logDebug(
                     "Failed to handle session name, continuing",
                     {
                       error: String(error),
@@ -6486,7 +6930,7 @@ function createDiscoveryStream(llm, signalParser, planStore, stateStore, promptS
                     }
                   )
                 ),
-                Effect16.orElseSucceed(() => void 0)
+                Effect17.orElseSucceed(() => void 0)
               );
             }
             const sessionNameEvent = {
@@ -6518,15 +6962,15 @@ function createDiscoveryStream(llm, signalParser, planStore, stateStore, promptS
 
 // src/commands/code/orchestrator/iteration.ts
 init_esm_shims();
-import { DateTime as DateTime6, Effect as Effect17, pipe as pipe2, Ref as Ref6, Stream as Stream7 } 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 Effect17.gen(function* () {
+  return Effect18.gen(function* () {
     const events = [];
     let completed = false;
     const parsedSignals = [];
     const signals = yield* signalParser.parse(text).pipe(
-      Effect17.tapError(
-        (error) => Effect17.logDebug(
+      Effect18.tapError(
+        (error) => Effect18.logDebug(
           "Signal parsing failed, continuing with empty signals",
           {
             error: String(error),
@@ -6534,10 +6978,10 @@ function processTextSignals2(signalParser, text, context) {
           }
         )
       ),
-      Effect17.orElseSucceed(() => [])
+      Effect18.orElseSucceed(() => [])
     );
     if (signals.length > 0) {
-      yield* Effect17.logDebug("Signals parsed", {
+      yield* Effect18.logDebug("Signals parsed", {
         signals: signals.map((s) => s._tag),
         count: signals.length
       });
@@ -6553,7 +6997,7 @@ function processTextSignals2(signalParser, text, context) {
   });
 }
 function processLLMEvent2(signalParser, llmEvent, context) {
-  return Effect17.gen(function* () {
+  return Effect18.gen(function* () {
     const domainEvent = mapLLMEventToDomain(llmEvent, context);
     const events = [domainEvent];
     let completed = false;
@@ -6586,7 +7030,7 @@ function processLLMEvent2(signalParser, llmEvent, context) {
 }
 function createIterationStream(llm, signalParser, planStore, stateStore, progressStore, currentPlanRef, loopCompletedRef, config, iteration, sessionId, worktreePath) {
   return Stream7.unwrap(
-    Effect17.gen(function* () {
+    Effect18.gen(function* () {
       const currentPlan = yield* Ref6.get(currentPlanRef);
       const persistenceStateRef = yield* Ref6.make({
         dirty: false,
@@ -6596,19 +7040,18 @@ function createIterationStream(llm, signalParser, planStore, stateStore, progres
         _tag: "IterationStarted",
         iteration
       };
-      const promptModule = yield* Effect17.promise(() => import("./prompt-YXBU2FXF.js"));
       const recentEntries = yield* progressStore.getRecent(sessionId, 5).pipe(
-        Effect17.tapError(
-          (error) => Effect17.logDebug("Failed to get recent progress, continuing", {
+        Effect18.tapError(
+          (error) => Effect18.logDebug("Failed to get recent progress, continuing", {
             error: String(error)
           })
         ),
-        Effect17.orElseSucceed(() => [])
+        Effect18.orElseSucceed(() => [])
       );
       const recentProgress = recentEntries.map(
         (entry) => `[${entry.action}] Task ${entry.taskId}: ${entry.summary}`
       );
-      const state = promptModule.buildSessionState(
+      const state = buildSessionState(
         config,
         iteration,
         sessionId,
@@ -6616,16 +7059,16 @@ function createIterationStream(llm, signalParser, planStore, stateStore, progres
         recentProgress
       );
       yield* stateStore.write(sessionId, state).pipe(
-        Effect17.tapError(
-          (error) => Effect17.logDebug("Failed to write STATE.json, continuing", {
+        Effect18.tapError(
+          (error) => Effect18.logDebug("Failed to write STATE.json, continuing", {
             error: String(error)
           })
         ),
-        Effect17.orElseSucceed(() => void 0)
+        Effect18.orElseSucceed(() => void 0)
       );
       const prompt = buildPrompt(config, iteration, currentPlan);
       const promptPreview = prompt.slice(0, 200);
-      yield* Effect17.logDebug("Building prompt for iteration", {
+      yield* Effect18.logDebug("Building prompt for iteration", {
         iteration,
         promptLength: prompt.length,
         promptPreview: promptPreview.length < prompt.length ? `${promptPreview}...` : promptPreview
@@ -6643,7 +7086,7 @@ function createIterationStream(llm, signalParser, planStore, stateStore, progres
         ),
         Stream7.flatMap(
           (llmEvent) => Stream7.unwrap(
-            Effect17.gen(function* () {
+            Effect18.gen(function* () {
               const now = yield* DateTime6.now;
               const context = {
                 timestamp: DateTime6.toEpochMillis(now)
@@ -6665,14 +7108,14 @@ function createIterationStream(llm, signalParser, planStore, stateStore, progres
                 events.push(...planEvents);
               }
               if (result.completed) {
-                yield* Effect17.logInfo(
+                yield* Effect18.logInfo(
                   "[DEBUG] createIterationStream: LLM emitted completion signal"
                 );
                 yield* Ref6.set(loopCompletedRef, true);
               }
               const updatedPlan = yield* Ref6.get(currentPlanRef);
               const allComplete = areAllTasksComplete(updatedPlan);
-              yield* Effect17.logInfo(
+              yield* Effect18.logInfo(
                 "[DEBUG] createIterationStream: Auto-complete check",
                 {
                   llmEmittedComplete: result.completed,
@@ -6684,7 +7127,7 @@ function createIterationStream(llm, signalParser, planStore, stateStore, progres
                 }
               );
               if (allComplete) {
-                yield* Effect17.logInfo(
+                yield* Effect18.logInfo(
                   "[DEBUG] createIterationStream: All tasks complete - ending loop"
                 );
                 yield* Ref6.set(loopCompletedRef, true);
@@ -6706,7 +7149,7 @@ function createIterationStream(llm, signalParser, planStore, stateStore, progres
         )
       );
       const completionStream = Stream7.fromEffect(
-        Effect17.gen(function* () {
+        Effect18.gen(function* () {
           const persistEvents = yield* flushPlanPersistence(
             planStore,
             currentPlanRef,
@@ -6731,7 +7174,7 @@ function createIterationStream(llm, signalParser, planStore, stateStore, progres
 // src/commands/code/orchestrator/loop.ts
 function runLoop(config) {
   return Stream8.unwrap(
-    Effect18.gen(function* () {
+    Effect19.gen(function* () {
       const llm = yield* LLM;
       const signalParser = yield* SignalParser;
       const sessionStore = yield* SessionStore;
@@ -6741,7 +7184,7 @@ function runLoop(config) {
       const stateStore = yield* StateStore;
       const promptStore = yield* PromptStore;
       const session = yield* sessionStore.create(config.task, config.sessionId).pipe(
-        Effect18.mapError(
+        Effect19.mapError(
           (e) => new OrchestratorError({
             message: `Failed to create session: ${e.message}`,
             phase: "setup",
@@ -6750,15 +7193,15 @@ function runLoop(config) {
         )
       );
       const baseBranch = yield* git.getCurrentBranch().pipe(
-        Effect18.tapError(
-          (error) => Effect18.logDebug("Failed to get current branch", {
+        Effect19.tapError(
+          (error) => Effect19.logDebug("Failed to get current branch", {
             error: String(error)
           })
         ),
-        Effect18.orElseSucceed(() => void 0)
+        Effect19.orElseSucceed(() => void 0)
       );
       const worktreePath = yield* git.createWorktree(session.id).pipe(
-        Effect18.mapError(
+        Effect19.mapError(
           (e) => new OrchestratorError({
             message: `Failed to create worktree: ${e.message}`,
             phase: "setup",
@@ -6773,12 +7216,12 @@ function runLoop(config) {
         branchName,
         baseBranch
       }).pipe(
-        Effect18.tapError(
-          (error) => Effect18.logDebug("Failed to update session with worktree info", {
+        Effect19.tapError(
+          (error) => Effect19.logDebug("Failed to update session with worktree info", {
             error: String(error)
           })
         ),
-        Effect18.orElseSucceed(() => void 0)
+        Effect19.orElseSucceed(() => void 0)
       );
       const startTimeUtc = yield* DateTime7.now;
       const startTime = DateTime7.toEpochMillis(startTimeUtc);
@@ -6799,7 +7242,7 @@ function runLoop(config) {
         config,
         timestamp: startTime
       };
-      const handleSessionName = (displayName) => Effect18.gen(function* () {
+      const handleSessionName = (displayName) => Effect19.gen(function* () {
         const currentSession = yield* Ref7.get(sessionRef);
         const newBranchName = yield* git.renameBranch(
           session.id,
@@ -6828,7 +7271,7 @@ function runLoop(config) {
       );
       const iterationsStream = Stream8.unfoldEffect(
         1,
-        (iteration) => Effect18.gen(function* () {
+        (iteration) => Effect19.gen(function* () {
           const completed = yield* Ref7.get(loopCompletedRef);
           if (completed || iteration > maxIterations) {
             return Option.none();
@@ -6876,8 +7319,8 @@ function runLoop(config) {
       );
     }).pipe(
       // Also catch setup errors (e.g., session creation failure)
-      Effect18.catchAll(
-        (error) => Effect18.succeed(
+      Effect19.catchAll(
+        (error) => Effect19.succeed(
           Stream8.succeed({
             _tag: "LoopFailed",
             error: {
@@ -6903,32 +7346,32 @@ Generated by Ferix`;
 }
 function createCompletionStream(sessionStore, git, sessionRef, config, startTime, loopCompletedRef, _worktreePath) {
   return Stream8.unwrap(
-    Effect18.gen(function* () {
+    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* Ref7.get(loopCompletedRef);
       yield* git.commitChanges(session.id, `feat: complete session ${session.id}`).pipe(
-        Effect18.tapError(
-          (error) => Effect18.logDebug("Final commit failed, continuing", {
+        Effect19.tapError(
+          (error) => Effect19.logDebug("Final commit failed, continuing", {
             sessionId: session.id,
             error: String(error)
           })
         ),
-        Effect18.orElseSucceed(() => void 0)
+        Effect19.orElseSucceed(() => void 0)
       );
       let branchPushed = false;
       if (config.push === true) {
         const pushResult = yield* git.pushBranch(session.id).pipe(
-          Effect18.map(() => true),
-          Effect18.tapError(
-            (error) => Effect18.logDebug("Push failed, continuing", {
+          Effect19.map(() => true),
+          Effect19.tapError(
+            (error) => Effect19.logDebug("Push failed, continuing", {
               sessionId: session.id,
               error: String(error)
             })
           ),
-          Effect18.orElseSucceed(() => false)
+          Effect19.orElseSucceed(() => false)
         );
         branchPushed = pushResult;
       }
@@ -6937,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(
-          Effect18.map((url) => url),
-          Effect18.tapError(
-            (error) => Effect18.logDebug("PR creation failed, continuing", {
+          Effect19.map((url) => url),
+          Effect19.tapError(
+            (error) => Effect19.logDebug("PR creation failed, continuing", {
               sessionId: session.id,
               error: String(error)
             })
           ),
-          Effect18.orElseSucceed(() => void 0)
+          Effect19.orElseSucceed(() => void 0)
         );
         prUrl = prResult;
       }
       yield* git.removeWorktreeKeepBranch(session.id).pipe(
-        Effect18.tapError(
-          (error) => Effect18.logDebug("Worktree cleanup failed, continuing", {
+        Effect19.tapError(
+          (error) => Effect19.logDebug("Worktree cleanup failed, continuing", {
             sessionId: session.id,
             error: String(error)
           })
         ),
-        Effect18.orElseSucceed(() => void 0)
+        Effect19.orElseSucceed(() => void 0)
       );
       const worktreeRemoved = {
         _tag: "WorktreeRemoved",
@@ -6976,13 +7419,13 @@ function createCompletionStream(sessionStore, git, sessionRef, config, startTime
         status: completed ? "completed" : "paused",
         worktreePath: void 0
       }).pipe(
-        Effect18.tapError(
-          (error) => Effect18.logDebug("Session update failed, continuing", {
+        Effect19.tapError(
+          (error) => Effect19.logDebug("Session update failed, continuing", {
             sessionId: session.id,
             error: String(error)
           })
         ),
-        Effect18.orElseSucceed(() => void 0)
+        Effect19.orElseSucceed(() => void 0)
       );
       const events = [worktreeRemoved];
       if (branchPushed) {
@@ -7018,7 +7461,7 @@ function run(options) {
   const sessionId = config.sessionId ?? generateSessionId2();
   const configWithSession = { ...config, sessionId };
   const events = runLoop(configWithSession);
-  const eventsWithCallback = onEvent ? events.pipe(Stream9.tap((event) => Effect19.sync(() => onEvent(event)))) : events;
+  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);
@@ -7031,7 +7474,7 @@ function run(options) {
 }
 function main(config) {
   const consumerType = process.stdout.isTTY ? "tui" : "headless";
-  return run({ config, consumer: consumerType }).pipe(Effect19.runPromise);
+  return run({ config, consumer: consumerType }).pipe(Effect20.runPromise);
 }
 
 // src/commands/code/services/index.ts
@@ -7116,14 +7559,14 @@ init_esm_shims();
 import { access as access5 } from "fs/promises";
 import { dirname as dirname4, resolve } from "path";
 import { cancel } from "@clack/prompts";
-import { Effect as Effect24 } 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 join9 } from "path";
-import { Effect as Effect20 } from "effect";
+import { join as join10 } from "path";
+import { Effect as Effect21 } from "effect";
 var AGENT_DIRECTORIES = {
   opencode: [".opencode"],
   "claude-code": [".claude"],
@@ -7136,7 +7579,7 @@ var AGENT_DIRECTORIES = {
 var SUPPORTED_AGENTS = Object.keys(
   AGENT_DIRECTORIES
 );
-var directoryExists2 = (dirPath) => Effect20.promise(async () => {
+var directoryExists2 = (dirPath) => Effect21.promise(async () => {
   try {
     await access3(dirPath);
     return true;
@@ -7146,18 +7589,18 @@ var directoryExists2 = (dirPath) => Effect20.promise(async () => {
 });
 var isAgentPresent = (projectDir, agent) => {
   const directories = AGENT_DIRECTORIES[agent];
-  return Effect20.forEach(
+  return Effect21.forEach(
     directories,
-    (dir) => directoryExists2(join9(projectDir, dir))
-  ).pipe(Effect20.map((results) => results.some((exists) => exists)));
+    (dir) => directoryExists2(join10(projectDir, dir))
+  ).pipe(Effect21.map((results) => results.some((exists) => exists)));
 };
-var detectAgents = (projectDir) => Effect20.forEach(
+var detectAgents = (projectDir) => Effect21.forEach(
   SUPPORTED_AGENTS,
   (agent) => isAgentPresent(projectDir, agent).pipe(
-    Effect20.map((present) => present ? agent : null)
+    Effect21.map((present) => present ? agent : null)
   )
 ).pipe(
-  Effect20.map(
+  Effect21.map(
     (results) => results.filter((agent) => agent !== null)
   )
 );
@@ -7175,24 +7618,24 @@ var components = componentsGeneric();
 
 // src/commands/sync/find-skills.ts
 import { ConvexHttpClient } from "convex/browser";
-import { Effect as Effect21, Schema as S22 } from "effect";
+import { Effect as Effect22, Schema as S23 } from "effect";
 
 // src/commands/sync/errors.ts
 init_esm_shims();
-import { Data } from "effect";
-var SchemaValidationError = class extends Data.TaggedError(
+import { Data as Data2 } from "effect";
+var SchemaValidationError = class extends Data2.TaggedError(
   "SchemaValidationError"
 ) {
 };
-var ConvexError = class extends Data.TaggedError("ConvexError") {
+var ConvexError = class extends Data2.TaggedError("ConvexError") {
 };
-var SkillInstallError = class extends Data.TaggedError("SkillInstallError") {
+var SkillInstallError = class extends Data2.TaggedError("SkillInstallError") {
 };
 
 // src/commands/sync/types.ts
 init_esm_shims();
-import { Schema as S21 } from "effect";
-var AgentNameSchema = S21.Literal(
+import { Schema as S22 } from "effect";
+var AgentNameSchema = S22.Literal(
   "opencode",
   "claude-code",
   "cursor",
@@ -7201,21 +7644,21 @@ var AgentNameSchema = S21.Literal(
   "openhands",
   "windsurf"
 );
-var SkillRepoSchema = S21.Struct({
-  owner: S21.String,
-  repo: S21.String,
-  githubUrl: S21.String
-});
-var PackageOrgSchema = S21.Struct({
-  packageName: S21.String,
-  githubOrg: S21.NullOr(S21.String)
-});
-var PackageOrgsResponseSchema = S21.Array(PackageOrgSchema);
-var SkillReposResponseSchema = S21.Array(SkillRepoSchema);
-var InstallOptionsSchema = S21.Struct({
-  dryRun: S21.optional(S21.Boolean),
-  global: S21.optional(S21.Boolean),
-  agents: S21.optional(S21.Array(AgentNameSchema))
+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";
@@ -7228,8 +7671,8 @@ var NON_NPM_VERSION_PREFIXES = [
 ];
 
 // src/commands/sync/find-skills.ts
-var findSkillRepos = (orgs, dev) => Effect21.gen(function* () {
-  const response = yield* Effect21.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, {
@@ -7242,10 +7685,10 @@ var findSkillRepos = (orgs, dev) => Effect21.gen(function* () {
       cause: error
     })
   });
-  const validated = yield* S22.decodeUnknown(SkillReposResponseSchema)(
+  const validated = yield* S23.decodeUnknown(SkillReposResponseSchema)(
     response
   ).pipe(
-    Effect21.mapError(
+    Effect22.mapError(
       (error) => new SchemaValidationError({
         message: "Invalid response from directories.getByOwners",
         context: "findSkillRepos",
@@ -7259,7 +7702,7 @@ var findSkillRepos = (orgs, dev) => Effect21.gen(function* () {
 // src/commands/sync/helpers.ts
 init_esm_shims();
 import { access as access4, readdir as readdir2, readFile as readFile8 } from "fs/promises";
-import { dirname as dirname3, join as join10 } from "path";
+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 ?? {};
@@ -7297,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 = join10(rootDir, baseDir);
+    const fullPath2 = join11(rootDir, baseDir);
     try {
       const entries = await readdir2(fullPath2, { withFileTypes: true });
-      return entries.filter((entry) => entry.isDirectory()).map((entry) => join10(fullPath2, entry.name));
+      return entries.filter((entry) => entry.isDirectory()).map((entry) => join11(fullPath2, entry.name));
     } catch {
       return [];
     }
   }
-  const fullPath = join10(rootDir, pattern);
+  const fullPath = join11(rootDir, pattern);
   try {
     await access4(fullPath);
     return [fullPath];
@@ -7327,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 = join10(dir, "package.json");
+      const pkgPath = join11(dir, "package.json");
       try {
         await access4(pkgPath);
         packageJsonPaths.push(pkgPath);
@@ -7342,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 Effect22 } from "effect";
+import { Effect as Effect23 } from "effect";
 var execAsync2 = promisify2(exec2);
-var installSingleSkill = (repo, options) => Effect22.tryPromise({
+var installSingleSkill = (repo, options) => Effect23.tryPromise({
   try: async () => {
     const repoId = `${repo.owner}/${repo.repo}`;
     const globalFlag = options.global === true ? " --global" : "";
@@ -7364,9 +7807,9 @@ var installSingleSkill = (repo, options) => Effect22.tryPromise({
 });
 var installSkills = (repos, options = {}) => {
   if (options.dryRun === true) {
-    return Effect22.succeed(repos.map((r) => `${r.owner}/${r.repo}`));
+    return Effect23.succeed(repos.map((r) => `${r.owner}/${r.repo}`));
   }
-  return Effect22.forEach(repos, (repo) => installSingleSkill(repo, options), {
+  return Effect23.forEach(repos, (repo) => installSingleSkill(repo, options), {
     concurrency: 1
   });
 };
@@ -7374,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 Effect23, Schema as S23 } from "effect";
-var resolvePackageOrgs = (packageNames, dev) => Effect23.gen(function* () {
-  const response = yield* Effect23.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, {
@@ -7389,10 +7832,10 @@ var resolvePackageOrgs = (packageNames, dev) => Effect23.gen(function* () {
       cause: error
     })
   });
-  const validated = yield* S23.decodeUnknown(PackageOrgsResponseSchema)(
+  const validated = yield* S24.decodeUnknown(PackageOrgsResponseSchema)(
     response
   ).pipe(
-    Effect23.mapError(
+    Effect24.mapError(
       (error) => new SchemaValidationError({
         message: "Invalid response from packageOrg.resolve",
         context: "resolvePackageOrgs",
@@ -7557,7 +8000,7 @@ var extractAllDependencies = async (state) => {
 var resolveOrganizations = async (state, isDev) => {
   state.spinner = createSpinner("Resolving GitHub organizations...").start();
   try {
-    const packageOrgs = await Effect24.runPromise(
+    const packageOrgs = await Effect25.runPromise(
       resolvePackageOrgs(state.dependencies, isDev)
     );
     state.orgs = Array.from(
@@ -7582,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 Effect24.runPromise(
+    state.skillRepos = await Effect25.runPromise(
       findSkillRepos(state.orgs, isDev)
     );
     if (state.skillRepos.length === 0) {
@@ -7604,7 +8047,7 @@ var findRepositories = async (state, isDev) => {
 var detectProjectAgents = async (state, projectDir) => {
   state.spinner = createSpinner("Detecting coding agents...").start();
   try {
-    state.detectedAgents = await Effect24.runPromise(detectAgents(projectDir));
+    state.detectedAgents = await Effect25.runPromise(detectAgents(projectDir));
     if (state.detectedAgents.length === 0) {
       state.spinner.info("No coding agents detected");
     } else {
@@ -7691,7 +8134,7 @@ var installRepositories = async (state, reposToInstall, isGlobal, agents) => {
       `Installing ${pc19.cyan(repo.owner)}${pc19.dim("/")}${pc19.white(repo.repo)}...`
     ).start();
     try {
-      await Effect24.runPromise(
+      await Effect25.runPromise(
         installSkills([repo], {
           dryRun: false,
           global: isGlobal,