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

package/dist/index.d.ts

@@ -96,14 +96,58 @@ declare const GitError_base: new <A extends Record<string, any> = {}>(args: effe
  */
 declare class GitError extends GitError_base<{
     readonly message: string;
-    readonly operation: "createWorktree" | "removeWorktree" | "removeWorktreeKeepBranch" | "commit" | "push" | "createPR" | "renameBranch" | "status";
+    readonly operation: "createWorktree" | "removeWorktree" | "removeWorktreeKeepBranch" | "commit" | "push" | "createPR" | "renameBranch" | "branchLookup" | "getCurrentBranch" | "status";
+    readonly cause?: unknown;
+}> {
+}
+declare const TokenBudgetError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "TokenBudgetError";
+} & Readonly<A>;
+/**
+ * Error that occurs when token budget is exceeded.
+ */
+declare class TokenBudgetError extends TokenBudgetError_base<{
+    readonly message: string;
+    /** Total tokens used */
+    readonly budgetUsed: number;
+    /** Maximum tokens available */
+    readonly budgetMax: number;
+    /** Sections that couldn't fit */
+    readonly overflowSections: readonly string[];
+}> {
+}
+declare const RetryExhaustedError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "RetryExhaustedError";
+} & Readonly<A>;
+/**
+ * Error that occurs when all retry attempts are exhausted.
+ */
+declare class RetryExhaustedError extends RetryExhaustedError_base<{
+    readonly message: string;
+    /** Number of attempts made */
+    readonly attempts: number;
+    /** The final error that caused failure */
+    readonly finalError: string;
+    /** Iteration where retries were exhausted */
+    readonly iteration: number;
+}> {
+}
+declare const MetricsError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "MetricsError";
+} & Readonly<A>;
+/**
+ * Error that occurs during metrics operations.
+ */
+declare class MetricsError extends MetricsError_base<{
+    readonly message: string;
+    readonly operation: "record" | "get" | "clear";
     readonly cause?: unknown;
 }> {
 }
 /**
  * Union of all possible errors in the system.
  */
-type FerixError = LLMError | ParseError | PlanStoreError | SessionStoreError | ProgressStoreError | GuardrailsStoreError | OrchestratorError | GitError;
+type FerixError = LLMError | ParseError | PlanStoreError | SessionStoreError | ProgressStoreError | GuardrailsStoreError | OrchestratorError | GitError | TokenBudgetError | RetryExhaustedError | MetricsError;
 
 /**
  * Text delta event - streamed text content.
@@ -699,6 +743,8 @@ declare const LoopSummarySchema: Schema.Struct<{
     sessionId: typeof Schema.String;
     completedTasks: Schema.Array$<typeof Schema.String>;
     durationMs: typeof Schema.Number;
+    branchPushed: Schema.optional<typeof Schema.Boolean>;
+    prUrl: Schema.optional<typeof Schema.String>;
 }>;
 type LoopSummary = typeof LoopSummarySchema.Type;
 declare const LoopErrorSchema: Schema.Struct<{
@@ -770,6 +816,8 @@ declare const LoopCompletedEventSchema: Schema.TaggedStruct<"LoopCompleted", {
         sessionId: typeof Schema.String;
         completedTasks: Schema.Array$<typeof Schema.String>;
         durationMs: typeof Schema.Number;
+        branchPushed: Schema.optional<typeof Schema.Boolean>;
+        prUrl: Schema.optional<typeof Schema.String>;
     }>;
 }>;
 type LoopCompletedEvent = typeof LoopCompletedEventSchema.Type;
@@ -1024,6 +1072,25 @@ declare const WorktreeRemovedEventSchema: Schema.TaggedStruct<"WorktreeRemoved",
     timestamp: typeof Schema.Number;
 }>;
 type WorktreeRemovedEvent = typeof WorktreeRemovedEventSchema.Type;
+/**
+ * Branch pushed event - signals that a branch was pushed to origin.
+ */
+declare const BranchPushedEventSchema: Schema.TaggedStruct<"BranchPushed", {
+    sessionId: typeof Schema.String;
+    branchName: typeof Schema.String;
+    timestamp: typeof Schema.Number;
+}>;
+type BranchPushedEvent = typeof BranchPushedEventSchema.Type;
+/**
+ * PR created event - signals that a pull request was created.
+ */
+declare const PRCreatedEventSchema: Schema.TaggedStruct<"PRCreated", {
+    sessionId: typeof Schema.String;
+    prUrl: typeof Schema.String;
+    title: typeof Schema.String;
+    timestamp: typeof Schema.Number;
+}>;
+type PRCreatedEvent = typeof PRCreatedEventSchema.Type;
 /**
  * Session name generated event - signals that the LLM generated a descriptive name for the session.
  * Emitted during the discovery phase after the session name signal is parsed.
@@ -1071,6 +1138,8 @@ declare const DomainEventSchema: Schema.Union<[Schema.TaggedStruct<"LoopStarted"
         sessionId: typeof Schema.String;
         completedTasks: Schema.Array$<typeof Schema.String>;
         durationMs: typeof Schema.Number;
+        branchPushed: Schema.optional<typeof Schema.Boolean>;
+        prUrl: Schema.optional<typeof Schema.String>;
     }>;
 }>, Schema.TaggedStruct<"LoopFailed", {
     error: Schema.Struct<{
@@ -1220,6 +1289,15 @@ declare const DomainEventSchema: Schema.Union<[Schema.TaggedStruct<"LoopStarted"
 }>, Schema.TaggedStruct<"WorktreeRemoved", {
     sessionId: typeof Schema.String;
     timestamp: typeof Schema.Number;
+}>, Schema.TaggedStruct<"BranchPushed", {
+    sessionId: typeof Schema.String;
+    branchName: typeof Schema.String;
+    timestamp: typeof Schema.Number;
+}>, Schema.TaggedStruct<"PRCreated", {
+    sessionId: typeof Schema.String;
+    prUrl: typeof Schema.String;
+    title: typeof Schema.String;
+    timestamp: typeof Schema.Number;
 }>, Schema.TaggedStruct<"SessionNameGenerated", {
     sessionId: typeof Schema.String;
     /** Task-based descriptive name (kebab-case slug, e.g., "add-dark-mode-toggle") */
