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

package/dist/index.js

@@ -71,7 +71,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "ferix-code",
-  version: "0.0.2-beta.15",
+  version: "0.0.2-beta.18",
   description: "Composable RALPH loops for AI coding agents - v2 with Effect",
   type: "module",
   bin: {
@@ -316,7 +316,14 @@ var worktreeCreatedFormatter = {
     `[WORKTREE] Branch: ${event.branchName} | Path: ${event.worktreePath}`
   )
 };
+var worktreeRemovedFormatter = {
+  tag: "WorktreeRemoved",
+  format: (event) => pc9.cyan(
+    `[WORKTREE] Cleaned up worktree for session: ${event.sessionId} (branch preserved)`
+  )
+};
 headlessFormatterRegistry.register(worktreeCreatedFormatter);
+headlessFormatterRegistry.register(worktreeRemovedFormatter);
 
 // src/consumers/headless/formatters/index.ts
 function formatEvent(event) {
@@ -1057,40 +1064,165 @@ init_esm_shims();
 
 // src/consumers/tui/tools/registry.ts
 init_esm_shims();
+import { Either as Either2 } from "effect";
 import pc13 from "picocolors";
+
+// src/domain/schemas/tool-inputs.ts
+init_esm_shims();
+import { Either, Schema as S } from "effect";
+var ExtendableRecord = S.Record({ key: S.String, value: S.Unknown });
+var ReadToolInputSchema = S.Struct({
+  file_path: S.String,
+  offset: S.optional(S.Number),
+  limit: S.optional(S.Number)
+}).pipe(S.extend(ExtendableRecord));
+var EditToolInputSchema = S.Struct({
+  file_path: S.String,
+  old_string: S.String,
+  new_string: S.String,
+  replace_all: S.optional(S.Boolean)
+}).pipe(S.extend(ExtendableRecord));
+var WriteToolInputSchema = S.Struct({
+  file_path: S.String,
+  content: S.String
+}).pipe(S.extend(ExtendableRecord));
+var BashToolInputSchema = S.Struct({
+  command: S.String,
+  description: S.optional(S.String),
+  timeout: S.optional(S.Number),
+  run_in_background: S.optional(S.Boolean)
+}).pipe(S.extend(ExtendableRecord));
+var GlobToolInputSchema = S.Struct({
+  pattern: S.String,
+  path: S.optional(S.String)
+}).pipe(S.extend(ExtendableRecord));
+var GrepToolInputSchema = S.Struct({
+  pattern: S.String,
+  path: S.optional(S.String),
+  glob: S.optional(S.String),
+  type: S.optional(S.String),
+  output_mode: S.optional(S.Literal("content", "files_with_matches", "count"))
+}).pipe(S.extend(ExtendableRecord));
+var TaskToolInputSchema = S.Struct({
+  description: S.String,
+  prompt: S.optional(S.String)
+}).pipe(S.extend(ExtendableRecord));
+var WebFetchToolInputSchema = S.Struct({
+  url: S.String,
+  prompt: S.optional(S.String)
+}).pipe(S.extend(ExtendableRecord));
+var WebSearchToolInputSchema = S.Struct({
+  query: S.String
+}).pipe(S.extend(ExtendableRecord));
+var ToolInputSchemaRegistry = {
+  read: ReadToolInputSchema,
+  edit: EditToolInputSchema,
+  write: WriteToolInputSchema,
+  bash: BashToolInputSchema,
+  glob: GlobToolInputSchema,
+  grep: GrepToolInputSchema,
+  task: TaskToolInputSchema,
+  webfetch: WebFetchToolInputSchema,
+  websearch: WebSearchToolInputSchema
+};
+function getToolInputSchema(tool) {
+  const normalized = tool.toLowerCase();
+  if (normalized in ToolInputSchemaRegistry) {
+    return ToolInputSchemaRegistry[normalized];
+  }
+  return void 0;
+}
+var AnyToolInputSchema = S.Union(
+  ReadToolInputSchema,
+  EditToolInputSchema,
+  WriteToolInputSchema,
+  BashToolInputSchema,
+  GlobToolInputSchema,
+  GrepToolInputSchema,
+  TaskToolInputSchema,
+  WebFetchToolInputSchema,
+  WebSearchToolInputSchema
+);
+function validateToolInput(tool, input) {
+  const schema = getToolInputSchema(tool);
+  if (!schema) {
+    return Either.right(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/consumers/tui/tools/registry.ts
 var brightWhite = (s) => pc13.bold(pc13.white(s));
+function normalizeToolName(tool) {
+  return tool.toLowerCase();
+}
+function extractStringValue(obj, key) {
+  const getValue = (k) => {
+    const val = obj[k];
+    return typeof val === "string" ? val : void 0;
+  };
+  const exact = getValue(key);
+  if (exact !== void 0) {
+    return exact;
+  }
+  const camelKey = key.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+  const camel = getValue(camelKey);
+  if (camel !== void 0) {
+    return camel;
+  }
+  const snakeKey = key.replace(/([A-Z])/g, "_$1").toLowerCase();
+  return getValue(snakeKey);
+}
+function getValidatedInput(tool, input) {
+  if (!input || typeof input !== "object") {
+    return null;
+  }
+  const result = validateToolInput(tool, input);
+  if (Either2.isRight(result)) {
+    return result.right;
+  }
+  return input;
+}
 function createToolDisplayRegistry() {
   const configs = /* @__PURE__ */ new Map();
   const defaultColor = pc13.white;
   return {
     register(config) {
-      configs.set(config.tool, config);
+      configs.set(normalizeToolName(config.tool), config);
     },
     getInputKey(tool) {
-      return configs.get(tool)?.inputKey;
+      return configs.get(normalizeToolName(tool))?.inputKey;
     },
     getColor(tool) {
-      return configs.get(tool)?.color ?? defaultColor;
+      return configs.get(normalizeToolName(tool))?.color ?? defaultColor;
     },
     getMaxLength(tool) {
-      return configs.get(tool)?.maxLength ?? MAX_TOOL_INPUT_LENGTH;
+      return configs.get(normalizeToolName(tool))?.maxLength ?? MAX_TOOL_INPUT_LENGTH;
     },
     formatInput(tool, input) {
-      if (!input || typeof input !== "object") {
+      const config = configs.get(normalizeToolName(tool));
+      if (!config) {
         return "";
       }
-      const config = configs.get(tool);
-      if (!config) {
+      const obj = getValidatedInput(tool, input);
+      if (!obj) {
         return "";
       }
-      const obj = input;
-      const value = obj[config.inputKey];
+      const value = extractStringValue(obj, config.inputKey);
       if (!value) {
         return "";
       }
-      const str = String(value);
       const maxLen = config.maxLength ?? MAX_TOOL_INPUT_LENGTH;
-      return str.length > maxLen ? `${str.slice(0, maxLen)}...` : str;
+      return value.length > maxLen ? `${value.slice(0, maxLen)}...` : value;
     }
   };
 }
@@ -1147,11 +1279,47 @@ function formatToolInput(tool, input) {
 }
 
 // src/consumers/tui/reducers/helpers.ts
+var FERIX_BLOCK_PATTERNS = [
+  /<ferix:session-name>[\s\S]*?<\/ferix:session-name>/g,
+  /<ferix:tasks>[\s\S]*?<\/ferix:tasks>/g,
+  /<ferix:phases[^>]*>[\s\S]*?<\/ferix:phases>/g,
+  /<ferix:criteria[^>]*>[\s\S]*?<\/ferix:criteria>/g,
+  /<ferix:task-complete[^>]*>[\s\S]*?<\/ferix:task-complete>/g,
+  /<ferix:phase-failed[^>]*>[\s\S]*?<\/ferix:phase-failed>/g,
+  /<ferix:learning[^>]*>[\s\S]*?<\/ferix:learning>/g,
+  /<ferix:guardrail[^>]*>[\s\S]*?<\/ferix:guardrail>/g
+];
+var FERIX_SELF_CLOSING_PATTERNS = [
+  /<ferix:phase-start[^>]*\/>/g,
+  /<ferix:phase-done[^>]*\/>/g,
+  /<ferix:criterion-passed[^>]*\/>/g,
+  /<ferix:criterion-failed[^>]*\/>/g,
+  /<ferix:check-passed\s*\/>/g,
+  /<ferix:check-failed\s*\/>/g,
+  /<ferix:review-complete\s*\/>/g,
+  /<ferix:review-changes-made\s*\/>/g,
+  /<ferix:complete\s*>/g
+  // Note: complete is not self-closing, just <ferix:complete>
+];
+function stripFerixSignals(text) {
+  let result = text;
+  for (const pattern of FERIX_BLOCK_PATTERNS) {
+    result = result.replace(pattern, "");
+  }
+  for (const pattern of FERIX_SELF_CLOSING_PATTERNS) {
+    result = result.replace(pattern, "");
+  }
+  return result;
+}
 function appendOutput(state, text) {
   if (!text) {
     return state;
   }
-  const fullText = state.partialLine + text;
+  const cleanedText = stripFerixSignals(text);
+  if (!cleanedText) {
+    return state;
+  }
+  const fullText = state.partialLine + cleanedText;
   const parts = fullText.split("\n");
   const partialLine = parts.pop() ?? "";
   const newLines = parts.filter((line) => line.length > 0);
@@ -1439,7 +1607,18 @@ Worktree created
 `
   )
 };
+var worktreeRemovedReducer = {
+  tag: "WorktreeRemoved",
+  reduce: (state, event) => appendOutput(
+    state,
+    `
+Worktree cleaned up (branch preserved)
+   Session: ${event.sessionId}
+`
+  )
+};
 stateReducerRegistry.register(worktreeCreatedReducer);
+stateReducerRegistry.register(worktreeRemovedReducer);
 
 // src/consumers/tui/reducers/index.ts
 function reduce(state, event) {
@@ -2536,6 +2715,36 @@ var make = {
       Effect4.catchAll(() => Effect4.succeed(void 0))
     );
   }),
+  removeWorktreeKeepBranch: (sessionId) => Effect4.gen(function* () {
+    const worktreeDir = getWorktreeDir(sessionId);
+    const exists = yield* directoryExists(worktreeDir);
+    if (!exists) {
+      return;
+    }
+    yield* gitExec(`git worktree remove "${worktreeDir}" --force`).pipe(
+      Effect4.mapError(
+        (error) => new GitError({
+          message: `Failed to remove worktree: ${error.message}`,
+          operation: "removeWorktreeKeepBranch",
+          cause: error
+        })
+      ),
+      // If git worktree remove fails, try manual cleanup
+      Effect4.catchAll(
+        () => Effect4.tryPromise({
+          try: () => rm(worktreeDir, { recursive: true, force: true }),
+          catch: (error) => new GitError({
+            message: `Failed to remove worktree directory: ${String(error)}`,
+            operation: "removeWorktreeKeepBranch",
+            cause: error
+          })
+        })
+      )
+    );
+    yield* gitExec("git worktree prune").pipe(
+      Effect4.catchAll(() => Effect4.succeed(void 0))
+    );
+  }),
   getWorktreePath: (sessionId) => Effect4.gen(function* () {
     const worktreeDir = getWorktreeDir(sessionId);
     const exists = yield* directoryExists(worktreeDir);
@@ -2646,6 +2855,33 @@ var make = {
     );
     return prUrl;
   }),
+  renameBranch: (sessionId, displayName) => Effect4.gen(function* () {
+    const worktreeDir = getWorktreeDir(sessionId);
+    const oldBranchName = getBranchName(sessionId);
+    const newBranchName = `${BRANCH_PREFIX}/${displayName}`;
+    const exists = yield* directoryExists(worktreeDir);
+    if (!exists) {
+      return yield* Effect4.fail(
+        new GitError({
+          message: `Worktree not found for session: ${sessionId}`,
+          operation: "renameBranch"
+        })
+      );
+    }
+    yield* gitExec(
+      `git branch -m "${oldBranchName}" "${newBranchName}"`,
+      worktreeDir
+    ).pipe(
+      Effect4.mapError(
+        (error) => new GitError({
+          message: `Failed to rename branch: ${error.message}`,
+          operation: "renameBranch",
+          cause: error
+        })
+      )
+    );
+    return newBranchName;
+  }),
   getBranchName
 };
 var Live = Layer.succeed(Git, make);
@@ -2684,6 +2920,11 @@ function createMemoryGitService(stateRef, commitCounterRef) {
       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);
@@ -2736,6 +2977,26 @@ function createMemoryGitService(stateRef, commitCounterRef) {
       const slug = title.toLowerCase().replace(/\s+/g, "-").slice(0, 30);
       return `https://github.com/test/repo/pull/${slug}`;
     }),
+    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
   };
 }
@@ -2767,60 +3028,196 @@ init_esm_shims();
 // src/domain/schemas/index.ts
 init_esm_shims();
 
+// src/domain/schemas/cli-output.ts
+init_esm_shims();
+import { Schema as S2 } from "effect";
+var TextDeltaSchema = S2.Struct({
+  type: S2.Literal("text_delta"),
+  text: S2.String
+});
+var InputJsonDeltaSchema = S2.Struct({
+  type: S2.Literal("input_json_delta"),
+  partial_json: S2.String
+});
+var DeltaSchema = S2.Union(TextDeltaSchema, InputJsonDeltaSchema);
+var TextContentBlockSchema = S2.Struct({
+  type: S2.Literal("text"),
+  text: S2.String
+});
+var ToolUseContentBlockSchema = S2.Struct({
+  type: S2.Literal("tool_use"),
+  id: S2.optional(S2.String),
+  name: S2.String,
+  input: S2.Unknown
+});
+var ContentBlockSchema = S2.Union(
+  TextContentBlockSchema,
+  ToolUseContentBlockSchema
+);
+var ContentBlockStartSchema = S2.Struct({
+  type: S2.Literal("content_block_start"),
+  index: S2.optional(S2.Number),
+  content_block: S2.Union(
+    S2.Struct({
+      type: S2.Literal("text"),
+      text: S2.optional(S2.String)
+    }),
+    S2.Struct({
+      type: S2.Literal("tool_use"),
+      id: S2.optional(S2.String),
+      name: S2.String,
+      input: S2.optional(S2.Unknown)
+    })
+  )
+});
+var ContentBlockDeltaSchema = S2.Struct({
+  type: S2.Literal("content_block_delta"),
+  index: S2.optional(S2.Number),
+  delta: DeltaSchema
+});
+var ContentBlockStopSchema = S2.Struct({
+  type: S2.Literal("content_block_stop"),
+  index: S2.optional(S2.Number)
+});
+var AssistantMessageSchema = S2.Struct({
+  type: S2.Literal("assistant"),
+  message: S2.Struct({
+    content: S2.Array(ContentBlockSchema)
+  })
+});
+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);
+var isAssistantMessage = S2.is(AssistantMessageSchema);
+var isStreamEventEnvelope = S2.is(StreamEventEnvelopeSchema);
+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/domain/schemas/cli-output-opencode.ts
+init_esm_shims();
+import { Schema as S3 } from "effect";
+var OpenCodeTextEventSchema = S3.Struct({
+  type: S3.Literal("text"),
+  text: S3.String
+});
+var OpenCodeToolStateSchema = S3.Struct({
+  status: S3.String,
+  input: S3.Unknown,
+  output: S3.optional(S3.String)
+});
+var OpenCodeToolPartSchema = S3.Struct({
+  tool: S3.String,
+  callID: S3.String,
+  state: OpenCodeToolStateSchema
+});
+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 }))
+);
+var OpenCodeCostSchema = S3.Struct({}).pipe(
+  S3.extend(S3.Record({ key: S3.String, value: S3.Unknown }))
+);
+var OpenCodeStepFinishSchema = S3.Struct({
+  type: S3.Literal("step_finish"),
+  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/domain/schemas/config.ts
 init_esm_shims();
-import { Schema as S } from "effect";
-var ProviderNameSchema = S.Literal("claude", "cursor", "opencode");
-var PhasePromptOverridesSchema = S.Struct({
-  breakdown: S.optional(S.String),
-  planning: S.optional(S.String),
-  execution: S.optional(S.String),
-  check: S.optional(S.String),
-  verify: S.optional(S.String),
-  review: S.optional(S.String),
-  completion: S.optional(S.String)
-});
-var PromptConfigSchema = S.Struct({
-  systemPrompt: S.optional(S.String),
-  phases: S.optional(PhasePromptOverridesSchema),
-  additionalContext: S.optional(S.String)
-});
-var LoopConfigSchema = S.Struct({
-  task: S.String,
-  maxIterations: S.Number,
-  verifyCommands: S.Array(S.String),
-  sessionId: S.optional(S.String),
-  branch: S.optional(S.String),
-  push: S.optional(S.Boolean),
-  pr: S.optional(S.Boolean),
-  verbose: S.optional(S.Boolean),
-  prompts: S.optional(PromptConfigSchema),
+import { Schema as S4 } from "effect";
+var ProviderNameSchema = S4.Literal("claude", "cursor", "opencode");
+var PhasePromptOverridesSchema = S4.Struct({
+  breakdown: S4.optional(S4.String),
+  planning: S4.optional(S4.String),
+  execution: S4.optional(S4.String),
+  check: S4.optional(S4.String),
+  verify: S4.optional(S4.String),
+  review: S4.optional(S4.String),
+  completion: S4.optional(S4.String)
+});
+var PromptConfigSchema = S4.Struct({
+  systemPrompt: S4.optional(S4.String),
+  phases: S4.optional(PhasePromptOverridesSchema),
+  additionalContext: S4.optional(S4.String)
+});
+var LoopConfigSchema = S4.Struct({
+  task: S4.String,
+  maxIterations: S4.Number,
+  verifyCommands: S4.Array(S4.String),
+  sessionId: S4.optional(S4.String),
+  branch: S4.optional(S4.String),
+  push: S4.optional(S4.Boolean),
+  pr: S4.optional(S4.Boolean),
+  verbose: S4.optional(S4.Boolean),
+  prompts: S4.optional(PromptConfigSchema),
   /** LLM provider to use. Defaults to "claude". */
-  provider: S.optional(ProviderNameSchema)
+  provider: S4.optional(ProviderNameSchema)
 });
-var LoopSummarySchema = S.Struct({
-  iterations: S.Number,
-  success: S.Boolean,
-  sessionId: S.String,
-  completedTasks: S.Array(S.String),
-  durationMs: S.Number
+var LoopSummarySchema = S4.Struct({
+  iterations: S4.Number,
+  success: S4.Boolean,
+  sessionId: S4.String,
+  completedTasks: S4.Array(S4.String),
+  durationMs: S4.Number
 });
-var LoopErrorSchema = S.Struct({
-  message: S.String,
-  phase: S.String,
-  iteration: S.optional(S.Number)
+var LoopErrorSchema = S4.Struct({
+  message: S4.String,
+  phase: S4.String,
+  iteration: S4.optional(S4.Number)
 });
-var decodeLoopConfig = S.decodeUnknown(LoopConfigSchema);
+var decodeLoopConfig = S4.decodeUnknown(LoopConfigSchema);
 
 // src/domain/schemas/events.ts
 init_esm_shims();
-import { Schema as S4 } from "effect";
+import { Schema as S7 } from "effect";
 
 // src/domain/schemas/plan.ts
 init_esm_shims();
-import { Brand, Schema as S2 } from "effect";
+import { Brand, Schema as S5 } from "effect";
 var PlanId = Brand.nominal();
-var TaskStatusSchema = S2.Literal(
+var TaskStatusSchema = S5.Literal(
   "pending",
   "planning",
   "in_progress",
@@ -2828,114 +3225,114 @@ var TaskStatusSchema = S2.Literal(
   "failed",
   "skipped"
 );
-var PhaseStatusSchema = S2.Literal(
+var PhaseStatusSchema = S5.Literal(
   "pending",
   "in_progress",
   "done",
   "failed"
 );
-var CriterionStatusSchema = S2.Literal("pending", "passed", "failed");
-var PhaseSchema = S2.Struct({
-  id: S2.String,
-  description: S2.String,
+var CriterionStatusSchema = S5.Literal("pending", "passed", "failed");
+var PhaseSchema = S5.Struct({
+  id: S5.String,
+  description: S5.String,
   status: PhaseStatusSchema
 });
-var CriterionSchema = S2.Struct({
-  id: S2.String,
-  description: S2.String,
+var CriterionSchema = S5.Struct({
+  id: S5.String,
+  description: S5.String,
   status: CriterionStatusSchema,
-  failureReason: S2.optional(S2.String)
+  failureReason: S5.optional(S5.String)
 });
-var TaskSchema = S2.Struct({
-  id: S2.String,
-  title: S2.String,
-  description: S2.String,
+var TaskSchema = S5.Struct({
+  id: S5.String,
+  title: S5.String,
+  description: S5.String,
   status: TaskStatusSchema,
-  phases: S2.Array(PhaseSchema),
-  criteria: S2.Array(CriterionSchema),
-  filesToModify: S2.Array(S2.String),
-  attempts: S2.Number,
-  completionNotes: S2.optional(S2.String)
-});
-var PlanDataSchema = S2.Struct({
-  sessionId: S2.String,
-  createdAt: S2.String,
-  originalTask: S2.String,
-  context: S2.optional(S2.String),
-  tasks: S2.Array(TaskSchema)
-});
-var PlanSchema = S2.Struct({
-  id: S2.String,
-  sessionId: S2.String,
-  createdAt: S2.String,
-  originalTask: S2.String,
-  context: S2.optional(S2.String),
-  tasks: S2.Array(TaskSchema)
-});
-var decodePlan = S2.decodeUnknown(PlanSchema);
-var decodePlanData = S2.decodeUnknown(PlanDataSchema);
+  phases: S5.Array(PhaseSchema),
+  criteria: S5.Array(CriterionSchema),
+  filesToModify: S5.Array(S5.String),
+  attempts: S5.Number,
+  completionNotes: S5.optional(S5.String)
+});
+var PlanDataSchema = S5.Struct({
+  sessionId: S5.String,
+  createdAt: S5.String,
+  originalTask: S5.String,
+  context: S5.optional(S5.String),
+  tasks: S5.Array(TaskSchema)
+});
+var PlanSchema = S5.Struct({
+  id: S5.String,
+  sessionId: S5.String,
+  createdAt: S5.String,
+  originalTask: S5.String,
+  context: S5.optional(S5.String),
+  tasks: S5.Array(TaskSchema)
+});
+var decodePlan = S5.decodeUnknown(PlanSchema);
+var decodePlanData = S5.decodeUnknown(PlanDataSchema);
 
 // src/domain/schemas/shared.ts
 init_esm_shims();
-import { Schema as S3 } from "effect";
-var TaskBasicInfoSchema = S3.Struct({
-  id: S3.String,
-  title: S3.String,
-  description: S3.String
+import { Schema as S6 } from "effect";
+var TaskBasicInfoSchema = S6.Struct({
+  id: S6.String,
+  title: S6.String,
+  description: S6.String
 });
-var PhaseBasicInfoSchema = S3.Struct({
-  id: S3.String,
-  description: S3.String
+var PhaseBasicInfoSchema = S6.Struct({
+  id: S6.String,
+  description: S6.String
 });
-var CriterionBasicInfoSchema = S3.Struct({
-  id: S3.String,
-  description: S3.String
+var CriterionBasicInfoSchema = S6.Struct({
+  id: S6.String,
+  description: S6.String
 });
-var TasksDefinedDataSchema = S3.Struct({
-  tasks: S3.Array(TaskBasicInfoSchema)
+var TasksDefinedDataSchema = S6.Struct({
+  tasks: S6.Array(TaskBasicInfoSchema)
 });
-var PhasesDefinedDataSchema = S3.Struct({
-  taskId: S3.String,
-  phases: S3.Array(PhaseBasicInfoSchema)
+var PhasesDefinedDataSchema = S6.Struct({
+  taskId: S6.String,
+  phases: S6.Array(PhaseBasicInfoSchema)
 });
-var CriteriaDefinedDataSchema = S3.Struct({
-  taskId: S3.String,
-  criteria: S3.Array(CriterionBasicInfoSchema)
+var CriteriaDefinedDataSchema = S6.Struct({
+  taskId: S6.String,
+  criteria: S6.Array(CriterionBasicInfoSchema)
 });
-var PhaseIdDataSchema = S3.Struct({
-  phaseId: S3.String
+var PhaseIdDataSchema = S6.Struct({
+  phaseId: S6.String
 });
-var PhaseFailedDataSchema = S3.Struct({
-  phaseId: S3.String,
-  reason: S3.String
+var PhaseFailedDataSchema = S6.Struct({
+  phaseId: S6.String,
+  reason: S6.String
 });
-var CriterionIdDataSchema = S3.Struct({
-  criterionId: S3.String
+var CriterionIdDataSchema = S6.Struct({
+  criterionId: S6.String
 });
-var CriterionFailedDataSchema = S3.Struct({
-  criterionId: S3.String,
-  reason: S3.String
+var CriterionFailedDataSchema = S6.Struct({
+  criterionId: S6.String,
+  reason: S6.String
 });
-var ReviewCompleteDataSchema = S3.Struct({
-  changesMade: S3.Boolean
+var ReviewCompleteDataSchema = S6.Struct({
+  changesMade: S6.Boolean
 });
-var TaskCompleteSignalDataSchema = S3.Struct({
-  taskId: S3.String,
-  summary: S3.String,
-  filesModified: S3.Array(S3.String),
-  filesCreated: S3.Array(S3.String)
+var TaskCompleteSignalDataSchema = S6.Struct({
+  taskId: S6.String,
+  summary: S6.String,
+  filesModified: S6.Array(S6.String),
+  filesCreated: S6.Array(S6.String)
 });
-var TaskCompleteDataSchema = S3.Struct({
-  taskId: S3.String,
-  summary: S3.String
+var TaskCompleteDataSchema = S6.Struct({
+  taskId: S6.String,
+  summary: S6.String
 });
 
 // src/domain/schemas/events.ts
-var taggedEvent = (tag, fields) => S4.TaggedStruct(tag, fields);
-var taggedFromData = (tag, dataSchema, extraFields = {}) => S4.TaggedStruct(tag, { ...dataSchema.fields, ...extraFields });
+var taggedEvent = (tag, fields) => S7.TaggedStruct(tag, fields);
+var taggedFromData = (tag, dataSchema, extraFields = {}) => S7.TaggedStruct(tag, { ...dataSchema.fields, ...extraFields });
 var LoopStartedEventSchema = taggedEvent("LoopStarted", {
   config: LoopConfigSchema,
-  timestamp: S4.Number
+  timestamp: S7.Number
 });
 var LoopCompletedEventSchema = taggedEvent("LoopCompleted", {
   summary: LoopSummarySchema
@@ -2944,30 +3341,30 @@ var LoopFailedEventSchema = taggedEvent("LoopFailed", {
   error: LoopErrorSchema
 });
 var DiscoveryStartedEventSchema = taggedEvent("DiscoveryStarted", {
-  timestamp: S4.Number
+  timestamp: S7.Number
 });
 var DiscoveryCompletedEventSchema = taggedEvent("DiscoveryCompleted", {
-  taskCount: S4.Number,
-  timestamp: S4.Number
+  taskCount: S7.Number,
+  timestamp: S7.Number
 });
 var IterationStartedEventSchema = taggedEvent("IterationStarted", {
-  iteration: S4.Number
+  iteration: S7.Number
 });
 var IterationCompletedEventSchema = taggedEvent("IterationCompleted", {
-  iteration: S4.Number
+  iteration: S7.Number
 });
 var LLMTextEventSchema = taggedEvent("LLMText", {
-  text: S4.String
+  text: S7.String
 });
 var LLMToolStartEventSchema = taggedEvent("LLMToolStart", {
-  tool: S4.String
+  tool: S7.String
 });
 var LLMToolUseEventSchema = taggedEvent("LLMToolUse", {
-  tool: S4.String,
-  input: S4.Unknown
+  tool: S7.String,
+  input: S7.Unknown
 });
 var LLMToolEndEventSchema = taggedEvent("LLMToolEnd", {
-  tool: S4.String
+  tool: S7.String
 });
 var TasksDefinedEventSchema = taggedFromData(
   "TasksDefined",
@@ -2984,17 +3381,17 @@ var CriteriaDefinedEventSchema = taggedFromData(
 var PhaseStartedEventSchema = taggedFromData(
   "PhaseStarted",
   PhaseIdDataSchema,
-  { timestamp: S4.Number }
+  { timestamp: S7.Number }
 );
 var PhaseCompletedEventSchema = taggedFromData(
   "PhaseCompleted",
   PhaseIdDataSchema,
-  { timestamp: S4.Number }
+  { timestamp: S7.Number }
 );
 var PhaseFailedEventSchema = taggedFromData(
   "PhaseFailed",
   PhaseFailedDataSchema,
-  { timestamp: S4.Number }
+  { timestamp: S7.Number }
 );
 var CriterionPassedEventSchema = taggedFromData(
   "CriterionPassed",
@@ -3004,9 +3401,9 @@ var CriterionFailedEventSchema = taggedFromData(
   "CriterionFailed",
   CriterionFailedDataSchema
 );
-var CheckPassedEventSchema = S4.TaggedStruct("CheckPassed", {});
+var CheckPassedEventSchema = S7.TaggedStruct("CheckPassed", {});
 var CheckFailedEventSchema = taggedEvent("CheckFailed", {
-  failedCriteria: S4.Array(S4.String)
+  failedCriteria: S7.Array(S7.String)
 });
 var ReviewCompleteEventSchema = taggedFromData(
   "ReviewComplete",
@@ -3015,7 +3412,7 @@ var ReviewCompleteEventSchema = taggedFromData(
 var TaskCompletedEventSchema = taggedFromData(
   "TaskCompleted",
   TaskCompleteDataSchema,
-  { timestamp: S4.Number }
+  { timestamp: S7.Number }
 );
 var PlanCreatedEventSchema = taggedEvent("PlanCreated", {
   plan: PlanSchema
@@ -3024,43 +3421,52 @@ var PlanUpdatedEventSchema = taggedEvent("PlanUpdated", {
   plan: PlanSchema
 });
 var PlanUpdateFailedEventSchema = taggedEvent("PlanUpdateFailed", {
-  operation: S4.Literal("create", "update"),
-  error: S4.String,
-  planId: S4.optional(S4.String)
+  operation: S7.Literal("create", "update"),
+  error: S7.String,
+  planId: S7.optional(S7.String)
 });
 var LearningRecordedEventSchema = taggedEvent("LearningRecorded", {
-  iteration: S4.Number,
-  content: S4.String,
-  category: S4.optional(S4.Literal("success", "failure", "optimization")),
-  timestamp: S4.Number
+  iteration: S7.Number,
+  content: S7.String,
+  category: S7.optional(S7.Literal("success", "failure", "optimization")),
+  timestamp: S7.Number
 });
 var GuardrailAddedEventSchema = taggedEvent("GuardrailAdded", {
-  id: S4.String,
-  iteration: S4.Number,
-  pattern: S4.String,
-  sign: S4.String,
-  avoidance: S4.String,
-  severity: S4.Literal("warning", "critical"),
-  timestamp: S4.Number
+  id: S7.String,
+  iteration: S7.Number,
+  pattern: S7.String,
+  sign: S7.String,
+  avoidance: S7.String,
+  severity: S7.Literal("warning", "critical"),
+  timestamp: S7.Number
 });
 var ProgressUpdatedEventSchema = taggedEvent("ProgressUpdated", {
-  sessionId: S4.String,
-  iteration: S4.Number,
-  taskId: S4.String,
-  action: S4.Literal("started", "completed", "failed", "learning"),
-  timestamp: S4.Number
+  sessionId: S7.String,
+  iteration: S7.Number,
+  taskId: S7.String,
+  action: S7.Literal("started", "completed", "failed", "learning"),
+  timestamp: S7.Number
 });
 var WorktreeCreatedEventSchema = taggedEvent("WorktreeCreated", {
-  sessionId: S4.String,
-  worktreePath: S4.String,
-  branchName: S4.String,
-  timestamp: S4.Number
+  sessionId: S7.String,
+  worktreePath: S7.String,
+  branchName: S7.String,
+  timestamp: S7.Number
 });
 var WorktreeRemovedEventSchema = taggedEvent("WorktreeRemoved", {
-  sessionId: S4.String,
-  timestamp: S4.Number
+  sessionId: S7.String,
+  timestamp: S7.Number
 });
-var DomainEventSchema = S4.Union(
+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,
@@ -3091,7 +3497,8 @@ var DomainEventSchema = S4.Union(
   GuardrailAddedEventSchema,
   ProgressUpdatedEventSchema,
   WorktreeCreatedEventSchema,
-  WorktreeRemovedEventSchema
+  WorktreeRemovedEventSchema,
+  SessionNameGeneratedEventSchema
 );
 var DomainEventUtils = {
   isLLMEvent: (e) => e._tag.startsWith("LLM"),
@@ -3103,132 +3510,149 @@ var DomainEventUtils = {
 
 // src/domain/schemas/guardrails.ts
 init_esm_shims();
-import { Schema as S5 } from "effect";
-var GuardrailSeveritySchema = S5.Literal("warning", "critical");
-var GuardrailSchema = S5.Struct({
-  id: S5.String,
-  createdAt: S5.String,
-  iteration: S5.Number,
-  pattern: S5.String,
-  sign: S5.String,
-  avoidance: S5.String,
+import { Schema as S8 } from "effect";
+var GuardrailSeveritySchema = S8.Literal("warning", "critical");
+var GuardrailSchema = S8.Struct({
+  id: S8.String,
+  createdAt: S8.String,
+  iteration: S8.Number,
+  pattern: S8.String,
+  sign: S8.String,
+  avoidance: S8.String,
   severity: GuardrailSeveritySchema
 });
-var GuardrailsFileSchema = S5.Struct({
-  sessionId: S5.String,
-  createdAt: S5.String,
-  guardrails: S5.Array(GuardrailSchema)
+var GuardrailsFileSchema = S8.Struct({
+  sessionId: S8.String,
+  createdAt: S8.String,
+  guardrails: S8.Array(GuardrailSchema)
 });
-var decodeGuardrail = S5.decodeUnknown(GuardrailSchema);
-var decodeGuardrailsFile = S5.decodeUnknown(GuardrailsFileSchema);
+var decodeGuardrail = S8.decodeUnknown(GuardrailSchema);
+var decodeGuardrailsFile = S8.decodeUnknown(GuardrailsFileSchema);
 
 // src/domain/schemas/llm.ts
 init_esm_shims();
-import { Schema as S6 } from "effect";
-var TextEventSchema = S6.TaggedStruct("Text", {
-  text: S6.String
+import { Either as Either3, Schema as S9 } from "effect";
+var TextEventSchema = S9.TaggedStruct("Text", {
+  text: S9.String
+});
+var ToolStartEventSchema = S9.TaggedStruct("ToolStart", {
+  tool: S9.String
 });
-var ToolStartEventSchema = S6.TaggedStruct("ToolStart", {
-  tool: S6.String
+var ToolUseEventSchema = S9.TaggedStruct("ToolUse", {
+  tool: S9.String,
+  input: S9.Unknown
 });
-var ToolUseEventSchema = S6.TaggedStruct("ToolUse", {
-  tool: S6.String,
-  input: S6.Unknown
+var ValidatedToolUseEventSchema = S9.TaggedStruct("ToolUse", {
+  tool: S9.String,
+  input: AnyToolInputSchema
 });
-var ToolEndEventSchema = S6.TaggedStruct("ToolEnd", {
-  tool: S6.String
+var ToolEndEventSchema = S9.TaggedStruct("ToolEnd", {
+  tool: S9.String
 });
-var DoneEventSchema = S6.TaggedStruct("Done", {
-  output: S6.String
+var DoneEventSchema = S9.TaggedStruct("Done", {
+  output: S9.String
 });
-var LLMEventSchema = S6.Union(
+var LLMEventSchema = S9.Union(
   TextEventSchema,
   ToolStartEventSchema,
   ToolUseEventSchema,
   ToolEndEventSchema,
   DoneEventSchema
 );
-var decodeLLMEvent = S6.decodeUnknown(LLMEventSchema);
+var decodeLLMEvent = S9.decodeUnknown(LLMEventSchema);
+function validateToolUseEvent(event) {
+  const validatedInput = validateToolInput(event.tool, event.input);
+  return Either3.map(validatedInput, (input) => ({
+    ...event,
+    input
+  }));
+}
 
 // src/domain/schemas/logger.ts
 init_esm_shims();
-import { Schema as S7 } from "effect";
-var LogLevelSchema = S7.Literal("debug", "info", "warn", "error");
-var LogEntrySchema = S7.Struct({
+import { Schema as S10 } from "effect";
+var LogLevelSchema = S10.Literal("debug", "info", "warn", "error");
+var LogEntrySchema = S10.Struct({
   level: LogLevelSchema,
-  message: S7.String,
-  timestamp: S7.String,
-  context: S7.optional(S7.Record({ key: S7.String, value: S7.Unknown }))
+  message: S10.String,
+  timestamp: S10.String,
+  context: S10.optional(S10.Record({ key: S10.String, value: S10.Unknown }))
 });
-var ConsoleLoggerConfigSchema = S7.Struct({
-  level: S7.optional(LogLevelSchema),
-  colors: S7.optional(S7.Boolean)
+var ConsoleLoggerConfigSchema = S10.Struct({
+  level: S10.optional(LogLevelSchema),
+  colors: S10.optional(S10.Boolean)
 });
-var FileLoggerConfigSchema = S7.Struct({
-  path: S7.optional(S7.String),
-  level: S7.optional(LogLevelSchema)
+var FileLoggerConfigSchema = S10.Struct({
+  path: S10.optional(S10.String),
+  level: S10.optional(LogLevelSchema)
 });
 
 // src/domain/schemas/program.ts
 init_esm_shims();
-import { Schema as S8 } from "effect";
-var ConsumerTypeSchema = S8.Literal("tui", "headless", "none");
-var RunOptionsDataSchema = S8.Struct({
+import { Schema as S11 } from "effect";
+var ConsumerTypeSchema = S11.Literal("tui", "headless", "none");
+var RunOptionsDataSchema = S11.Struct({
   config: LoopConfigSchema,
-  consumer: S8.optional(ConsumerTypeSchema)
+  consumer: S11.optional(ConsumerTypeSchema)
 });
 
 // src/domain/schemas/progress.ts
 init_esm_shims();
-import { Schema as S9 } from "effect";
-var ProgressActionSchema = S9.Literal(
+import { Schema as S12 } from "effect";
+var ProgressActionSchema = S12.Literal(
   "started",
   "completed",
   "failed",
   "learning"
 );
-var ProgressEntrySchema = S9.Struct({
-  iteration: S9.Number,
-  timestamp: S9.String,
-  taskId: S9.String,
+var ProgressEntrySchema = S12.Struct({
+  iteration: S12.Number,
+  timestamp: S12.String,
+  taskId: S12.String,
   action: ProgressActionSchema,
-  summary: S9.String,
-  learnings: S9.optional(S9.Array(S9.String)),
-  filesModified: S9.optional(S9.Array(S9.String))
+  summary: S12.String,
+  learnings: S12.optional(S12.Array(S12.String)),
+  filesModified: S12.optional(S12.Array(S12.String))
 });
-var ProgressFileSchema = S9.Struct({
-  sessionId: S9.String,
-  createdAt: S9.String,
-  entries: S9.Array(ProgressEntrySchema)
+var ProgressFileSchema = S12.Struct({
+  sessionId: S12.String,
+  createdAt: S12.String,
+  entries: S12.Array(ProgressEntrySchema)
 });
-var decodeProgressEntry = S9.decodeUnknown(ProgressEntrySchema);
-var decodeProgressFile = S9.decodeUnknown(ProgressFileSchema);
+var decodeProgressEntry = S12.decodeUnknown(ProgressEntrySchema);
+var decodeProgressFile = S12.decodeUnknown(ProgressFileSchema);
 
 // src/domain/schemas/session.ts
 init_esm_shims();
-import { Schema as S10 } from "effect";
-var SessionStatusSchema = S10.Literal(
+import { Schema as S13 } from "effect";
+var SessionStatusSchema = S13.Literal(
   "active",
   "completed",
   "failed",
   "paused"
 );
-var SessionSchema = S10.Struct({
-  id: S10.String,
-  createdAt: S10.String,
+var SessionSchema = S13.Struct({
+  id: S13.String,
+  createdAt: S13.String,
   status: SessionStatusSchema,
-  originalTask: S10.String,
-  completedTasks: S10.Array(S10.String),
-  currentTaskId: S10.optional(S10.String),
-  worktreePath: S10.optional(S10.String),
-  branchName: S10.optional(S10.String)
+  originalTask: S13.String,
+  completedTasks: S13.Array(S13.String),
+  currentTaskId: S13.optional(S13.String),
+  worktreePath: S13.optional(S13.String),
+  branchName: S13.optional(S13.String),
+  /** Task-based descriptive name (kebab-case slug, e.g., "add-dark-mode-toggle") */
+  displayName: S13.optional(S13.String)
 });
-var decodeSession = S10.decodeUnknown(SessionSchema);
+var decodeSession = S13.decodeUnknown(SessionSchema);
+
+// src/domain/schemas/signal-factories.ts
+init_esm_shims();
+import { Schema as S15 } from "effect";
 
 // src/domain/schemas/signals.ts
 init_esm_shims();
-import { Schema as S11 } from "effect";
-var taggedFromData2 = (tag, dataSchema) => S11.TaggedStruct(tag, dataSchema.fields);
+import { Schema as S14 } from "effect";
+var taggedFromData2 = (tag, dataSchema) => S14.TaggedStruct(tag, dataSchema.fields);
 var TasksDefinedSignalSchema = taggedFromData2(
   "TasksDefined",
   TasksDefinedDataSchema
@@ -3261,8 +3685,8 @@ var CriterionFailedSignalSchema = taggedFromData2(
   "CriterionFailed",
   CriterionFailedDataSchema
 );
-var CheckPassedSignalSchema = S11.TaggedStruct("CheckPassed", {});
-var CheckFailedSignalSchema = S11.TaggedStruct("CheckFailed", {});
+var CheckPassedSignalSchema = S14.TaggedStruct("CheckPassed", {});
+var CheckFailedSignalSchema = S14.TaggedStruct("CheckFailed", {});
 var ReviewCompleteSignalSchema = taggedFromData2(
   "ReviewComplete",
   ReviewCompleteDataSchema
@@ -3271,23 +3695,30 @@ var TaskCompleteSignalSchema = taggedFromData2(
   "TaskComplete",
   TaskCompleteSignalDataSchema
 );
-var LoopCompleteSignalSchema = S11.TaggedStruct("LoopComplete", {});
-var LearningCategorySchema = S11.Literal(
+var LoopCompleteSignalSchema = S14.TaggedStruct("LoopComplete", {});
+var SessionNameDefinedSignalSchema = S14.TaggedStruct(
+  "SessionNameDefined",
+  {
+    /** Kebab-case slug, e.g., "add-dark-mode-toggle" */
+    name: S14.String
+  }
+);
+var LearningCategorySchema = S14.Literal(
   "success",
   "failure",
   "optimization"
 );
-var LearningSignalSchema = S11.TaggedStruct("Learning", {
-  content: S11.String,
-  category: S11.optional(LearningCategorySchema)
+var LearningSignalSchema = S14.TaggedStruct("Learning", {
+  content: S14.String,
+  category: S14.optional(LearningCategorySchema)
 });
-var GuardrailSignalSchema = S11.TaggedStruct("Guardrail", {
-  pattern: S11.String,
-  sign: S11.String,
-  avoidance: S11.String,
-  severity: S11.Literal("warning", "critical")
+var GuardrailSignalSchema = S14.TaggedStruct("Guardrail", {
+  pattern: S14.String,
+  sign: S14.String,
+  avoidance: S14.String,
+  severity: S14.Literal("warning", "critical")
 });
-var SignalSchema = S11.Union(
+var SignalSchema = S14.Union(
   TasksDefinedSignalSchema,
   PhasesDefinedSignalSchema,
   CriteriaDefinedSignalSchema,
@@ -3302,26 +3733,133 @@ var SignalSchema = S11.Union(
   TaskCompleteSignalSchema,
   LoopCompleteSignalSchema,
   LearningSignalSchema,
-  GuardrailSignalSchema
+  GuardrailSignalSchema,
+  SessionNameDefinedSignalSchema
 );
-var decodeSignal = S11.decodeUnknown(SignalSchema);
-var decodeSignalSync = S11.decodeUnknownSync(SignalSchema);
+var decodeSignal = S14.decodeUnknown(SignalSchema);
+var decodeSignalSync = S14.decodeUnknownSync(SignalSchema);
+
+// src/domain/schemas/signal-factories.ts
+function createTasksDefinedSignal(input) {
+  return S15.decodeUnknownEither(TasksDefinedSignalSchema)({
+    _tag: "TasksDefined",
+    tasks: input.tasks
+  });
+}
+function createPhasesDefinedSignal(input) {
+  return S15.decodeUnknownEither(PhasesDefinedSignalSchema)({
+    _tag: "PhasesDefined",
+    taskId: input.taskId,
+    phases: input.phases
+  });
+}
+function createCriteriaDefinedSignal(input) {
+  return S15.decodeUnknownEither(CriteriaDefinedSignalSchema)({
+    _tag: "CriteriaDefined",
+    taskId: input.taskId,
+    criteria: input.criteria
+  });
+}
+function createPhaseStartedSignal(input) {
+  return S15.decodeUnknownEither(PhaseStartedSignalSchema)({
+    _tag: "PhaseStarted",
+    phaseId: input.phaseId
+  });
+}
+function createPhaseCompletedSignal(input) {
+  return S15.decodeUnknownEither(PhaseCompletedSignalSchema)({
+    _tag: "PhaseCompleted",
+    phaseId: input.phaseId
+  });
+}
+function createPhaseFailedSignal(input) {
+  return S15.decodeUnknownEither(PhaseFailedSignalSchema)({
+    _tag: "PhaseFailed",
+    phaseId: input.phaseId,
+    reason: input.reason
+  });
+}
+function createCriterionPassedSignal(input) {
+  return S15.decodeUnknownEither(CriterionPassedSignalSchema)({
+    _tag: "CriterionPassed",
+    criterionId: input.criterionId
+  });
+}
+function createCriterionFailedSignal(input) {
+  return S15.decodeUnknownEither(CriterionFailedSignalSchema)({
+    _tag: "CriterionFailed",
+    criterionId: input.criterionId,
+    reason: input.reason
+  });
+}
+function createCheckPassedSignal(_input) {
+  return S15.decodeUnknownEither(CheckPassedSignalSchema)({
+    _tag: "CheckPassed"
+  });
+}
+function createCheckFailedSignal(_input) {
+  return S15.decodeUnknownEither(CheckFailedSignalSchema)({
+    _tag: "CheckFailed"
+  });
+}
+function createReviewCompleteSignal(input) {
+  return S15.decodeUnknownEither(ReviewCompleteSignalSchema)({
+    _tag: "ReviewComplete",
+    changesMade: input.changesMade
+  });
+}
+function createTaskCompleteSignal(input) {
+  return S15.decodeUnknownEither(TaskCompleteSignalSchema)({
+    _tag: "TaskComplete",
+    taskId: input.taskId,
+    summary: input.summary,
+    filesModified: input.filesModified,
+    filesCreated: input.filesCreated
+  });
+}
+function createLoopCompleteSignal(_input) {
+  return S15.decodeUnknownEither(LoopCompleteSignalSchema)({
+    _tag: "LoopComplete"
+  });
+}
+function createLearningSignal(input) {
+  return S15.decodeUnknownEither(LearningSignalSchema)({
+    _tag: "Learning",
+    content: input.content,
+    category: input.category
+  });
+}
+function createGuardrailSignal(input) {
+  return S15.decodeUnknownEither(GuardrailSignalSchema)({
+    _tag: "Guardrail",
+    pattern: input.pattern,
+    sign: input.sign,
+    avoidance: input.avoidance,
+    severity: input.severity
+  });
+}
+function createSessionNameDefinedSignal(input) {
+  return S15.decodeUnknownEither(SessionNameDefinedSignalSchema)({
+    _tag: "SessionNameDefined",
+    name: input.name
+  });
+}
 
 // src/domain/schemas/task-generation.ts
 init_esm_shims();
-import { Schema as S12 } from "effect";
-var GeneratedTaskStatusSchema = S12.Literal(
+import { Schema as S16 } from "effect";
+var GeneratedTaskStatusSchema = S16.Literal(
   "pending",
   "in_progress",
   "done",
   "failed"
 );
-var GeneratedTaskSchema = S12.Struct({
-  id: S12.String,
-  title: S12.String,
+var GeneratedTaskSchema = S16.Struct({
+  id: S16.String,
+  title: S16.String,
   status: GeneratedTaskStatusSchema
 });
-var GeneratedTaskListSchema = S12.Array(GeneratedTaskSchema);
+var GeneratedTaskListSchema = S16.Array(GeneratedTaskSchema);
 var STATUS_ICONS = {
   done: "[x]",
   in_progress: "[~]",
@@ -3380,15 +3918,15 @@ function parseTasksMd(content) {
 
 // src/domain/schemas/tui.ts
 init_esm_shims();
-import { Schema as S13 } from "effect";
-var ViewModeSchema = S13.Literal("logs", "tasks", "detail");
-var LoopStatusSchema = S13.Literal(
+import { Schema as S17 } from "effect";
+var ViewModeSchema = S17.Literal("logs", "tasks", "detail");
+var LoopStatusSchema = S17.Literal(
   "idle",
   "running",
   "complete",
   "error"
 );
-var ExecutionModeSchema = S13.Literal(
+var ExecutionModeSchema = S17.Literal(
   "idle",
   "discovery",
   "breakdown",
@@ -3398,73 +3936,73 @@ var ExecutionModeSchema = S13.Literal(
   "verifying",
   "reviewing"
 );
-var TUIPhaseStatusSchema = S13.Literal(
+var TUIPhaseStatusSchema = S17.Literal(
   "pending",
   "in_progress",
   "done",
   "failed"
 );
-var TUICriterionStatusSchema = S13.Literal(
+var TUICriterionStatusSchema = S17.Literal(
   "pending",
   "passed",
   "failed"
 );
-var TUITaskStatusSchema = S13.Literal(
+var TUITaskStatusSchema = S17.Literal(
   "pending",
   "in_progress",
   "done",
   "failed"
 );
-var TUIPhaseSchema = S13.Struct({
-  id: S13.String,
-  description: S13.String,
+var TUIPhaseSchema = S17.Struct({
+  id: S17.String,
+  description: S17.String,
   status: TUIPhaseStatusSchema,
-  startedAt: S13.optional(S13.Number),
-  completedAt: S13.optional(S13.Number)
+  startedAt: S17.optional(S17.Number),
+  completedAt: S17.optional(S17.Number)
 });
-var TUICriterionSchema = S13.Struct({
-  id: S13.String,
-  description: S13.String,
+var TUICriterionSchema = S17.Struct({
+  id: S17.String,
+  description: S17.String,
   status: TUICriterionStatusSchema,
-  failureReason: S13.optional(S13.String)
+  failureReason: S17.optional(S17.String)
 });
-var TUITaskSchema = S13.Struct({
-  id: S13.String,
-  title: S13.String,
+var TUITaskSchema = S17.Struct({
+  id: S17.String,
+  title: S17.String,
   status: TUITaskStatusSchema,
-  phases: S13.Array(TUIPhaseSchema),
-  criteria: S13.Array(TUICriterionSchema),
-  startedAt: S13.optional(S13.Number),
-  completedAt: S13.optional(S13.Number)
+  phases: S17.Array(TUIPhaseSchema),
+  criteria: S17.Array(TUICriterionSchema),
+  startedAt: S17.optional(S17.Number),
+  completedAt: S17.optional(S17.Number)
 });
-var TUIStateSchema = S13.Struct({
+var TUIStateSchema = S17.Struct({
   // Loop info
-  task: S13.String,
-  iteration: S13.Number,
-  maxIterations: S13.Number,
+  task: S17.String,
+  iteration: S17.Number,
+  maxIterations: S17.Number,
   status: LoopStatusSchema,
-  startTime: S13.Number,
+  startTime: S17.Number,
   // Discovery phase
-  discoveryInProgress: S13.Boolean,
-  discoveryCompleted: S13.Boolean,
+  discoveryInProgress: S17.Boolean,
+  discoveryCompleted: S17.Boolean,
   // Current activity
   executionMode: ExecutionModeSchema,
-  currentTool: S13.optional(S13.String),
-  currentTaskId: S13.optional(S13.String),
+  currentTool: S17.optional(S17.String),
+  currentTaskId: S17.optional(S17.String),
   // Output
-  outputLines: S13.Array(S13.String),
-  partialLine: S13.String,
+  outputLines: S17.Array(S17.String),
+  partialLine: S17.String,
   // Tasks
-  tasks: S13.Array(TUITaskSchema),
+  tasks: S17.Array(TUITaskSchema),
   // Navigation
   viewMode: ViewModeSchema,
-  selectedTaskIndex: S13.Number,
-  scrollOffset: S13.Number,
-  userScrolled: S13.Boolean,
+  selectedTaskIndex: S17.Number,
+  scrollOffset: S17.Number,
+  userScrolled: S17.Boolean,
   // Git
-  gitBranch: S13.optional(S13.String),
-  gitPushed: S13.Boolean,
-  prUrl: S13.optional(S13.String)
+  gitBranch: S17.optional(S17.String),
+  gitPushed: S17.Boolean,
+  prUrl: S17.optional(S17.String)
 });
 
 // src/services/guardrails-store.ts
@@ -3670,7 +4208,7 @@ var MemoryGuardrails = {
 
 // src/layers/llm/mock.ts
 init_esm_shims();
-import { Effect as Effect8, Layer as Layer5, Schema as S14, Stream as Stream4 } from "effect";
+import { Effect as Effect8, Layer as Layer5, Schema as S18, Stream as Stream4 } from "effect";
 
 // src/services/llm.ts
 init_esm_shims();
@@ -3679,9 +4217,9 @@ var LLM = class extends Context3.Tag("@ferix/LLM")() {
 };
 
 // src/layers/llm/mock.ts
-var MockLLMConfigSchema = S14.Struct({
-  events: S14.Array(LLMEventSchema),
-  delayMs: S14.optional(S14.Number)
+var MockLLMConfigSchema = S18.Struct({
+  events: S18.Array(LLMEventSchema),
+  delayMs: S18.optional(S18.Number)
 });
 function createMockLLM(config) {
   return {
@@ -3722,7 +4260,23 @@ import { Effect as Effect11 } from "effect";
 
 // src/layers/llm/types.ts
 init_esm_shims();
-var PROVIDER_CONFIGS = {
+import { Schema as S19 } from "effect";
+var PermissionModeSchema = S19.Literal("acceptEdits", "yolo", "prompt");
+var ProviderConfigSchema = S19.Struct({
+  /** Provider name */
+  name: ProviderNameSchema,
+  /** CLI command to execute */
+  cliCommand: S19.String,
+  /** Default arguments for the CLI */
+  args: S19.Array(S19.String),
+  /** Environment variables to pass */
+  env: S19.optional(S19.Record({ key: S19.String, value: S19.String })),
+  /** Permission mode for the CLI */
+  permissions: S19.optional(PermissionModeSchema),
+  /** URL for installation instructions */
+  installUrl: S19.String
+});
+var RAW_PROVIDER_CONFIGS = {
   claude: {
     name: "claude",
     cliCommand: "claude",
@@ -3751,6 +4305,17 @@ var PROVIDER_CONFIGS = {
     installUrl: "https://opencode.ai/docs/"
   }
 };
+var ProviderConfigsSchema = S19.Record({
+  key: ProviderNameSchema,
+  value: ProviderConfigSchema
+});
+var validateProviderConfigs = () => {
+  const decoded = S19.decodeUnknownSync(ProviderConfigsSchema)(
+    RAW_PROVIDER_CONFIGS
+  );
+  return decoded;
+};
+var PROVIDER_CONFIGS = validateProviderConfigs();
 
 // src/layers/llm/providers/claude.ts
 init_esm_shims();
@@ -3796,78 +4361,57 @@ init_esm_shims();
 
 // src/layers/llm/providers/parsers/stream-json.ts
 init_esm_shims();
+import { Either as Either4 } from "effect";
 function parseJsonLine(line) {
   if (!line.startsWith("{")) {
     return null;
   }
-  try {
-    return JSON.parse(line);
-  } catch {
-    return null;
-  }
-}
-function isTextContent(json) {
-  return typeof json === "object" && json !== null && "type" in json && typeof json.type === "string";
-}
-function isToolUse(json) {
-  return typeof json === "object" && json !== null && "type" in json && "content_block" in json;
+  return Either4.getOrNull(
+    Either4.try({ try: () => JSON.parse(line), catch: () => null })
+  );
 }
 function extractText(json) {
-  if (!isTextContent(json)) {
-    return null;
-  }
-  if (json.type === "content_block_delta") {
-    const delta = json;
-    if (delta.delta?.type === "text_delta" && delta.delta.text) {
-      return delta.delta.text;
-    }
+  if (isContentBlockDelta(json) && isTextDelta(json.delta)) {
+    return json.delta.text;
   }
-  if (json.type === "assistant" && json.message?.content) {
+  if (isAssistantMessage(json)) {
     for (const block of json.message.content) {
-      if (block.type === "text" && block.text) {
+      if (isTextContentBlock(block)) {
         return block.text;
       }
     }
   }
   return null;
 }
-function isToolInputDelta(json) {
-  return typeof json === "object" && json !== null && "type" in json && json.type === "content_block_delta" && "delta" in json;
-}
 function extractToolInfo(json) {
-  if (typeof json === "object" && json !== null && "type" in json && json.type === "content_block_stop") {
+  if (isContentBlockStop(json)) {
     return {
       type: "end",
       name: "unknown"
     };
   }
-  if (!isToolUse(json)) {
-    if (isToolInputDelta(json) && json.delta?.type === "input_json_delta" && json.delta.partial_json) {
-      return {
-        type: "input_delta",
-        name: "",
-        partialJson: json.delta.partial_json
-      };
-    }
-    return null;
-  }
-  if (json.type === "content_block_start" && json.content_block?.type === "tool_use") {
+  if (isContentBlockStart(json) && isToolUseContentBlock(json.content_block)) {
     return {
       type: "start",
-      name: json.content_block.name || "unknown"
+      name: json.content_block.name
+    };
+  }
+  if (isContentBlockDelta(json) && isInputJsonDelta(json.delta)) {
+    return {
+      type: "input_delta",
+      name: "",
+      partialJson: json.delta.partial_json
     };
   }
   return null;
 }
 function safeParseJson(jsonStr) {
-  try {
-    return JSON.parse(jsonStr);
-  } catch {
-    return null;
-  }
+  return Either4.getOrNull(
+    Either4.try({ try: () => JSON.parse(jsonStr), catch: () => null })
+  );
 }
 function unwrapStreamEvent(json) {
-  if (typeof json === "object" && json !== null && "type" in json && json.type === "stream_event" && "event" in json) {
+  if (isStreamEventEnvelope(json)) {
     return json.event;
   }
   return json;
@@ -4008,50 +4552,26 @@ init_esm_shims();
 
 // src/layers/llm/providers/parsers/opencode.ts
 init_esm_shims();
+import { Either as Either5 } from "effect";
 function parseJsonLine2(line) {
   if (!line.startsWith("{")) {
     return null;
   }
-  try {
-    return JSON.parse(line);
-  } catch {
-    return null;
-  }
-}
-function isTextContent2(json) {
-  return typeof json === "object" && json !== null && "type" in json && json.type === "text" && "text" in json && typeof json.text === "string";
+  return Either5.getOrNull(
+    Either5.try({ try: () => JSON.parse(line), catch: () => null })
+  );
 }
 function isStepFinish(json) {
-  return typeof json === "object" && json !== null && "type" in json && json.type === "step_finish";
-}
-function isToolUse2(json) {
-  if (typeof json !== "object" || json === null) {
-    return false;
-  }
-  const obj = json;
-  if (obj.type !== "tool_use") {
-    return false;
-  }
-  if (typeof obj.part !== "object" || obj.part === null) {
-    return false;
-  }
-  const part = obj.part;
-  if (typeof part.tool !== "string") {
-    return false;
-  }
-  if (typeof part.state !== "object" || part.state === null) {
-    return false;
-  }
-  return true;
+  return isOpenCodeStepFinish(json);
 }
 function extractText2(json) {
-  if (isTextContent2(json)) {
+  if (isOpenCodeTextEvent(json)) {
     return json.text;
   }
   return null;
 }
 function extractToolInfo2(json) {
-  if (isToolUse2(json)) {
+  if (isOpenCodeToolUseEvent(json)) {
     return {
       type: "complete",
       name: json.part.tool,
@@ -4816,7 +5336,7 @@ init_esm_shims();
 
 // src/layers/signal/specs/check.ts
 init_esm_shims();
-import { Schema as S15 } from "effect";
+import { Either as Either6 } from "effect";
 
 // src/layers/signal/specs/registry.ts
 init_esm_shims();
@@ -4872,9 +5392,8 @@ var checkPassedSpec = {
   schema: CheckPassedSignalSchema,
   parse: (text) => {
     if (CHECK_PASSED.test(text)) {
-      const raw = { _tag: "CheckPassed" };
-      const result = S15.decodeUnknownEither(CheckPassedSignalSchema)(raw);
-      if (result._tag === "Right") {
+      const result = createCheckPassedSignal({});
+      if (Either6.isRight(result)) {
         return [result.right];
       }
     }
@@ -4888,9 +5407,8 @@ var checkFailedSpec = {
   schema: CheckFailedSignalSchema,
   parse: (text) => {
     if (CHECK_FAILED.test(text)) {
-      const raw = { _tag: "CheckFailed" };
-      const result = S15.decodeUnknownEither(CheckFailedSignalSchema)(raw);
-      if (result._tag === "Right") {
+      const result = createCheckFailedSignal({});
+      if (Either6.isRight(result)) {
         return [result.right];
       }
     }
@@ -4903,7 +5421,7 @@ signalSpecRegistry.register(checkFailedSpec);
 
 // src/layers/signal/specs/criteria.ts
 init_esm_shims();
-import { Schema as S16 } from "effect";
+import { Either as Either7 } 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;
@@ -4929,13 +5447,11 @@ var criteriaDefinedSpec = {
         }
       }
       if (criteria.length > 0) {
-        const raw = {
-          _tag: "CriteriaDefined",
+        const result = createCriteriaDefinedSignal({
           taskId: match[1],
           criteria
-        };
-        const result = S16.decodeUnknownEither(CriteriaDefinedSignalSchema)(raw);
-        if (result._tag === "Right") {
+        });
+        if (Either7.isRight(result)) {
           signals.push(result.right);
         }
       }
@@ -4952,9 +5468,8 @@ var criterionPassedSpec = {
     const signals = [];
     for (const m of text.matchAll(resetRegex(CRITERION_PASSED))) {
       if (m[1]) {
-        const raw = { _tag: "CriterionPassed", criterionId: m[1] };
-        const result = S16.decodeUnknownEither(CriterionPassedSignalSchema)(raw);
-        if (result._tag === "Right") {
+        const result = createCriterionPassedSignal({ criterionId: m[1] });
+        if (Either7.isRight(result)) {
           signals.push(result.right);
         }
       }
@@ -4971,13 +5486,11 @@ var criterionFailedSpec = {
     const signals = [];
     for (const m of text.matchAll(resetRegex(CRITERION_FAILED))) {
       if (m[1]) {
-        const raw = {
-          _tag: "CriterionFailed",
+        const result = createCriterionFailedSignal({
           criterionId: m[1],
           reason: m[2] || "Unknown reason"
-        };
-        const result = S16.decodeUnknownEither(CriterionFailedSignalSchema)(raw);
-        if (result._tag === "Right") {
+        });
+        if (Either7.isRight(result)) {
           signals.push(result.right);
         }
       }
@@ -4992,7 +5505,7 @@ signalSpecRegistry.register(criterionFailedSpec);
 
 // src/layers/signal/specs/guardrail.ts
 init_esm_shims();
-import { Schema as S17 } from "effect";
+import { Either as Either8 } 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>/;
@@ -5016,15 +5529,13 @@ var guardrailSpec = {
       if (!(pattern && sign && avoidance)) {
         continue;
       }
-      const raw = {
-        _tag: "Guardrail",
+      const result = createGuardrailSignal({
         pattern,
         sign,
         avoidance,
         severity
-      };
-      const result = S17.decodeUnknownEither(GuardrailSignalSchema)(raw);
-      if (result._tag === "Right") {
+      });
+      if (Either8.isRight(result)) {
         signals.push(result.right);
       }
     }
@@ -5036,7 +5547,7 @@ signalSpecRegistry.register(guardrailSpec);
 
 // src/layers/signal/specs/learning.ts
 init_esm_shims();
-import { Schema as S18 } from "effect";
+import { Either as Either9 } from "effect";
 var LEARNING = /<ferix:learning(?:\s+category="(success|failure|optimization)")?\s*>([\s\S]*?)<\/ferix:learning>/g;
 var learningSpec = {
   tag: "Learning",
@@ -5051,15 +5562,8 @@ var learningSpec = {
       if (!content) {
         continue;
       }
-      const raw = {
-        _tag: "Learning",
-        content
-      };
-      if (category) {
-        raw.category = category;
-      }
-      const result = S18.decodeUnknownEither(LearningSignalSchema)(raw);
-      if (result._tag === "Right") {
+      const result = createLearningSignal({ content, category });
+      if (Either9.isRight(result)) {
         signals.push(result.right);
       }
     }
@@ -5071,7 +5575,7 @@ signalSpecRegistry.register(learningSpec);
 
 // src/layers/signal/specs/loop-complete.ts
 init_esm_shims();
-import { Schema as S19 } from "effect";
+import { Schema as S20 } from "effect";
 var LOOP_COMPLETE = /<ferix:complete>/;
 var loopCompleteSpec = {
   tag: "LoopComplete",
@@ -5080,7 +5584,7 @@ var loopCompleteSpec = {
   parse: (text) => {
     if (LOOP_COMPLETE.test(text)) {
       const raw = { _tag: "LoopComplete" };
-      const result = S19.decodeUnknownEither(LoopCompleteSignalSchema)(raw);
+      const result = S20.decodeUnknownEither(LoopCompleteSignalSchema)(raw);
       if (result._tag === "Right") {
         return [result.right];
       }
@@ -5093,7 +5597,7 @@ signalSpecRegistry.register(loopCompleteSpec);
 
 // src/layers/signal/specs/phases.ts
 init_esm_shims();
-import { Schema as S20 } from "effect";
+import { Either as Either10 } 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;
@@ -5121,16 +5625,11 @@ var phasesDefinedSpec = {
     if (phases.length === 0) {
       return [];
     }
-    const raw = {
-      _tag: "PhasesDefined",
-      taskId: match[1],
-      phases
-    };
-    const result = S20.decodeUnknownEither(PhasesDefinedSignalSchema)(raw);
-    if (result._tag === "Left") {
-      return [];
+    const result = createPhasesDefinedSignal({ taskId: match[1], phases });
+    if (Either10.isRight(result)) {
+      return [result.right];
     }
-    return [result.right];
+    return [];
   },
   keyFields: (s) => `${s.taskId}:${s.phases.map((p) => p.id).join(",")}`
 };
@@ -5142,9 +5641,8 @@ var phaseStartedSpec = {
     const signals = [];
     for (const m of text.matchAll(resetRegex2(PHASE_START))) {
       if (m[1]) {
-        const raw = { _tag: "PhaseStarted", phaseId: m[1] };
-        const result = S20.decodeUnknownEither(PhaseStartedSignalSchema)(raw);
-        if (result._tag === "Right") {
+        const result = createPhaseStartedSignal({ phaseId: m[1] });
+        if (Either10.isRight(result)) {
           signals.push(result.right);
         }
       }
@@ -5161,9 +5659,8 @@ var phaseCompletedSpec = {
     const signals = [];
     for (const m of text.matchAll(resetRegex2(PHASE_DONE))) {
       if (m[1]) {
-        const raw = { _tag: "PhaseCompleted", phaseId: m[1] };
-        const result = S20.decodeUnknownEither(PhaseCompletedSignalSchema)(raw);
-        if (result._tag === "Right") {
+        const result = createPhaseCompletedSignal({ phaseId: m[1] });
+        if (Either10.isRight(result)) {
           signals.push(result.right);
         }
       }
@@ -5180,13 +5677,11 @@ var phaseFailedSpec = {
     const signals = [];
     for (const m of text.matchAll(resetRegex2(PHASE_FAILED))) {
       if (m[1]) {
-        const raw = {
-          _tag: "PhaseFailed",
+        const result = createPhaseFailedSignal({
           phaseId: m[1],
           reason: m[2] || "Unknown reason"
-        };
-        const result = S20.decodeUnknownEither(PhaseFailedSignalSchema)(raw);
-        if (result._tag === "Right") {
+        });
+        if (Either10.isRight(result)) {
           signals.push(result.right);
         }
       }
@@ -5225,6 +5720,37 @@ var reviewCompleteSpec = {
 };
 signalSpecRegistry.register(reviewCompleteSpec);
 
+// src/layers/signal/specs/session-name.ts
+init_esm_shims();
+import { Either as Either11 } 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, "");
+}
+var sessionNameSpec = {
+  tag: "SessionNameDefined",
+  closingTag: "</ferix:session-name>",
+  schema: SessionNameDefinedSignalSchema,
+  parse: (text) => {
+    const signals = [];
+    const matches = text.matchAll(SESSION_NAME);
+    for (const match of matches) {
+      const rawName = match[1] || "";
+      const name = sanitizeSessionName(rawName);
+      if (!name) {
+        continue;
+      }
+      const result = createSessionNameDefinedSignal({ name });
+      if (Either11.isRight(result)) {
+        signals.push(result.right);
+      }
+    }
+    return signals;
+  },
+  keyFields: (s) => s.name
+};
+signalSpecRegistry.register(sessionNameSpec);
+
 // src/layers/signal/specs/task-complete.ts
 init_esm_shims();
 import { Schema as S22 } from "effect";
@@ -5270,7 +5796,7 @@ signalSpecRegistry.register(taskCompleteSpec);
 
 // src/layers/signal/specs/tasks.ts
 init_esm_shims();
-import { Schema as S23 } from "effect";
+import { Either as Either12 } from "effect";
 var TASKS_BLOCK = /<ferix:tasks>([\s\S]*?)<\/ferix:tasks>/;
 var TASK = /<task id="(\d+)">([^<]+)<\/task>/g;
 function resetRegex3(pattern) {
@@ -5299,12 +5825,11 @@ var tasksDefinedSpec = {
     if (tasks.length === 0) {
       return [];
     }
-    const raw = { _tag: "TasksDefined", tasks };
-    const result = S23.decodeUnknownEither(TasksDefinedSignalSchema)(raw);
-    if (result._tag === "Left") {
-      return [];
+    const result = createTasksDefinedSignal({ tasks });
+    if (Either12.isRight(result)) {
+      return [result.right];
     }
-    return [result.right];
+    return [];
   },
   keyFields: (s) => s.tasks.map((t) => t.id).join(",")
 };
@@ -5621,6 +6146,16 @@ eventMappingRegistry.registerSignalMapper({
     timestamp: context.timestamp
   })
 });
+eventMappingRegistry.registerSignalMapper({
+  tag: "SessionNameDefined",
+  map: (signal, context) => ({
+    _tag: "SessionNameGenerated",
+    sessionId: "",
+    // Will be overwritten by discovery stream
+    displayName: signal.name,
+    timestamp: context.timestamp
+  })
+});
 
 // src/orchestrator/mapping/index.ts
 function mapLLMEventToDomain(event, context) {
@@ -6057,19 +6592,44 @@ After completing a single task, emit <ferix:task-complete> and continue to the n
 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 analyze the task and break it into logical subtasks.
+Your goal is to:
+1. Generate a short, descriptive name for this session
+2. Analyze the task and break it into logical subtasks
 
-Your output must include a <ferix:tasks> signal that the orchestrator will parse.
-This signal MUST appear on its own line, not inside code blocks.
+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>
 
-IMPORTANT: Always emit the <ferix:tasks> signal on its own line, never inside markdown code blocks.`;
+## 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.
@@ -6188,17 +6748,26 @@ ${config.prompts.additionalContext}`
 ${config.task}`);
   sections.push(`## Instructions
 
-Analyze the task above and break it into logical subtasks.
+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>
 
-1. Read and understand what needs to be done
-2. Identify the main components or steps
-3. Break the work into 2-6 discrete tasks
+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>
 
-Emit a <ferix:tasks> block with your task breakdown.
 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");
@@ -6311,7 +6880,7 @@ function planTasksToGeneratedTasks(plan) {
     status: mapTaskStatus(task.status)
   }));
 }
-function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, config, sessionId, worktreePath) {
+function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, config, sessionId, worktreePath, onSessionName) {
   return Stream7.unwrap(
     Effect21.gen(function* () {
       const startTimeUtc = yield* DateTime8.now;
@@ -6320,6 +6889,7 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
         dirty: false,
         pendingOperation: null
       });
+      const sessionNameRef = yield* Ref10.make(void 0);
       const discoveryStarted = {
         _tag: "DiscoveryStarted",
         timestamp: startTime
@@ -6352,6 +6922,9 @@ 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);
+                }
                 const planEvents = yield* updatePlanFromSignal(
                   currentPlanRef,
                   persistenceStateRef,
@@ -6398,12 +6971,38 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
           }
           const endTimeUtc = yield* DateTime8.now;
           const endTime = DateTime8.toEpochMillis(endTimeUtc);
+          const events = [...persistEvents];
+          const capturedName = yield* Ref10.get(sessionNameRef);
+          if (capturedName) {
+            if (onSessionName) {
+              yield* onSessionName(capturedName).pipe(
+                Effect21.tapError(
+                  (error) => Effect21.logDebug(
+                    "Failed to handle session name, continuing",
+                    {
+                      error: String(error),
+                      displayName: capturedName
+                    }
+                  )
+                ),
+                Effect21.orElseSucceed(() => void 0)
+              );
+            }
+            const sessionNameEvent = {
+              _tag: "SessionNameGenerated",
+              sessionId,
+              displayName: capturedName,
+              timestamp: endTime
+            };
+            events.push(sessionNameEvent);
+          }
           const discoveryCompleted = {
             _tag: "DiscoveryCompleted",
             taskCount,
             timestamp: endTime
           };
-          return [...persistEvents, discoveryCompleted];
+          events.push(discoveryCompleted);
+          return events;
         })
       ).pipe(Stream7.flatMap((events) => Stream7.fromIterable(events)));
       return pipe(
@@ -6617,12 +7216,27 @@ function runLoop(config) {
       };
       const loopCompletedRef = yield* Ref12.make(false);
       const currentPlanRef = yield* Ref12.make(void 0);
+      const sessionRef = yield* Ref12.make(session);
       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 newBranchName = yield* git.renameBranch(
+          session.id,
+          displayName
+        );
+        const updatedSession = {
+          ...currentSession,
+          displayName,
+          branchName: newBranchName
+        };
+        yield* sessionStore.update(session.id, updatedSession);
+        yield* Ref12.set(sessionRef, updatedSession);
+      });
       const discoveryStream = createDiscoveryStream(
         llm,
         signalParser,
@@ -6630,7 +7244,8 @@ function runLoop(config) {
         currentPlanRef,
         config,
         session.id,
-        worktreePath
+        worktreePath,
+        handleSessionName
       );
       const iterationsStream = Stream9.unfoldEffect(
         1,
@@ -6692,7 +7307,8 @@ function createCompletionStream(sessionStore, git, session, config, startTime, l
   return Stream9.unwrap(
     Effect23.gen(function* () {
       const endTimeUtc = yield* DateTime10.now;
-      const durationMs = DateTime10.toEpochMillis(endTimeUtc) - startTime;
+      const endTime = DateTime10.toEpochMillis(endTimeUtc);
+      const durationMs = endTime - startTime;
       const completed = yield* Ref12.get(loopCompletedRef);
       yield* git.commitChanges(session.id, `feat: complete session ${session.id}`).pipe(
         Effect23.tapError(
@@ -6703,6 +7319,20 @@ function createCompletionStream(sessionStore, git, session, config, startTime, l
         ),
         Effect23.orElseSucceed(() => void 0)
       );
+      yield* git.removeWorktreeKeepBranch(session.id).pipe(
+        Effect23.tapError(
+          (error) => Effect23.logDebug("Worktree cleanup failed, continuing", {
+            sessionId: session.id,
+            error: String(error)
+          })
+        ),
+        Effect23.orElseSucceed(() => void 0)
+      );
+      const worktreeRemoved = {
+        _tag: "WorktreeRemoved",
+        sessionId: session.id,
+        timestamp: endTime
+      };
       const summary = {
         iterations: config.maxIterations,
         success: completed,
@@ -6712,7 +7342,8 @@ function createCompletionStream(sessionStore, git, session, config, startTime, l
       };
       yield* sessionStore.update(session.id, {
         ...session,
-        status: completed ? "completed" : "paused"
+        status: completed ? "completed" : "paused",
+        worktreePath: void 0
       }).pipe(
         Effect23.tapError(
           (error) => Effect23.logDebug("Session update failed, continuing", {
@@ -6723,7 +7354,10 @@ function createCompletionStream(sessionStore, git, session, config, startTime, l
         Effect23.orElseSucceed(() => void 0)
       );
       const loopCompleted = { _tag: "LoopCompleted", summary };
-      return Stream9.succeed(loopCompleted);
+      return pipe3(
+        Stream9.succeed(worktreeRemoved),
+        Stream9.concat(Stream9.succeed(loopCompleted))
+      );
     })
   );
 }
@@ -6783,13 +7417,21 @@ program.name("ferix-code").description("Composable RALPH loops for AI coding age
 });
 program.parse();
 export {
+  AnyToolInputSchema,
+  AssistantMessageSchema,
+  BashToolInputSchema,
   CheckFailedEventSchema,
   CheckFailedSignalSchema,
   CheckPassedEventSchema,
   CheckPassedSignalSchema,
   ClaudeCLI,
+  ClaudeCliEventSchema,
   ConsoleLoggerConfigSchema,
   ConsumerTypeSchema,
+  ContentBlockDeltaSchema,
+  ContentBlockSchema,
+  ContentBlockStartSchema,
+  ContentBlockStopSchema,
   CriteriaDefinedDataSchema,
   CriteriaDefinedEventSchema,
   CriteriaDefinedSignalSchema,
@@ -6803,11 +7445,13 @@ export {
   CriterionSchema,
   CriterionStatusSchema,
   CursorCLI,
+  DeltaSchema,
   DiscoveryCompletedEventSchema,
   DiscoveryStartedEventSchema,
   DomainEventSchema,
   DomainEventUtils,
   DoneEventSchema,
+  EditToolInputSchema,
   ExecutionModeSchema,
   FerixParser,
   FileLoggerConfigSchema,
@@ -6821,6 +7465,8 @@ export {
   GeneratedTaskStatusSchema,
   Git,
   GitError,
+  GlobToolInputSchema,
+  GrepToolInputSchema,
   GuardrailAddedEventSchema,
   GuardrailSchema,
   GuardrailSeveritySchema,
@@ -6828,6 +7474,7 @@ export {
   GuardrailsFileSchema,
   GuardrailsStore,
   GuardrailsStoreError,
+  InputJsonDeltaSchema,
   IterationCompletedEventSchema,
   IterationStartedEventSchema,
   LLM,
@@ -6857,6 +7504,16 @@ export {
   MemorySession,
   Mock,
   Mock as MockLLM,
+  OpenCodeCliEventSchema,
+  OpenCodeCostSchema,
+  OpenCodeStepFinishSchema,
+  OpenCodeStepPartSchema,
+  OpenCodeStepStartSchema,
+  OpenCodeTextEventSchema,
+  OpenCodeTokensSchema,
+  OpenCodeToolPartSchema,
+  OpenCodeToolStateSchema,
+  OpenCodeToolUseEventSchema,
   OrchestratorError,
   PROVIDER_CONFIGS,
   ParseError,
@@ -6892,16 +7549,20 @@ export {
   ProgressUpdatedEventSchema,
   PromptConfigSchema,
   ProviderNameSchema,
+  ReadToolInputSchema,
   ReviewCompleteDataSchema,
   ReviewCompleteEventSchema,
   ReviewCompleteSignalSchema,
   RunOptionsDataSchema,
+  SessionNameDefinedSignalSchema,
+  SessionNameGeneratedEventSchema,
   SessionSchema,
   SessionStatusSchema,
   SessionStore,
   SessionStoreError,
   SignalParser,
   SignalSchema,
+  StreamEventEnvelopeSchema,
   TUICriterionSchema,
   TUICriterionStatusSchema,
   TUIPhaseSchema,
@@ -6916,28 +7577,57 @@ export {
   TaskCompletedEventSchema,
   TaskSchema,
   TaskStatusSchema,
+  TaskToolInputSchema,
   TasksDefinedDataSchema,
   TasksDefinedEventSchema,
   TasksDefinedSignalSchema,
   TestLayers,
+  TextContentBlockSchema,
+  TextDeltaSchema,
   TextEventSchema,
   ToolEndEventSchema,
+  ToolInputSchemaRegistry,
   ToolStartEventSchema,
+  ToolUseContentBlockSchema,
   ToolUseEventSchema,
+  ValidatedToolUseEventSchema,
   ViewModeSchema,
+  WebFetchToolInputSchema,
+  WebSearchToolInputSchema,
   WorktreeCreatedEventSchema,
   WorktreeRemovedEventSchema,
+  WriteToolInputSchema,
   buildPrompt,
   collectEvents,
+  createCheckFailedSignal,
+  createCheckPassedSignal,
+  createCriteriaDefinedSignal,
+  createCriterionFailedSignal,
+  createCriterionPassedSignal,
+  createGuardrailSignal,
   createHeadlessConsumer,
+  createLearningSignal,
+  createLoopCompleteSignal,
+  createPhaseCompletedSignal,
+  createPhaseFailedSignal,
+  createPhaseStartedSignal,
+  createPhasesDefinedSignal,
   createProductionLayers,
   createProviderLayer2 as createProviderLayer,
+  createReviewCompleteSignal,
+  createSessionNameDefinedSignal,
   createTUIConsumer,
+  createTaskCompleteSignal,
+  createTasksDefinedSignal,
   createTestLayers,
+  decodeClaudeCliEvent,
+  decodeClaudeCliEventSync,
   decodeGuardrail,
   decodeGuardrailsFile,
   decodeLLMEvent,
   decodeLoopConfig,
+  decodeOpenCodeCliEvent,
+  decodeOpenCodeCliEventSync,
   decodePlan,
   decodePlanData,
   decodeProgressEntry,
@@ -6946,9 +7636,34 @@ export {
   decodeSignal,
   decodeSignalSync,
   formatTasksMd,
+  getToolInputSchema,
+  isAssistantMessage,
+  isBashToolInput,
+  isContentBlockDelta,
+  isContentBlockStart,
+  isContentBlockStop,
+  isEditToolInput,
+  isGlobToolInput,
+  isGrepToolInput,
+  isInputJsonDelta,
+  isOpenCodeStepFinish,
+  isOpenCodeStepStart,
+  isOpenCodeTextEvent,
+  isOpenCodeToolUseEvent,
+  isReadToolInput,
+  isStreamEventEnvelope,
+  isTaskToolInput,
+  isTextContentBlock,
+  isTextDelta,
+  isToolUseContentBlock,
+  isWebFetchToolInput,
+  isWebSearchToolInput,
+  isWriteToolInput,
   main,
   parseTasksMd,
   run,
   runLoop,
-  runTest
+  runTest,
+  validateToolInput,
+  validateToolUseEvent
 };