@@ -1229,7 +1307,7 @@ declare const DomainEventSchema: Schema.Union<[Schema.TaggedStruct<"LoopStarted"
 /**
  * Explicit discriminated union type for proper TypeScript narrowing.
  */
-type DomainEvent = LoopStartedEvent | LoopCompletedEvent | LoopFailedEvent | DiscoveryStartedEvent | DiscoveryCompletedEvent | IterationStartedEvent | IterationCompletedEvent | LLMTextEvent | LLMToolStartEvent | LLMToolUseEvent | LLMToolEndEvent | TasksDefinedEvent | PhasesDefinedEvent | CriteriaDefinedEvent | PhaseStartedEvent | PhaseCompletedEvent | PhaseFailedEvent | CriterionPassedEvent | CriterionFailedEvent | CheckPassedEvent | CheckFailedEvent | ReviewCompleteEvent | TaskCompletedEvent | PlanCreatedEvent | PlanUpdatedEvent | PlanUpdateFailedEvent | LearningRecordedEvent | GuardrailAddedEvent | ProgressUpdatedEvent | WorktreeCreatedEvent | WorktreeRemovedEvent | SessionNameGeneratedEvent;
+type DomainEvent = LoopStartedEvent | LoopCompletedEvent | LoopFailedEvent | DiscoveryStartedEvent | DiscoveryCompletedEvent | IterationStartedEvent | IterationCompletedEvent | LLMTextEvent | LLMToolStartEvent | LLMToolUseEvent | LLMToolEndEvent | TasksDefinedEvent | PhasesDefinedEvent | CriteriaDefinedEvent | PhaseStartedEvent | PhaseCompletedEvent | PhaseFailedEvent | CriterionPassedEvent | CriterionFailedEvent | CheckPassedEvent | CheckFailedEvent | ReviewCompleteEvent | TaskCompletedEvent | PlanCreatedEvent | PlanUpdatedEvent | PlanUpdateFailedEvent | LearningRecordedEvent | GuardrailAddedEvent | ProgressUpdatedEvent | WorktreeCreatedEvent | WorktreeRemovedEvent | BranchPushedEvent | PRCreatedEvent | SessionNameGeneratedEvent;
 /**
  * Type guard utilities for domain events.
  */
@@ -1830,6 +1908,7 @@ declare const decodePlan: (u: unknown, overrideOptions?: effect_SchemaAST.ParseO
             readonly description: string;
         }[];
         readonly status: "planning" | "pending" | "in_progress" | "done" | "failed" | "skipped";
+        readonly attempts: number;
         readonly id: string;
         readonly description: string;
         readonly title: string;
@@ -1840,7 +1919,6 @@ declare const decodePlan: (u: unknown, overrideOptions?: effect_SchemaAST.ParseO
             readonly failureReason?: string | undefined;
         }[];
         readonly filesToModify: readonly string[];
-        readonly attempts: number;
         readonly completionNotes?: string | undefined;
     }[];
 }, effect_ParseResult.ParseError, never>;
@@ -1856,6 +1934,7 @@ declare const decodePlanData: (u: unknown, overrideOptions?: effect_SchemaAST.Pa
             readonly description: string;
         }[];
         readonly status: "planning" | "pending" | "in_progress" | "done" | "failed" | "skipped";
+        readonly attempts: number;
         readonly id: string;
         readonly description: string;
         readonly title: string;
@@ -1866,7 +1945,6 @@ declare const decodePlanData: (u: unknown, overrideOptions?: effect_SchemaAST.Pa
             readonly failureReason?: string | undefined;
         }[];
         readonly filesToModify: readonly string[];
-        readonly attempts: number;
         readonly completionNotes?: string | undefined;
     }[];
 }, effect_ParseResult.ParseError, never>;
@@ -1992,6 +2070,8 @@ declare const SessionSchema: Schema.Struct<{
     branchName: Schema.optional<typeof Schema.String>;
     /** Task-based descriptive name (kebab-case slug, e.g., "add-dark-mode-toggle") */
     displayName: Schema.optional<typeof Schema.String>;
+    /** The branch ferix was started from - used as PR base branch */
+    baseBranch: Schema.optional<typeof Schema.String>;
 }>;
 type Session = typeof SessionSchema.Type;
 /**
@@ -2007,6 +2087,7 @@ declare const decodeSession: (u: unknown, overrideOptions?: effect_SchemaAST.Par
     readonly branchName?: string | undefined;
     readonly displayName?: string | undefined;
     readonly currentTaskId?: string | undefined;
+    readonly baseBranch?: string | undefined;
 }, effect_ParseResult.ParseError, never>;
 
 /**
@@ -2926,9 +3007,18 @@ interface GitService {
      * @param sessionId - Session ID whose branch to create PR for
      * @param title - PR title
      * @param body - PR body/description
+     * @param baseBranch - Optional base branch for the PR (defaults to repo default)
      * @returns URL of the created PR
      */
-    readonly createPR: (sessionId: string, title: string, body: string) => Effect.Effect<PrUrl, GitError>;
+    readonly createPR: (sessionId: string, title: string, body: string, baseBranch?: string) => Effect.Effect<PrUrl, GitError>;
+    /**
+     * Get the current branch name of the main repository.
+     *
+     * Used to capture the base branch when starting a session.
+     *
+     * @returns The current branch name
+     */
+    readonly getCurrentBranch: () => Effect.Effect<string, GitError>;
     /**
      * Get the branch name for a session.
      *
@@ -3783,4 +3873,4 @@ declare function collectEvents(config: LoopConfig, mockEvents?: readonly LLMEven
  */
 declare function main(config: LoopConfig): Promise<void>;
 
-export { type AnyToolInput, AnyToolInputSchema, type AssistantMessage, AssistantMessageSchema, type BashToolInput, BashToolInputSchema, type CheckFailedEvent, CheckFailedEventSchema, type CheckFailedSignal, CheckFailedSignalSchema, type CheckPassedEvent, CheckPassedEventSchema, type CheckPassedSignal, CheckPassedSignalSchema, ClaudeCLI, type ClaudeCliEvent, ClaudeCliEventSchema, type CommitHash, type ConsoleLoggerConfig, ConsoleLoggerConfigSchema, type Consumer, type ConsumerType, ConsumerTypeSchema, type ContentBlock, type ContentBlockDelta, ContentBlockDeltaSchema, ContentBlockSchema, type ContentBlockStart, ContentBlockStartSchema, type ContentBlockStop, ContentBlockStopSchema, type CriteriaDefinedData, CriteriaDefinedDataSchema, type CriteriaDefinedEvent, CriteriaDefinedEventSchema, type CriteriaDefinedSignal, CriteriaDefinedSignalSchema, type Criterion, type CriterionBasicInfo, CriterionBasicInfoSchema, type CriterionFailedData, CriterionFailedDataSchema, type CriterionFailedEvent, CriterionFailedEventSchema, type CriterionFailedSignal, CriterionFailedSignalSchema, type CriterionIdData, CriterionIdDataSchema, type CriterionPassedEvent, CriterionPassedEventSchema, type CriterionPassedSignal, CriterionPassedSignalSchema, CriterionSchema, type CriterionStatus, CriterionStatusSchema, CursorCLI, type Delta, DeltaSchema, type DiscoveryCompletedEvent, DiscoveryCompletedEventSchema, type DiscoveryStartedEvent, DiscoveryStartedEventSchema, type DomainEvent, DomainEventSchema, DomainEventUtils, type DoneEvent, DoneEventSchema, type EditToolInput, EditToolInputSchema, type ExecutionMode, ExecutionModeSchema, type FerixError, FerixParser, type FileLoggerConfig, FileLoggerConfigSchema, FileSystemGit, FileSystemGuardrails, FileSystemPlan, FileSystemProgress, FileSystemSession, type GeneratedTask, type GeneratedTaskList, GeneratedTaskListSchema, GeneratedTaskSchema, type GeneratedTaskStatus, GeneratedTaskStatusSchema, Git, GitError, type GitService, type GlobToolInput, GlobToolInputSchema, type GrepToolInput, GrepToolInputSchema, type Guardrail, type GuardrailAddedEvent, GuardrailAddedEventSchema, GuardrailSchema, type GuardrailSeverity, GuardrailSeveritySchema, type GuardrailSignal, GuardrailSignalSchema, type GuardrailsFile, GuardrailsFileSchema, GuardrailsStore, GuardrailsStoreError, type GuardrailsStoreService, type InputJsonDelta, InputJsonDeltaSchema, type IterationCompletedEvent, IterationCompletedEventSchema, type IterationStartedEvent, IterationStartedEventSchema, type KnownToolName, LLM, LLMError, type LLMEvent, LLMEventSchema, type LLMExecuteOptions, type LLMService, type LLMTextEvent, LLMTextEventSchema, type LLMToolEndEvent, LLMToolEndEventSchema, type LLMToolStartEvent, LLMToolStartEventSchema, type LLMToolUseEvent, LLMToolUseEventSchema, type LearningCategory, LearningCategorySchema, type LearningRecordedEvent, LearningRecordedEventSchema, type LearningSignal, LearningSignalSchema, type LogEntry, LogEntrySchema, type LogLevel, LogLevelSchema, type LoopCompleteSignal, LoopCompleteSignalSchema, type LoopCompletedEvent, LoopCompletedEventSchema, type LoopConfig, LoopConfigSchema, type LoopError, LoopErrorSchema, type LoopFailedEvent, LoopFailedEventSchema, type LoopStartedEvent, LoopStartedEventSchema, type LoopStatus, LoopStatusSchema, type LoopSummary, LoopSummarySchema, MemoryGit, MemoryGuardrails, MemoryPlan, MemoryProgress, MemorySession, Mock, Mock as MockLLM, type OpenCodeCliEvent, OpenCodeCliEventSchema, type OpenCodeCost, OpenCodeCostSchema, type OpenCodeStepFinish, OpenCodeStepFinishSchema, type OpenCodeStepPart, OpenCodeStepPartSchema, type OpenCodeStepStart, OpenCodeStepStartSchema, type OpenCodeTextEvent, OpenCodeTextEventSchema, type OpenCodeTokens, OpenCodeTokensSchema, type OpenCodeToolPart, OpenCodeToolPartSchema, type OpenCodeToolState, OpenCodeToolStateSchema, type OpenCodeToolUseEvent, OpenCodeToolUseEventSchema, OrchestratorError, type OrchestratorServices, PROVIDER_CONFIGS, ParseError, type Phase, type PhaseBasicInfo, PhaseBasicInfoSchema, type PhaseCompletedEvent, PhaseCompletedEventSchema, type PhaseCompletedSignal, PhaseCompletedSignalSchema, type PhaseFailedData, PhaseFailedDataSchema, type PhaseFailedEvent, PhaseFailedEventSchema, type PhaseFailedSignal, PhaseFailedSignalSchema, type PhaseIdData, PhaseIdDataSchema, type PhasePromptOverrides, PhasePromptOverridesSchema, PhaseSchema, type PhaseStartedEvent, PhaseStartedEventSchema, type PhaseStartedSignal, PhaseStartedSignalSchema, type PhaseStatus, PhaseStatusSchema, type PhasesDefinedData, PhasesDefinedDataSchema, type PhasesDefinedEvent, PhasesDefinedEventSchema, type PhasesDefinedSignal, PhasesDefinedSignalSchema, type Plan, type PlanCreatedEvent, PlanCreatedEventSchema, type PlanData, PlanDataSchema, PlanId, PlanSchema, PlanStore, PlanStoreError, type PlanStoreService, type PlanUpdateFailedEvent, PlanUpdateFailedEventSchema, type PlanUpdatedEvent, PlanUpdatedEventSchema, type PrUrl, ProductionLayers, type ProgressAction, ProgressActionSchema, type ProgressEntry, ProgressEntrySchema, type ProgressFile, ProgressFileSchema, ProgressStore, ProgressStoreError, type ProgressStoreService, type ProgressUpdatedEvent, ProgressUpdatedEventSchema, type PromptConfig, PromptConfigSchema, type Provider, type ProviderConfig, type ProviderName, ProviderNameSchema, type ReadToolInput, ReadToolInputSchema, type ReviewCompleteData, ReviewCompleteDataSchema, type ReviewCompleteEvent, ReviewCompleteEventSchema, type ReviewCompleteSignal, ReviewCompleteSignalSchema, type RunOptions, type RunOptionsData, RunOptionsDataSchema, type Session, type SessionNameDefinedSignal, SessionNameDefinedSignalSchema, type SessionNameGeneratedEvent, SessionNameGeneratedEventSchema, SessionSchema, type SessionStatus, SessionStatusSchema, SessionStore, SessionStoreError, type SessionStoreService, type Signal, type SignalAccumulator, SignalParser, type SignalParserService, SignalSchema, type StreamEventEnvelope, StreamEventEnvelopeSchema, type TUICriterion, TUICriterionSchema, type TUICriterionStatus, TUICriterionStatusSchema, type TUIPhase, TUIPhaseSchema, type TUIPhaseStatus, TUIPhaseStatusSchema, type TUIState, TUIStateSchema, type TUITask, TUITaskSchema, type TUITaskStatus, TUITaskStatusSchema, type Task, type TaskBasicInfo, TaskBasicInfoSchema, type TaskCompleteData, TaskCompleteDataSchema, type TaskCompleteSignal, type TaskCompleteSignalData, TaskCompleteSignalDataSchema, TaskCompleteSignalSchema, type TaskCompletedEvent, TaskCompletedEventSchema, TaskSchema, type TaskStatus, TaskStatusSchema, type TaskToolInput, TaskToolInputSchema, type TasksDefinedData, TasksDefinedDataSchema, type TasksDefinedEvent, TasksDefinedEventSchema, type TasksDefinedSignal, TasksDefinedSignalSchema, TestLayers, type TextContentBlock, TextContentBlockSchema, type TextDelta, TextDeltaSchema, type TextEvent, TextEventSchema, type ToolEndEvent, ToolEndEventSchema, ToolInputSchemaRegistry, type ToolStartEvent, ToolStartEventSchema, type ToolUseContentBlock, ToolUseContentBlockSchema, type ToolUseEvent, ToolUseEventSchema, type ValidatedToolUseEvent, ValidatedToolUseEventSchema, type ViewMode, ViewModeSchema, type WebFetchToolInput, WebFetchToolInputSchema, type WebSearchToolInput, WebSearchToolInputSchema, type WorktreeCreatedEvent, WorktreeCreatedEventSchema, type WorktreeInfo, type WorktreePath, type WorktreeRemovedEvent, WorktreeRemovedEventSchema, type WriteToolInput, WriteToolInputSchema, buildPrompt, collectEvents, createCheckFailedSignal, createCheckPassedSignal, createCriteriaDefinedSignal, createCriterionFailedSignal, createCriterionPassedSignal, createGuardrailSignal, createHeadlessConsumer, createLearningSignal, createLoopCompleteSignal, createPhaseCompletedSignal, createPhaseFailedSignal, createPhaseStartedSignal, createPhasesDefinedSignal, createProductionLayers, createProviderLayer, createReviewCompleteSignal, createSessionNameDefinedSignal, createTUIConsumer, createTaskCompleteSignal, createTasksDefinedSignal, createTestLayers, decodeClaudeCliEvent, decodeClaudeCliEventSync, decodeGuardrail, decodeGuardrailsFile, decodeLLMEvent, decodeLoopConfig, decodeOpenCodeCliEvent, decodeOpenCodeCliEventSync, decodePlan, decodePlanData, decodeProgressEntry, decodeProgressFile, decodeSession, 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, validateToolInput, validateToolUseEvent };
+export { type AnyToolInput, AnyToolInputSchema, type AssistantMessage, AssistantMessageSchema, type BashToolInput, BashToolInputSchema, type BranchPushedEvent, BranchPushedEventSchema, type CheckFailedEvent, CheckFailedEventSchema, type CheckFailedSignal, CheckFailedSignalSchema, type CheckPassedEvent, CheckPassedEventSchema, type CheckPassedSignal, CheckPassedSignalSchema, ClaudeCLI, type ClaudeCliEvent, ClaudeCliEventSchema, type CommitHash, type ConsoleLoggerConfig, ConsoleLoggerConfigSchema, type Consumer, type ConsumerType, ConsumerTypeSchema, type ContentBlock, type ContentBlockDelta, ContentBlockDeltaSchema, ContentBlockSchema, type ContentBlockStart, ContentBlockStartSchema, type ContentBlockStop, ContentBlockStopSchema, type CriteriaDefinedData, CriteriaDefinedDataSchema, type CriteriaDefinedEvent, CriteriaDefinedEventSchema, type CriteriaDefinedSignal, CriteriaDefinedSignalSchema, type Criterion, type CriterionBasicInfo, CriterionBasicInfoSchema, type CriterionFailedData, CriterionFailedDataSchema, type CriterionFailedEvent, CriterionFailedEventSchema, type CriterionFailedSignal, CriterionFailedSignalSchema, type CriterionIdData, CriterionIdDataSchema, type CriterionPassedEvent, CriterionPassedEventSchema, type CriterionPassedSignal, CriterionPassedSignalSchema, CriterionSchema, type CriterionStatus, CriterionStatusSchema, CursorCLI, type Delta, DeltaSchema, type DiscoveryCompletedEvent, DiscoveryCompletedEventSchema, type DiscoveryStartedEvent, DiscoveryStartedEventSchema, type DomainEvent, DomainEventSchema, DomainEventUtils, type DoneEvent, DoneEventSchema, type EditToolInput, EditToolInputSchema, type ExecutionMode, ExecutionModeSchema, type FerixError, FerixParser, type FileLoggerConfig, FileLoggerConfigSchema, FileSystemGit, FileSystemGuardrails, FileSystemPlan, FileSystemProgress, FileSystemSession, type GeneratedTask, type GeneratedTaskList, GeneratedTaskListSchema, GeneratedTaskSchema, type GeneratedTaskStatus, GeneratedTaskStatusSchema, Git, GitError, type GitService, type GlobToolInput, GlobToolInputSchema, type GrepToolInput, GrepToolInputSchema, type Guardrail, type GuardrailAddedEvent, GuardrailAddedEventSchema, GuardrailSchema, type GuardrailSeverity, GuardrailSeveritySchema, type GuardrailSignal, GuardrailSignalSchema, type GuardrailsFile, GuardrailsFileSchema, GuardrailsStore, GuardrailsStoreError, type GuardrailsStoreService, type InputJsonDelta, InputJsonDeltaSchema, type IterationCompletedEvent, IterationCompletedEventSchema, type IterationStartedEvent, IterationStartedEventSchema, type KnownToolName, LLM, LLMError, type LLMEvent, LLMEventSchema, type LLMExecuteOptions, type LLMService, type LLMTextEvent, LLMTextEventSchema, type LLMToolEndEvent, LLMToolEndEventSchema, type LLMToolStartEvent, LLMToolStartEventSchema, type LLMToolUseEvent, LLMToolUseEventSchema, type LearningCategory, LearningCategorySchema, type LearningRecordedEvent, LearningRecordedEventSchema, type LearningSignal, LearningSignalSchema, type LogEntry, LogEntrySchema, type LogLevel, LogLevelSchema, type LoopCompleteSignal, LoopCompleteSignalSchema, type LoopCompletedEvent, LoopCompletedEventSchema, type LoopConfig, LoopConfigSchema, type LoopError, LoopErrorSchema, type LoopFailedEvent, LoopFailedEventSchema, type LoopStartedEvent, LoopStartedEventSchema, type LoopStatus, LoopStatusSchema, type LoopSummary, LoopSummarySchema, MemoryGit, MemoryGuardrails, MemoryPlan, MemoryProgress, MemorySession, MetricsError, Mock, Mock as MockLLM, type OpenCodeCliEvent, OpenCodeCliEventSchema, type OpenCodeCost, OpenCodeCostSchema, type OpenCodeStepFinish, OpenCodeStepFinishSchema, type OpenCodeStepPart, OpenCodeStepPartSchema, type OpenCodeStepStart, OpenCodeStepStartSchema, type OpenCodeTextEvent, OpenCodeTextEventSchema, type OpenCodeTokens, OpenCodeTokensSchema, type OpenCodeToolPart, OpenCodeToolPartSchema, type OpenCodeToolState, OpenCodeToolStateSchema, type OpenCodeToolUseEvent, OpenCodeToolUseEventSchema, OrchestratorError, type OrchestratorServices, type PRCreatedEvent, PRCreatedEventSchema, PROVIDER_CONFIGS, ParseError, type Phase, type PhaseBasicInfo, PhaseBasicInfoSchema, type PhaseCompletedEvent, PhaseCompletedEventSchema, type PhaseCompletedSignal, PhaseCompletedSignalSchema, type PhaseFailedData, PhaseFailedDataSchema, type PhaseFailedEvent, PhaseFailedEventSchema, type PhaseFailedSignal, PhaseFailedSignalSchema, type PhaseIdData, PhaseIdDataSchema, type PhasePromptOverrides, PhasePromptOverridesSchema, PhaseSchema, type PhaseStartedEvent, PhaseStartedEventSchema, type PhaseStartedSignal, PhaseStartedSignalSchema, type PhaseStatus, PhaseStatusSchema, type PhasesDefinedData, PhasesDefinedDataSchema, type PhasesDefinedEvent, PhasesDefinedEventSchema, type PhasesDefinedSignal, PhasesDefinedSignalSchema, type Plan, type PlanCreatedEvent, PlanCreatedEventSchema, type PlanData, PlanDataSchema, PlanId, PlanSchema, PlanStore, PlanStoreError, type PlanStoreService, type PlanUpdateFailedEvent, PlanUpdateFailedEventSchema, type PlanUpdatedEvent, PlanUpdatedEventSchema, type PrUrl, ProductionLayers, type ProgressAction, ProgressActionSchema, type ProgressEntry, ProgressEntrySchema, type ProgressFile, ProgressFileSchema, ProgressStore, ProgressStoreError, type ProgressStoreService, type ProgressUpdatedEvent, ProgressUpdatedEventSchema, type PromptConfig, PromptConfigSchema, type Provider, type ProviderConfig, type ProviderName, ProviderNameSchema, type ReadToolInput, ReadToolInputSchema, RetryExhaustedError, type ReviewCompleteData, ReviewCompleteDataSchema, type ReviewCompleteEvent, ReviewCompleteEventSchema, type ReviewCompleteSignal, ReviewCompleteSignalSchema, type RunOptions, type RunOptionsData, RunOptionsDataSchema, type Session, type SessionNameDefinedSignal, SessionNameDefinedSignalSchema, type SessionNameGeneratedEvent, SessionNameGeneratedEventSchema, SessionSchema, type SessionStatus, SessionStatusSchema, SessionStore, SessionStoreError, type SessionStoreService, type Signal, type SignalAccumulator, SignalParser, type SignalParserService, SignalSchema, type StreamEventEnvelope, StreamEventEnvelopeSchema, type TUICriterion, TUICriterionSchema, type TUICriterionStatus, TUICriterionStatusSchema, type TUIPhase, TUIPhaseSchema, type TUIPhaseStatus, TUIPhaseStatusSchema, type TUIState, TUIStateSchema, type TUITask, TUITaskSchema, type TUITaskStatus, TUITaskStatusSchema, type Task, type TaskBasicInfo, TaskBasicInfoSchema, type TaskCompleteData, TaskCompleteDataSchema, type TaskCompleteSignal, type TaskCompleteSignalData, TaskCompleteSignalDataSchema, TaskCompleteSignalSchema, type TaskCompletedEvent, TaskCompletedEventSchema, TaskSchema, type TaskStatus, TaskStatusSchema, type TaskToolInput, TaskToolInputSchema, type TasksDefinedData, TasksDefinedDataSchema, type TasksDefinedEvent, TasksDefinedEventSchema, type TasksDefinedSignal, TasksDefinedSignalSchema, TestLayers, type TextContentBlock, TextContentBlockSchema, type TextDelta, TextDeltaSchema, type TextEvent, TextEventSchema, TokenBudgetError, type ToolEndEvent, ToolEndEventSchema, ToolInputSchemaRegistry, type ToolStartEvent, ToolStartEventSchema, type ToolUseContentBlock, ToolUseContentBlockSchema, type ToolUseEvent, ToolUseEventSchema, type ValidatedToolUseEvent, ValidatedToolUseEventSchema, type ViewMode, ViewModeSchema, type WebFetchToolInput, WebFetchToolInputSchema, type WebSearchToolInput, WebSearchToolInputSchema, type WorktreeCreatedEvent, WorktreeCreatedEventSchema, type WorktreeInfo, type WorktreePath, type WorktreeRemovedEvent, WorktreeRemovedEventSchema, type WriteToolInput, WriteToolInputSchema, buildPrompt, collectEvents, createCheckFailedSignal, createCheckPassedSignal, createCriteriaDefinedSignal, createCriterionFailedSignal, createCriterionPassedSignal, createGuardrailSignal, createHeadlessConsumer, createLearningSignal, createLoopCompleteSignal, createPhaseCompletedSignal, createPhaseFailedSignal, createPhaseStartedSignal, createPhasesDefinedSignal, createProductionLayers, createProviderLayer, createReviewCompleteSignal, createSessionNameDefinedSignal, createTUIConsumer, createTaskCompleteSignal, createTasksDefinedSignal, createTestLayers, decodeClaudeCliEvent, decodeClaudeCliEventSync, decodeGuardrail, decodeGuardrailsFile, decodeLLMEvent, decodeLoopConfig, decodeOpenCodeCliEvent, decodeOpenCodeCliEventSync, decodePlan, decodePlanData, decodeProgressEntry, decodeProgressFile, decodeSession, 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, validateToolInput, validateToolUseEvent };

package/dist/index.js

@@ -66,12 +66,15 @@ var init_registry = __esm({
 
 // src/index.ts
 init_esm_shims();
+import { sync } from "@ferix/sync";
 import { Command } from "commander";
+import { Effect as Effect25 } from "effect";
+import pc17 from "picocolors";
 
 // package.json
 var package_default = {
   name: "ferix-code",
-  version: "0.0.2-beta.18",
+  version: "0.0.2-beta.20",
   description: "Composable RALPH loops for AI coding agents - v2 with Effect",
   type: "module",
   bin: {
@@ -90,6 +93,7 @@ var package_default = {
     bump: "npm version prerelease --preid=beta --workspaces=false && bun run build && bun publish --tag beta"
   },
   dependencies: {
+    "@ferix/sync": "*",
     commander: "^14.0.0",
     effect: "^3.19.15",
     "human-id": "^4.1.3",
@@ -905,6 +909,17 @@ tagRendererRegistry.register({
   render: () => `${colors.info(symbols.bulletFilled)} ${colors.muted("Review made changes")}`
 });
 
+// src/consumers/tui/tags/handlers/session-name.ts
+init_esm_shims();
+init_registry();
+tagRendererRegistry.register({
+  pattern: /<ferix:session-name>([^<]+)<\/ferix:session-name>/g,
+  render: (m) => {
+    const name = m[1] ?? "";
+    return `${colors.brand(symbols.diamond)} ${colors.muted(name)}`;
+  }
+});
+
 // src/consumers/tui/tags/handlers/tasks.ts
 init_esm_shims();
 init_registry();
@@ -2560,7 +2575,14 @@ import { Layer as Layer14 } from "effect";
 // src/layers/git/file-system.ts
 init_esm_shims();
 import { exec } from "child_process";
-import { access, copyFile, mkdir, rm } from "fs/promises";
+import {
+  access,
+  appendFile,
+  copyFile,
+  mkdir,
+  readFile,
+  rm
+} from "fs/promises";
 import { dirname, join } from "path";
 import { promisify } from "util";
 import { Effect as Effect4, Layer } from "effect";
@@ -2586,6 +2608,14 @@ 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 MetricsError = class extends Data.TaggedError("MetricsError") {
+};
 
 // src/services/git.ts
 init_esm_shims();
@@ -2596,6 +2626,7 @@ var Git = class extends Context.Tag("@ferix/Git")() {
 // src/layers/git/file-system.ts
 var execAsync = promisify(exec);
 var WORKTREES_DIR = ".ferix/worktrees";
+var GITDIR_REGEX = /^gitdir:\s*(.+)$/m;
 var BRANCH_PREFIX = "ferix";
 function getWorktreeDir(sessionId) {
   return join(process.cwd(), WORKTREES_DIR, sessionId);
@@ -2628,12 +2659,39 @@ function directoryExists(dirPath) {
     catch: () => new Error("Directory does not exist")
   }).pipe(Effect4.orElseSucceed(() => false));
 }
+function branchExists(branchName) {
+  return gitExec(`git rev-parse --verify refs/heads/${branchName}`).pipe(
+    Effect4.map(() => true),
+    Effect4.orElseSucceed(() => false)
+  );
+}
+function findAvailableBranchName(baseName, maxAttempts = 100) {
+  const tryName = (name, attempt) => Effect4.gen(function* () {
+    const exists = yield* branchExists(name);
+    if (!exists) {
+      return name;
+    }
+    if (attempt >= maxAttempts) {
+      return yield* Effect4.fail(
+        new GitError({
+          message: `Could not find available branch name after ${maxAttempts} attempts`,
+          operation: "branchLookup"
+        })
+      );
+    }
+    return yield* tryName(`${baseName}-${attempt + 1}`, attempt + 1);
+  });
+  return tryName(baseName, 1);
+}
 function copyUntrackedFiles(worktreeDir) {
   return Effect4.gen(function* () {
     const untrackedOutput = yield* gitExec(
       "git ls-files --others --exclude-standard"
     ).pipe(Effect4.catchAll(() => Effect4.succeed("")));
     const untrackedFiles = untrackedOutput.split("\n").filter((f) => f.length > 0).filter((f) => !f.startsWith(".ferix/"));
+    if (untrackedFiles.length === 0) {
+      return;
+    }
     for (const file of untrackedFiles) {
       const srcPath = join(process.cwd(), file);
       const destPath = join(worktreeDir, file);
@@ -2648,6 +2706,26 @@ function copyUntrackedFiles(worktreeDir) {
         })
       }).pipe(Effect4.catchAll(() => Effect4.succeed(void 0)));
     }
+    yield* Effect4.tryPromise({
+      try: async () => {
+        const gitFilePath = join(worktreeDir, ".git");
+        const gitFileContent = await readFile(gitFilePath, "utf-8");
+        const gitDirMatch = gitFileContent.match(GITDIR_REGEX);
+        const gitDirPath = gitDirMatch?.[1]?.trim();
+        if (!gitDirPath) {
+          return;
+        }
+        const gitDir = gitDirPath;
+        const excludePath = join(gitDir, "info", "exclude");
+        await mkdir(dirname(excludePath), { recursive: true });
+        const excludeContent = "\n# Untracked files copied from main worktree (auto-generated by ferix)\n" + untrackedFiles.join("\n") + "\n";
+        await appendFile(excludePath, excludeContent);
+      },
+      catch: () => new GitError({
+        message: "Failed to update exclude file for copied untracked files",
+        operation: "createWorktree"
+      })
+    }).pipe(Effect4.catchAll(() => Effect4.succeed(void 0)));
   });
 }
 var make = {
@@ -2808,7 +2886,6 @@ var make = {
   }),
   pushBranch: (sessionId) => Effect4.gen(function* () {
     const worktreeDir = getWorktreeDir(sessionId);
-    const branchName = getBranchName(sessionId);
     const exists = yield* directoryExists(worktreeDir);
     if (!exists) {
       return yield* Effect4.fail(
@@ -2818,7 +2895,7 @@ var make = {
         })
       );
     }
-    yield* gitExec(`git push -u origin "${branchName}"`, worktreeDir).pipe(
+    yield* gitExec("git push -u origin HEAD", worktreeDir).pipe(
       Effect4.mapError(
         (error) => new GitError({
           message: `Failed to push branch: ${error.message}`,
@@ -2828,7 +2905,7 @@ var make = {
       )
     );
   }),
-  createPR: (sessionId, title, body) => Effect4.gen(function* () {
+  createPR: (sessionId, title, body, baseBranch) => Effect4.gen(function* () {
     const worktreeDir = getWorktreeDir(sessionId);
     const exists = yield* directoryExists(worktreeDir);
     if (!exists) {
@@ -2841,8 +2918,9 @@ var make = {
     }
     const escapedTitle = title.replace(/"/g, '\\"');
     const escapedBody = body.replace(/"/g, '\\"');
+    const baseFlag = baseBranch ? ` --base "${baseBranch}"` : "";
     const prUrl = yield* gitExec(
-      `gh pr create --title "${escapedTitle}" --body "${escapedBody}"`,
+      `gh pr create --title "${escapedTitle}" --body "${escapedBody}"${baseFlag}`,
       worktreeDir
     ).pipe(
       Effect4.mapError(
@@ -2855,10 +2933,18 @@ var make = {
     );
     return prUrl;
   }),
+  getCurrentBranch: () => gitExec("git branch --show-current").pipe(
+    Effect4.mapError(
+      (error) => new GitError({
+        message: `Failed to get current branch: ${error.message}`,
+        operation: "getCurrentBranch",
+        cause: error
+      })
+    )
+  ),
   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(
@@ -2868,6 +2954,8 @@ var make = {
         })
       );
     }
+    const desiredName = `${BRANCH_PREFIX}/${displayName}`;
+    const newBranchName = yield* findAvailableBranchName(desiredName);
     yield* gitExec(
       `git branch -m "${oldBranchName}" "${newBranchName}"`,
       worktreeDir
@@ -2963,7 +3051,7 @@ function createMemoryGitService(stateRef, commitCounterRef) {
         );
       }
     }),
-    createPR: (sessionId, title, _body) => Effect5.gen(function* () {
+    createPR: (sessionId, title, _body, _baseBranch) => Effect5.gen(function* () {
       const state = yield* Ref3.get(stateRef);
       const worktree = state.get(sessionId);
       if (!worktree) {
@@ -2977,6 +3065,8 @@ function createMemoryGitService(stateRef, commitCounterRef) {
       const slug = title.toLowerCase().replace(/\s+/g, "-").slice(0, 30);
       return `https://github.com/test/repo/pull/${slug}`;
     }),
+    getCurrentBranch: () => Effect5.succeed("main"),
+    // Default to main for tests
     renameBranch: (sessionId, displayName) => Effect5.gen(function* () {
       const state = yield* Ref3.get(stateRef);
       const worktree = state.get(sessionId);
@@ -3018,7 +3108,7 @@ var MemoryGit = {
 
 // src/layers/guardrails/file-system.ts
 init_esm_shims();
-import { mkdir as mkdir2, readFile, writeFile } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile2, writeFile } from "fs/promises";
 import { join as join2 } from "path";
 import { DateTime, Effect as Effect6, Layer as Layer3 } from "effect";
 
@@ -3200,7 +3290,9 @@ var LoopSummarySchema = S4.Struct({
   success: S4.Boolean,
   sessionId: S4.String,
   completedTasks: S4.Array(S4.String),
-  durationMs: S4.Number
+  durationMs: S4.Number,
+  branchPushed: S4.optional(S4.Boolean),
+  prUrl: S4.optional(S4.String)
 });
 var LoopErrorSchema = S4.Struct({
   message: S4.String,
@@ -3457,6 +3549,17 @@ var WorktreeRemovedEventSchema = taggedEvent("WorktreeRemoved", {
   sessionId: S7.String,
   timestamp: S7.Number
 });
+var BranchPushedEventSchema = taggedEvent("BranchPushed", {
+  sessionId: S7.String,
+  branchName: S7.String,
+  timestamp: S7.Number
+});
+var PRCreatedEventSchema = taggedEvent("PRCreated", {
+  sessionId: S7.String,
+  prUrl: S7.String,
+  title: S7.String,
+  timestamp: S7.Number
+});
 var SessionNameGeneratedEventSchema = taggedEvent(
   "SessionNameGenerated",
   {
@@ -3498,6 +3601,8 @@ var DomainEventSchema = S7.Union(
   ProgressUpdatedEventSchema,
   WorktreeCreatedEventSchema,
   WorktreeRemovedEventSchema,
+  BranchPushedEventSchema,
+  PRCreatedEventSchema,
   SessionNameGeneratedEventSchema
 );
 var DomainEventUtils = {
@@ -3641,7 +3746,9 @@ var SessionSchema = S13.Struct({
   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)
+  displayName: S13.optional(S13.String),
+  /** The branch ferix was started from - used as PR base branch */
+  baseBranch: S13.optional(S13.String)
 });
 var decodeSession = S13.decodeUnknown(SessionSchema);
 
@@ -4069,7 +4176,7 @@ var make2 = {
     const existing = yield* Effect6.tryPromise({
       try: async () => {
         try {
-          const content = await readFile(guardrailsPath, "utf-8");
+          const content = await readFile2(guardrailsPath, "utf-8");
           return content;
         } catch {
           return null;
@@ -4118,7 +4225,7 @@ var make2 = {
     const content = yield* Effect6.tryPromise({
       try: async () => {
         try {
-          return await readFile(guardrailsPath, "utf-8");
+          return await readFile2(guardrailsPath, "utf-8");
         } catch {
           return null;
         }
@@ -4673,7 +4780,7 @@ function createProviderLayer2(name) {
 
 // src/layers/plan/file-system.ts
 init_esm_shims();
-import { access as access2, mkdir as mkdir3, readdir, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { access as access2, mkdir as mkdir3, readdir, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
 import { join as join3 } from "path";
 import { Effect as Effect12, Layer as Layer7 } from "effect";
 
@@ -4767,7 +4874,7 @@ var make3 = {
     if (sessionId) {
       const planPath = getPlanPath(sessionId, planId);
       const content = yield* Effect12.tryPromise({
-        try: () => readFile2(planPath, "utf-8"),
+        try: () => readFile3(planPath, "utf-8"),
         catch: (error) => new PlanStoreError({
           message: `Failed to read plan file: ${planPath}`,
           operation: "load",
@@ -4802,7 +4909,7 @@ var make3 = {
       }).pipe(Effect12.orElseSucceed(() => false));
       if (exists) {
         const content = yield* Effect12.tryPromise({
-          try: () => readFile2(planPath, "utf-8"),
+          try: () => readFile3(planPath, "utf-8"),
           catch: (error) => new PlanStoreError({
             message: `Failed to read plan file: ${planPath}`,
             operation: "load",
@@ -4943,7 +5050,7 @@ var MemoryPlan = {
 
 // src/layers/progress/file-system.ts
 init_esm_shims();
-import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
 import { join as join4 } from "path";
 import { DateTime as DateTime3, Effect as Effect14, Layer as Layer9 } from "effect";
 
@@ -5011,7 +5118,7 @@ var make4 = {
     const existing = yield* Effect14.tryPromise({
       try: async () => {
         try {
-          const content = await readFile3(progressPath, "utf-8");
+          const content = await readFile4(progressPath, "utf-8");
           return content;
         } catch {
           return null;
@@ -5056,7 +5163,7 @@ var make4 = {
     const content = yield* Effect14.tryPromise({
       try: async () => {
         try {
-          return await readFile3(progressPath, "utf-8");
+          return await readFile4(progressPath, "utf-8");
         } catch {
           return null;
         }
@@ -5147,7 +5254,7 @@ var MemoryProgress = {
 
 // src/layers/session/file-system.ts
 init_esm_shims();
-import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
 import { join as join5 } from "path";
 import { DateTime as DateTime5, Effect as Effect16, Layer as Layer11 } from "effect";
 import { humanId } from "human-id";
@@ -5230,7 +5337,7 @@ var make5 = {
   get: (sessionId) => Effect16.gen(function* () {
     const sessionPath = getSessionPath(sessionId);
     const content = yield* Effect16.tryPromise({
-      try: () => readFile4(sessionPath, "utf-8"),
+      try: () => readFile5(sessionPath, "utf-8"),
       catch: (error) => new SessionStoreError({
         message: `Failed to read session file: ${sessionPath}`,
         operation: "get",
@@ -5949,7 +6056,7 @@ import { DateTime as DateTime8, Effect as Effect21, pipe, Ref as Ref10, Stream a
 
 // src/layers/plan/task-generation.ts
 init_esm_shims();
-import { mkdir as mkdir6, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
 import { join as join6 } from "path";
 import { Effect as Effect19 } from "effect";
 var PLANS_DIR4 = ".ferix/plans";
@@ -6177,6 +6284,15 @@ init_esm_shims();
 
 // src/orchestrator/plan-updates/helpers.ts
 init_esm_shims();
+var VERIFICATION_PATTERNS = [
+  /\b(lint|linting|format|formatting)\b/i,
+  /\b(run\s+tests?|testing)\b/i,
+  /\b(verify|verification|validate|validation)\b/i,
+  /^run\s+(bun|npm|yarn|pnpm)\s+(lint|test|format|build)/i
+];
+function isVerificationTask(title) {
+  return VERIFICATION_PATTERNS.some((pattern) => pattern.test(title));
+}
 function createPlanFromTasks(sessionId, originalTask, tasks, createdAt) {
   return {
     id: PlanId(`${sessionId}-plan`),
@@ -6446,16 +6562,24 @@ planUpdateRegistry.register({
 init_esm_shims();
 planUpdateRegistry.register({
   tag: "TasksDefined",
-  handle: (signal, _currentPlan, context) => ({
-    plan: createPlanFromTasks(
-      context.sessionId,
-      context.originalTask,
-      signal.tasks,
-      context.timestamp
-    ),
-    operation: "create",
-    eventTag: "PlanCreated"
-  })
+  handle: (signal, _currentPlan, context) => {
+    const filteredTasks = signal.tasks.filter(
+      (task) => !isVerificationTask(task.title)
+    );
+    if (filteredTasks.length === 0) {
+      return void 0;
+    }
+    return {
+      plan: createPlanFromTasks(
+        context.sessionId,
+        context.originalTask,
+        filteredTasks,
+        context.timestamp
+      ),
+      operation: "create",
+      eventTag: "PlanCreated"
+    };
+  }
 });
 
 // src/orchestrator/plan-updates/index.ts
@@ -6677,7 +6801,12 @@ function buildVerifyPrompt(verifyCommands, prompts) {
 Run these verification commands:
 ${verifyCommands.map((cmd) => `- ${cmd}`).join("\n")}
 
-If any fail, fix the issues and re-verify.`;
+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 = {
@@ -6797,8 +6926,13 @@ ${config.task}`);
   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) {
-    sections.push(buildVerifyPrompt(config.verifyCommands, prompts));
+  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(
@@ -6811,6 +6945,12 @@ 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");
+}
 
 // src/orchestrator/discovery.ts
 function processTextSignals(signalParser, text, context) {
@@ -7124,6 +7264,28 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
                 events.push(...planEvents);
               }
               if (result.completed) {
+                yield* Effect22.logInfo(
+                  "[DEBUG] createIterationStream: LLM emitted completion signal"
+                );
+                yield* Ref11.set(loopCompletedRef, true);
+              }
+              const updatedPlan = yield* Ref11.get(currentPlanRef);
+              const allComplete = areAllTasksComplete(updatedPlan);
+              yield* Effect22.logInfo(
+                "[DEBUG] createIterationStream: Auto-complete check",
+                {
+                  llmEmittedComplete: result.completed,
+                  allTasksComplete: allComplete,
+                  taskStatuses: updatedPlan?.tasks.map((t) => ({
+                    id: t.id,
+                    status: t.status
+                  }))
+                }
+              );
+              if (allComplete) {
+                yield* Effect22.logInfo(
+                  "[DEBUG] createIterationStream: All tasks complete - ending loop"
+                );
                 yield* Ref11.set(loopCompletedRef, true);
               }
               return Stream8.fromIterable(events);
@@ -7183,6 +7345,14 @@ function runLoop(config) {
           })
         )
       );
+      const baseBranch = yield* git.getCurrentBranch().pipe(
+        Effect23.tapError(
+          (error) => Effect23.logDebug("Failed to get current branch", {
+            error: String(error)
+          })
+        ),
+        Effect23.orElseSucceed(() => void 0)
+      );
       const worktreePath = yield* git.createWorktree(session.id).pipe(
         Effect23.mapError(
           (e) => new OrchestratorError({
@@ -7196,7 +7366,8 @@ function runLoop(config) {
       yield* sessionStore.update(session.id, {
         ...session,
         worktreePath,
-        branchName
+        branchName,
+        baseBranch
       }).pipe(
         Effect23.tapError(
           (error) => Effect23.logDebug("Failed to update session with worktree info", {
@@ -7216,7 +7387,8 @@ function runLoop(config) {
       };
       const loopCompletedRef = yield* Ref12.make(false);
       const currentPlanRef = yield* Ref12.make(void 0);
-      const sessionRef = yield* Ref12.make(session);
+      const initialSession = { ...session, baseBranch };
+      const sessionRef = yield* Ref12.make(initialSession);
       const maxIterations = config.maxIterations === 0 ? Number.POSITIVE_INFINITY : config.maxIterations;
       const loopStarted = {
         _tag: "LoopStarted",
@@ -7273,8 +7445,14 @@ function runLoop(config) {
       );
       const completionStream = createCompletionStream(
         sessionStore,
-        git,
-        session,
+        {
+          commitChanges: git.commitChanges,
+          removeWorktreeKeepBranch: git.removeWorktreeKeepBranch,
+          pushBranch: git.pushBranch,
+          createPR: git.createPR,
+          getBranchName: git.getBranchName
+        },
+        sessionRef,
         config,
         startTime,
         loopCompletedRef,
@@ -7303,9 +7481,21 @@ function runLoop(config) {
     )
   );
 }
-function createCompletionStream(sessionStore, git, session, config, startTime, loopCompletedRef, _worktreePath) {
+function buildPRBody(session, config) {
+  const completedTasks = session.completedTasks.length > 0 ? session.completedTasks.map((t) => `- ${t}`).join("\n") : "- No specific tasks tracked";
+  return `## Summary
+${config.task}
+
+## Completed Tasks
+${completedTasks}
+
+---
+Generated by Ferix`;
+}
+function createCompletionStream(sessionStore, git, sessionRef, config, startTime, loopCompletedRef, _worktreePath) {
   return Stream9.unwrap(
     Effect23.gen(function* () {
+      const session = yield* Ref12.get(sessionRef);
       const endTimeUtc = yield* DateTime10.now;
       const endTime = DateTime10.toEpochMillis(endTimeUtc);
       const durationMs = endTime - startTime;
@@ -7319,6 +7509,36 @@ function createCompletionStream(sessionStore, git, session, config, startTime, l
         ),
         Effect23.orElseSucceed(() => void 0)
       );
+      let branchPushed = false;
+      if (config.push === true) {
+        const pushResult = yield* git.pushBranch(session.id).pipe(
+          Effect23.map(() => true),
+          Effect23.tapError(
+            (error) => Effect23.logDebug("Push failed, continuing", {
+              sessionId: session.id,
+              error: String(error)
+            })
+          ),
+          Effect23.orElseSucceed(() => false)
+        );
+        branchPushed = pushResult;
+      }
+      let prUrl;
+      if (config.pr === true && branchPushed) {
+        const title = `feat: ${session.originalTask.slice(0, 50)}`;
+        const body = buildPRBody(session, config);
+        const prResult = yield* git.createPR(session.id, title, body, session.baseBranch).pipe(
+          Effect23.map((url) => url),
+          Effect23.tapError(
+            (error) => Effect23.logDebug("PR creation failed, continuing", {
+              sessionId: session.id,
+              error: String(error)
+            })
+          ),
+          Effect23.orElseSucceed(() => void 0)
+        );
+        prUrl = prResult;
+      }
       yield* git.removeWorktreeKeepBranch(session.id).pipe(
         Effect23.tapError(
           (error) => Effect23.logDebug("Worktree cleanup failed, continuing", {
@@ -7338,7 +7558,9 @@ function createCompletionStream(sessionStore, git, session, config, startTime, l
         success: completed,
         sessionId: session.id,
         completedTasks: session.completedTasks,
-        durationMs
+        durationMs,
+        branchPushed: branchPushed || void 0,
+        prUrl: prUrl || void 0
       };
       yield* sessionStore.update(session.id, {
         ...session,
@@ -7353,11 +7575,26 @@ function createCompletionStream(sessionStore, git, session, config, startTime, l
         ),
         Effect23.orElseSucceed(() => void 0)
       );
-      const loopCompleted = { _tag: "LoopCompleted", summary };
-      return pipe3(
-        Stream9.succeed(worktreeRemoved),
-        Stream9.concat(Stream9.succeed(loopCompleted))
-      );
+      const events = [worktreeRemoved];
+      if (branchPushed) {
+        events.push({
+          _tag: "BranchPushed",
+          sessionId: session.id,
+          branchName: session.branchName ?? git.getBranchName(session.id),
+          timestamp: endTime
+        });
+      }
+      if (prUrl) {
+        events.push({
+          _tag: "PRCreated",
+          sessionId: session.id,
+          prUrl,
+          title: `feat: ${session.originalTask.slice(0, 50)}`,
+          timestamp: endTime
+        });
+      }
+      events.push({ _tag: "LoopCompleted", summary });
+      return Stream9.fromIterable(events);
     })
   );
 }
@@ -7398,7 +7635,8 @@ init_esm_shims();
 
 // src/index.ts
 var program = new Command();
-program.name("ferix-code").description("Composable RALPH loops for AI coding agents").version(package_default.version, "-v, --version", "Output the version number").argument("<task>", "Task description or path to PRD file").option("-i, --iterations <n>", "Maximum iterations", "1").option("-c, --verify <commands...>", "Verification commands to run").option("--branch <name>", "Git branch to create").option("--push", "Push branch after completion").option("--pr", "Create PR after pushing").option("--provider <name>", "LLM provider to use (claude, cursor)", "claude").action(async (task, options) => {
+program.name("ferix-code").description("Composable RALPH loops for AI coding agents").version(package_default.version, "-v, --version", "Output the version number");
+program.command("run", { isDefault: true }).argument("<task>", "Task description or path to PRD file").option("-i, --iterations <n>", "Maximum iterations", "1").option("-c, --verify <commands...>", "Verification commands to run").option("--branch <name>", "Git branch to create").option("--push", "Push branch after completion").option("--pr", "Create PR after pushing").option("--provider <name>", "LLM provider to use (claude, cursor)", "claude").action(async (task, options) => {
   const config = {
     task,
     maxIterations: Number.parseInt(options.iterations, 10),
@@ -7415,11 +7653,58 @@ program.name("ferix-code").description("Composable RALPH loops for AI coding age
     process.exit(1);
   }
 });
+program.command("sync").description("Discover and install skills based on your dependencies").option("-p, --path <path>", "Path to package.json", "./package.json").option("-d, --dry-run", "List skills without installing").option("-g, --global", "Install globally instead of project-level").action(async (options) => {
+  try {
+    console.log("\nScanning package.json...");
+    const result = await Effect25.runPromise(
+      sync(options.path, {
+        dryRun: options.dryRun ?? false,
+        global: options.global ?? false
+      })
+    );
+    console.log(
+      `Found ${pc17.bold(String(result.dependencies.length))} dependencies`
+    );
+    console.log(
+      `Resolved ${pc17.bold(String(result.orgs.length))} unique GitHub organizations`
+    );
+    if (result.skillRepos.length === 0) {
+      console.log(
+        `
+${pc17.yellow("No skill repositories found for your dependencies.")}`
+      );
+      return;
+    }
+    console.log(
+      `
+Found ${pc17.bold(String(result.skillRepos.length))} skill repositories:
+`
+    );
+    for (const repo of result.skillRepos) {
+      console.log(`  ${pc17.green("\u2022")} ${repo.owner}/${repo.repo}`);
+    }
+    if (options.dryRun) {
+      console.log(
+        `
+${pc17.dim("Run without --dry-run to install these skills.")}`
+      );
+    } else {
+      console.log(
+        `
+${pc17.green("\u2713")} Installed ${pc17.bold(String(result.installed.length))} skill repositories`
+      );
+    }
+  } catch (error) {
+    console.error(pc17.red("Error:"), error);
+    process.exit(1);
+  }
+});
 program.parse();
 export {
   AnyToolInputSchema,
   AssistantMessageSchema,
   BashToolInputSchema,
+  BranchPushedEventSchema,
   CheckFailedEventSchema,
   CheckFailedSignalSchema,
   CheckPassedEventSchema,
@@ -7502,6 +7787,7 @@ export {
   MemoryPlan,
   MemoryProgress,
   MemorySession,
+  MetricsError,
   Mock,
   Mock as MockLLM,
   OpenCodeCliEventSchema,
@@ -7515,6 +7801,7 @@ export {
   OpenCodeToolStateSchema,
   OpenCodeToolUseEventSchema,
   OrchestratorError,
+  PRCreatedEventSchema,
   PROVIDER_CONFIGS,
   ParseError,
   PhaseBasicInfoSchema,
@@ -7550,6 +7837,7 @@ export {
   PromptConfigSchema,
   ProviderNameSchema,
   ReadToolInputSchema,
+  RetryExhaustedError,
   ReviewCompleteDataSchema,
   ReviewCompleteEventSchema,
   ReviewCompleteSignalSchema,
@@ -7585,6 +7873,7 @@ export {
   TextContentBlockSchema,
   TextDeltaSchema,
   TextEventSchema,
+  TokenBudgetError,
   ToolEndEventSchema,
   ToolInputSchemaRegistry,
   ToolStartEventSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ferix-code",
-  "version": "0.0.2-beta.18",
+  "version": "0.0.2-beta.20",
   "description": "Composable RALPH loops for AI coding agents - v2 with Effect",
   "type": "module",
   "bin": {
@@ -19,6 +19,7 @@
     "bump": "npm version prerelease --preid=beta --workspaces=false && bun run build && bun publish --tag beta"
   },
   "dependencies": {
+    "@ferix/sync": "*",
     "commander": "^14.0.0",
     "effect": "^3.19.15",
     "human-id": "^4.1.3",