@llm4ts/flow 0.15.0 → 0.16.0

package/dist/Replay.d.ts

@@ -22,8 +22,8 @@ export declare class ReplayFailure extends ReplayFailure_base {
 export declare const ReplayTurn: Schema.Union<readonly [typeof ReplaySuccess, typeof ReplayFailure]>;
 export type ReplayTurn = typeof ReplayTurn.Type;
 export declare const segmentReplayTurns: (lines: ReadonlyArray<TraceLine>) => ReadonlyArray<ReplayTurn>;
-export declare const readTrace: (files: PlainFileStoreShape, path: string) => Effect.Effect<readonly TraceLine[], import("./FlowError.ts").PersistenceError | PlanParseError | UnsupportedSchemaVersion | import("./FlowError.ts").WorkspacePathError | import("./FlowError.ts").WorkspaceLimitError | import("./FlowError.ts").WorkspaceIoError | import("./FlowError.ts").FlowAborted | import("./FlowError.ts").ProcessError | import("./FlowError.ts").FlowLlmError | import("./FlowError.ts").FlowCapabilityDenied | import("./FlowError.ts").ColumnNotFound | import("./FlowError.ts").BudgetExceeded, never>;
+export declare const readTrace: (files: PlainFileStoreShape, path: string) => Effect.Effect<readonly TraceLine[], import("./FlowError.ts").PersistenceError | PlanParseError | UnsupportedSchemaVersion | import("./FlowError.ts").WorkspacePathError | import("./FlowError.ts").WorkspaceLimitError | import("./FlowError.ts").WorkspaceIoError | import("./FlowError.ts").FlowAborted | import("./FlowError.ts").ProcessError | import("./FlowError.ts").FlowLlmError | import("./FlowError.ts").FlowCapabilityDenied | import("./FlowError.ts").ColumnNotFound | import("./FlowError.ts").BudgetExceeded | import("./FlowError.ts").StoryPlanInvalid | import("./FlowError.ts").PerimeterViolation | import("./FlowError.ts").MissingDependency | import("./FlowError.ts").MergeConflict | import("./FlowError.ts").StoryFailed, never>;
 export declare const makeReplayConnector: (turns: readonly (ReplaySuccess | ReplayFailure)[]) => Effect.Effect<LlmServiceShape, never, never>;
-export declare const replayFromTrace: (files: PlainFileStoreShape, path: string) => Effect.Effect<LlmServiceShape, import("./FlowError.ts").PersistenceError | PlanParseError | UnsupportedSchemaVersion | import("./FlowError.ts").WorkspacePathError | import("./FlowError.ts").WorkspaceLimitError | import("./FlowError.ts").WorkspaceIoError | import("./FlowError.ts").FlowAborted | import("./FlowError.ts").ProcessError | import("./FlowError.ts").FlowLlmError | import("./FlowError.ts").FlowCapabilityDenied | import("./FlowError.ts").ColumnNotFound | import("./FlowError.ts").BudgetExceeded, never>;
+export declare const replayFromTrace: (files: PlainFileStoreShape, path: string) => Effect.Effect<LlmServiceShape, import("./FlowError.ts").PersistenceError | PlanParseError | UnsupportedSchemaVersion | import("./FlowError.ts").WorkspacePathError | import("./FlowError.ts").WorkspaceLimitError | import("./FlowError.ts").WorkspaceIoError | import("./FlowError.ts").FlowAborted | import("./FlowError.ts").ProcessError | import("./FlowError.ts").FlowLlmError | import("./FlowError.ts").FlowCapabilityDenied | import("./FlowError.ts").ColumnNotFound | import("./FlowError.ts").BudgetExceeded | import("./FlowError.ts").StoryPlanInvalid | import("./FlowError.ts").PerimeterViolation | import("./FlowError.ts").MissingDependency | import("./FlowError.ts").MergeConflict | import("./FlowError.ts").StoryFailed, never>;
 export {};
 //# sourceMappingURL=Replay.d.ts.map

package/dist/Replay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Replay.d.ts","sourceRoot":"","sources":["../src/Replay.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AAC9D,OAAO,EAAY,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAE1D,OAAO,EAAE,cAAc,EAAE,wBAAwB,EAAkB,MAAM,gBAAgB,CAAA;AACzF,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAE3D,eAAO,MAAM,kBAAkB,IAAI,CAAA;;;;;;AAEnC,qBAAa,aAAc,SAAQ,kBAIjC;CAAG;;;;;AAEL,qBAAa,aAAc,SAAQ,kBAGjC;CAAG;AAEL,eAAO,MAAM,UAAU,qEAA+C,CAAA;AACtE,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA;AA8C/C,eAAO,MAAM,kBAAkB,GAAI,OAAO,aAAa,CAAC,SAAS,CAAC,KAAG,aAAa,CAAC,UAAU,CAgE5F,CAAA;AAID,eAAO,MAAM,SAAS,qjBAqCpB,CAAA;AAEF,eAAO,MAAM,mBAAmB,qGA6E9B,CAAA;AAEF,eAAO,MAAM,eAAe,gjBAM1B,CAAA"}
+{"version":3,"file":"Replay.d.ts","sourceRoot":"","sources":["../src/Replay.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AAC9D,OAAO,EAAY,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAE1D,OAAO,EAAE,cAAc,EAAE,wBAAwB,EAAkB,MAAM,gBAAgB,CAAA;AACzF,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAE3D,eAAO,MAAM,kBAAkB,IAAI,CAAA;;;;;;AAEnC,qBAAa,aAAc,SAAQ,kBAIjC;CAAG;;;;;AAEL,qBAAa,aAAc,SAAQ,kBAGjC;CAAG;AAEL,eAAO,MAAM,UAAU,qEAA+C,CAAA;AACtE,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA;AA8C/C,eAAO,MAAM,kBAAkB,GAAI,OAAO,aAAa,CAAC,SAAS,CAAC,KAAG,aAAa,CAAC,UAAU,CAgE5F,CAAA;AAID,eAAO,MAAM,SAAS,4wBAqCpB,CAAA;AAEF,eAAO,MAAM,mBAAmB,qGA6E9B,CAAA;AAEF,eAAO,MAAM,eAAe,uwBAM1B,CAAA"}

package/dist/Review.d.ts

@@ -51,7 +51,7 @@ export declare const llmDriven: (picker: LlmServiceShape) => ReviewerSelector;
 export declare const reviewPrompt: (task: string, diff: string) => string;
 export declare const fixPrompt: (result: ReviewResult) => string;
 export declare const mergeReviewResults: (results: ReadonlyArray<ReviewResult>) => ReviewResult;
-export declare const lintCommand: (process: ProcessExecutorShape, events: FlowEventsShape, command: readonly string[], workDir: string) => Effect.Effect<ReviewResult, import("./FlowError.ts").PersistenceError | import("./FlowError.ts").PlanParseError | import("./FlowError.ts").UnsupportedSchemaVersion | import("./FlowError.ts").WorkspacePathError | import("./FlowError.ts").WorkspaceLimitError | import("./FlowError.ts").WorkspaceIoError | import("./FlowError.ts").FlowAborted | ProcessError | FlowLlmError | import("./FlowError.ts").FlowCapabilityDenied | import("./FlowError.ts").ColumnNotFound | import("./FlowError.ts").BudgetExceeded, never>;
+export declare const lintCommand: (process: ProcessExecutorShape, events: FlowEventsShape, command: readonly string[], workDir: string) => Effect.Effect<ReviewResult, import("./FlowError.ts").PersistenceError | import("./FlowError.ts").PlanParseError | import("./FlowError.ts").UnsupportedSchemaVersion | import("./FlowError.ts").WorkspacePathError | import("./FlowError.ts").WorkspaceLimitError | import("./FlowError.ts").WorkspaceIoError | import("./FlowError.ts").FlowAborted | ProcessError | FlowLlmError | import("./FlowError.ts").FlowCapabilityDenied | import("./FlowError.ts").ColumnNotFound | import("./FlowError.ts").BudgetExceeded | import("./FlowError.ts").StoryPlanInvalid | import("./FlowError.ts").PerimeterViolation | import("./FlowError.ts").MissingDependency | import("./FlowError.ts").MergeConflict | import("./FlowError.ts").StoryFailed, never>;
 export interface ReviewAndFixOptions {
     readonly reviewers: ReadonlyArray<Reviewer>;
     readonly reviewerService: LlmServiceShape;
@@ -66,6 +66,6 @@ export interface ReviewAndFixOptions {
     readonly parallelism?: number;
     readonly format?: Effect.Effect<void, FlowError>;
 }
-export declare const reviewAndFixLoop: (options: ReviewAndFixOptions) => Effect.Effect<ReviewResult, import("./FlowError.ts").PersistenceError | import("./FlowError.ts").PlanParseError | import("./FlowError.ts").UnsupportedSchemaVersion | import("./FlowError.ts").WorkspacePathError | import("./FlowError.ts").WorkspaceLimitError | import("./FlowError.ts").WorkspaceIoError | import("./FlowError.ts").FlowAborted | ProcessError | FlowLlmError | import("./FlowError.ts").FlowCapabilityDenied | import("./FlowError.ts").ColumnNotFound | import("./FlowError.ts").BudgetExceeded, never>;
+export declare const reviewAndFixLoop: (options: ReviewAndFixOptions) => Effect.Effect<ReviewResult, import("./FlowError.ts").PersistenceError | import("./FlowError.ts").PlanParseError | import("./FlowError.ts").UnsupportedSchemaVersion | import("./FlowError.ts").WorkspacePathError | import("./FlowError.ts").WorkspaceLimitError | import("./FlowError.ts").WorkspaceIoError | import("./FlowError.ts").FlowAborted | ProcessError | FlowLlmError | import("./FlowError.ts").FlowCapabilityDenied | import("./FlowError.ts").ColumnNotFound | import("./FlowError.ts").BudgetExceeded | import("./FlowError.ts").StoryPlanInvalid | import("./FlowError.ts").PerimeterViolation | import("./FlowError.ts").MissingDependency | import("./FlowError.ts").MergeConflict | import("./FlowError.ts").StoryFailed, never>;
 export {};
 //# sourceMappingURL=Review.d.ts.map

package/dist/Review.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Review.d.ts","sourceRoot":"","sources":["../src/Review.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Review.d.ts","sourceRoot":"","sources":["../src/Review.ts"],"names":[],"mappings":"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"}

package/dist/ReviewCache.d.ts

@@ -2,5 +2,5 @@ import * as Effect from "effect/Effect";
 import { PersistenceError } from "./FlowError.ts";
 import type { PlainFileStoreShape } from "./Persistence.ts";
 import { ReviewResult } from "./Review.ts";
-export declare const cachedReview: <R>(files: PlainFileStoreShape, path: string, fingerprint: string, evaluate: Effect.Effect<ReviewResult, PersistenceError | import("./FlowError.ts").PlanParseError | import("./FlowError.ts").UnsupportedSchemaVersion | import("./FlowError.ts").WorkspacePathError | import("./FlowError.ts").WorkspaceLimitError | import("./FlowError.ts").WorkspaceIoError | import("./FlowError.ts").FlowAborted | import("./FlowError.ts").ProcessError | import("./FlowError.ts").FlowLlmError | import("./FlowError.ts").FlowCapabilityDenied | import("./FlowError.ts").ColumnNotFound | import("./FlowError.ts").BudgetExceeded, R>) => Effect.Effect<ReviewResult, PersistenceError | import("./FlowError.ts").PlanParseError | import("./FlowError.ts").UnsupportedSchemaVersion | import("./FlowError.ts").WorkspacePathError | import("./FlowError.ts").WorkspaceLimitError | import("./FlowError.ts").WorkspaceIoError | import("./FlowError.ts").FlowAborted | import("./FlowError.ts").ProcessError | import("./FlowError.ts").FlowLlmError | import("./FlowError.ts").FlowCapabilityDenied | import("./FlowError.ts").ColumnNotFound | import("./FlowError.ts").BudgetExceeded, R>;
+export declare const cachedReview: <R>(files: PlainFileStoreShape, path: string, fingerprint: string, evaluate: Effect.Effect<ReviewResult, PersistenceError | import("./FlowError.ts").PlanParseError | import("./FlowError.ts").UnsupportedSchemaVersion | import("./FlowError.ts").WorkspacePathError | import("./FlowError.ts").WorkspaceLimitError | import("./FlowError.ts").WorkspaceIoError | import("./FlowError.ts").FlowAborted | import("./FlowError.ts").ProcessError | import("./FlowError.ts").FlowLlmError | import("./FlowError.ts").FlowCapabilityDenied | import("./FlowError.ts").ColumnNotFound | import("./FlowError.ts").BudgetExceeded | import("./FlowError.ts").StoryPlanInvalid | import("./FlowError.ts").PerimeterViolation | import("./FlowError.ts").MissingDependency | import("./FlowError.ts").MergeConflict | import("./FlowError.ts").StoryFailed, R>) => Effect.Effect<ReviewResult, PersistenceError | import("./FlowError.ts").PlanParseError | import("./FlowError.ts").UnsupportedSchemaVersion | import("./FlowError.ts").WorkspacePathError | import("./FlowError.ts").WorkspaceLimitError | import("./FlowError.ts").WorkspaceIoError | import("./FlowError.ts").FlowAborted | import("./FlowError.ts").ProcessError | import("./FlowError.ts").FlowLlmError | import("./FlowError.ts").FlowCapabilityDenied | import("./FlowError.ts").ColumnNotFound | import("./FlowError.ts").BudgetExceeded | import("./FlowError.ts").StoryPlanInvalid | import("./FlowError.ts").PerimeterViolation | import("./FlowError.ts").MissingDependency | import("./FlowError.ts").MergeConflict | import("./FlowError.ts").StoryFailed, R>;
 //# sourceMappingURL=ReviewCache.d.ts.map

package/dist/ReviewCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReviewCache.d.ts","sourceRoot":"","sources":["../src/ReviewCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,gBAAgB,EAAkB,MAAM,gBAAgB,CAAA;AACjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAa1C,eAAO,MAAM,YAAY,GAA2D,CAAC,onCA2BnF,CAAA"}
+{"version":3,"file":"ReviewCache.d.ts","sourceRoot":"","sources":["../src/ReviewCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,gBAAgB,EAAkB,MAAM,gBAAgB,CAAA;AACjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAa1C,eAAO,MAAM,YAAY,GAA2D,CAAC,kiDA2BnF,CAAA"}

package/dist/Stories.d.ts

@@ -0,0 +1,109 @@
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+import * as Schema from "effect/Schema";
+import type * as Scope from "effect/Scope";
+import type { LlmServiceShape } from "@llm4ts/core/LlmService";
+import type { TokenUsage } from "@llm4ts/core/Models";
+import { type BoardSyncShape } from "./BoardSync.ts";
+import type { FlowContextShape } from "./FlowContext.ts";
+import { MissingDependency, StoryFailed, type FlowError } from "./FlowError.ts";
+import { type PlainFileStoreShape } from "./Persistence.ts";
+import type { Plan } from "./Plan.ts";
+import type { ReviewResult } from "./Review.ts";
+import type { Reviewer } from "./Reviewer.ts";
+import { type Story, type StoryPlan } from "./StoryPlan.ts";
+/** A flow context rooted in a story's worktree, plus that story's own usage totals. */
+export interface StorySeats {
+    readonly context: FlowContextShape;
+    /** Running usage of this story's seats — estimates where the backend reports none. */
+    readonly totals?: Effect.Effect<TokenUsage | undefined>;
+}
+export declare const StoryStateVersion = 1;
+export declare const StoryStatus: Schema.Literals<readonly ["started", "merged", "failed"]>;
+export type StoryStatus = typeof StoryStatus.Type;
+declare const StoryState_base: Schema.Class<StoryState, Schema.Struct<{
+    readonly id: Schema.String;
+    /** `storyHash` of the plan entry the branch was created from. */
+    readonly hash: Schema.String;
+    readonly branch: Schema.String;
+    readonly worktree: Schema.String;
+    readonly status: Schema.Literals<readonly ["started", "merged", "failed"]>;
+}>, {}>;
+/** What the executor remembers about a story between runs. */
+export declare class StoryState extends StoryState_base {
+}
+export declare const EpicReportVersion = 1;
+export declare const OutcomeStatus: Schema.Literals<readonly ["done", "failed", "skipped"]>;
+export type OutcomeStatus = typeof OutcomeStatus.Type;
+declare const StoryOutcome_base: Schema.Class<StoryOutcome, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly title: Schema.String;
+    readonly status: Schema.Literals<readonly ["done", "failed", "skipped"]>;
+    readonly branch: Schema.optionalKey<Schema.String>;
+    /** Failure or skip reason. */
+    readonly reason: Schema.optionalKey<Schema.String>;
+    readonly judge: Schema.optionalKey<Schema.String>;
+    /** ESTIMATES, never measurements (ADR 0012). */
+    readonly estimatedTokens: Schema.optionalKey<Schema.Int>;
+    readonly estimatedCostUsd: Schema.optionalKey<Schema.Number>;
+}>, {}>;
+export declare class StoryOutcome extends StoryOutcome_base {
+}
+declare const EpicReport_base: Schema.Class<EpicReport, Schema.Struct<{
+    readonly epicId: Schema.String;
+    readonly epicBranch: Schema.String;
+    /** Always true: the figures come from character-count estimates. */
+    readonly estimated: Schema.Boolean;
+    readonly stories: Schema.$Array<typeof StoryOutcome>;
+}>, {}>;
+export declare class EpicReport extends EpicReport_base {
+    count(status: OutcomeStatus): number;
+}
+export declare const renderEpicReport: (report: EpicReport) => string;
+export declare const blockedOnSentinel = "BLOCKED_ON:";
+/** The text after the sentinel, if the coder ended a turn with it. */
+export declare const blockedOnIn: (text: string) => string | undefined;
+/** The hard rules every story coder receives; the perimeter check enforces them afterwards. */
+export declare const perimeterRules: (story: Story) => string;
+export declare const storyPrompt: (story: Story) => string;
+export declare const storyTaskPlanInstructions: (story: Story) => string;
+/** The coder plans its own tasks from the story — the orchestrator split the epic, not the story. */
+export declare const defaultPlanTasks: (seats: StorySeats, story: Story, prompt: string) => Effect.Effect<Plan, FlowError>;
+/**
+ * A coder whose turns are watched for the `BLOCKED_ON:` sentinel. The story
+ * loop reads the ref after the coder stops, so a blocked turn ends the story
+ * as a typed `MissingDependency` instead of an empty-diff abort.
+ */
+export declare const watchForBlockedOn: (service: LlmServiceShape, blocked: Ref.Ref<string | undefined>) => LlmServiceShape;
+export interface StoriesOptions {
+    readonly plan: StoryPlan;
+    readonly files: PlainFileStoreShape;
+    /** The executor's own durable state: story states, task plans, the report. */
+    readonly stateDir: string;
+    /** Where story worktrees are created (`<worktreeRoot>/<story-id>`). */
+    readonly worktreeRoot: string;
+    /** Default `epic/<epicId>`. */
+    readonly epicBranch?: string;
+    /** Seats rooted in a worktree; the executor never resolves seats itself. */
+    readonly contextFor: (workDir: string) => Effect.Effect<StorySeats, FlowError, Scope.Scope>;
+    readonly board: BoardSyncShape;
+    /** The target's gates, run in a worktree per task and on the epic checkout after each merge. */
+    readonly gates: (workDir: string) => Effect.Effect<ReviewResult, FlowError>;
+    /** Story-level judge over the branch's diff against the epic branch; omit to skip. */
+    readonly judge?: (story: Story, diff: string) => Effect.Effect<ReviewResult, FlowError>;
+    /** Judge attempts, each but the last followed by one coder feedback round. Default 2. */
+    readonly judgeRounds?: number;
+    /** Extra system context per story (house rules, shared read-only excerpts). */
+    readonly system?: (story: Story) => Effect.Effect<string, FlowError>;
+    /** How a story's task plan is produced. Default: the story's own coder plans it. */
+    readonly planTasks?: (seats: StorySeats, story: Story, prompt: string) => Effect.Effect<Plan, FlowError>;
+    /** Stories implemented at once. Default 3. */
+    readonly concurrency?: number;
+    /** Stop the epic at the first failed story instead of skipping its dependents. */
+    readonly failFast?: boolean;
+    readonly reviewers?: ReadonlyArray<Reviewer>;
+    readonly maxRounds?: number;
+}
+export declare const implementStoriesFlow: (context: FlowContextShape, options: StoriesOptions) => Effect.Effect<EpicReport, import("./FlowError.ts").PersistenceError | import("./FlowError.ts").PlanParseError | import("./FlowError.ts").UnsupportedSchemaVersion | import("./FlowError.ts").WorkspacePathError | import("./FlowError.ts").WorkspaceLimitError | import("./FlowError.ts").WorkspaceIoError | import("./FlowError.ts").FlowAborted | import("./FlowError.ts").ProcessError | import("./FlowError.ts").FlowLlmError | import("./FlowError.ts").FlowCapabilityDenied | import("./FlowError.ts").ColumnNotFound | import("./FlowError.ts").BudgetExceeded | import("./FlowError.ts").StoryPlanInvalid | import("./FlowError.ts").PerimeterViolation | MissingDependency | import("./FlowError.ts").MergeConflict | StoryFailed, never>;
+export {};
+//# sourceMappingURL=Stories.d.ts.map

package/dist/Stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stories.d.ts","sourceRoot":"","sources":["../src/Stories.ts"],"names":[],"mappings":"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"}

package/dist/Stories.js

@@ -0,0 +1,432 @@
+// The parallel story executor (ADR 0013). One story = one worktree on its
+// own branch, created only once every predecessor has merged into the epic
+// branch; the inner loop is the unchanged `implementPlanFlow`; a story
+// merges back only after its judge and perimeter checks pass, and the
+// target's gates run on the epic branch after every merge. Scheduling,
+// gating, resume and failure policy live here; seats come from `contextFor`.
+import * as Effect from "effect/Effect";
+import * as Queue from "effect/Queue";
+import * as Ref from "effect/Ref";
+import * as Schema from "effect/Schema";
+import * as Semaphore from "effect/Semaphore";
+import * as Stream from "effect/Stream";
+import { BoardItem } from "./BoardSync.js";
+import { makeChat } from "./Chat.js";
+import { implementPlanFlow } from "./Flow.js";
+import { describeFlowError, MissingDependency, StoryFailed } from "./FlowError.js";
+import { Info } from "./FlowEvents.js";
+import { enforcePerimeter } from "./Perimeter.js";
+import { loadVersioned, makePlanStore, saveVersioned } from "./Persistence.js";
+import { stage } from "./PlanExecution.js";
+import { planFrom } from "./Planner.js";
+import { dependentsOf, readyStories, storyHash, topologicalWaves, validateStoryPlan } from "./StoryPlan.js";
+const join = (root, path) => `${root.replace(/[\\/]+$/, "")}/${path.replace(/^[\\/]+/, "")}`;
+// ---- Durable state ----------------------------------------------------------
+export const StoryStateVersion = 1;
+export const StoryStatus = Schema.Literals(["started", "merged", "failed"]);
+/** What the executor remembers about a story between runs. */
+export class StoryState extends Schema.Class("StoryState")({
+    id: Schema.String,
+    /** `storyHash` of the plan entry the branch was created from. */
+    hash: Schema.String,
+    branch: Schema.String,
+    worktree: Schema.String,
+    status: StoryStatus
+}) {
+}
+export const EpicReportVersion = 1;
+export const OutcomeStatus = Schema.Literals(["done", "failed", "skipped"]);
+export class StoryOutcome extends Schema.Class("StoryOutcome")({
+    id: Schema.String,
+    title: Schema.String,
+    status: OutcomeStatus,
+    branch: Schema.optionalKey(Schema.String),
+    /** Failure or skip reason. */
+    reason: Schema.optionalKey(Schema.String),
+    judge: Schema.optionalKey(Schema.String),
+    /** ESTIMATES, never measurements (ADR 0012). */
+    estimatedTokens: Schema.optionalKey(Schema.Int),
+    estimatedCostUsd: Schema.optionalKey(Schema.Number)
+}) {
+}
+export class EpicReport extends Schema.Class("EpicReport")({
+    epicId: Schema.String,
+    epicBranch: Schema.String,
+    /** Always true: the figures come from character-count estimates. */
+    estimated: Schema.Boolean,
+    stories: Schema.Array(StoryOutcome)
+}) {
+    count(status) {
+        return this.stories.filter((story) => story.status === status).length;
+    }
+}
+const money = (value) => `~$${value.toFixed(2)}`;
+export const renderEpicReport = (report) => {
+    const lines = [
+        `# Epic report: ${report.epicId}`,
+        "",
+        "> Token and cost figures are ESTIMATES from character counts (ADR 0012):",
+        "> the CLI seats report no usage. They are not measurements.",
+        "",
+        `- Epic branch: \`${report.epicBranch}\``,
+        `- Stories: ${report.stories.length} (done ${report.count("done")}, failed ${report.count("failed")}, skipped ${report.count("skipped")})`,
+        "",
+        "| Story | Status | Branch | Est. tokens | Est. cost | Note |",
+        "| --- | --- | --- | --- | --- | --- |"
+    ];
+    for (const story of report.stories) {
+        const note = story.reason ?? story.judge ?? "";
+        lines.push(`| ${story.id} | ${story.status} | ${story.branch === undefined ? "—" : `\`${story.branch}\``} | ${story.estimatedTokens === undefined ? "—" : `~${story.estimatedTokens}`} | ${story.estimatedCostUsd === undefined ? "—" : money(story.estimatedCostUsd)} | ${note.replace(/\|/g, "\\|").replace(/\s+/g, " ")} |`);
+    }
+    const tokens = report.stories.flatMap((story) => story.estimatedTokens === undefined ? [] : [story.estimatedTokens]);
+    const cost = report.stories.flatMap((story) => story.estimatedCostUsd === undefined ? [] : [story.estimatedCostUsd]);
+    lines.push("");
+    if (tokens.length > 0) {
+        lines.push(`- Estimated tokens: ~${tokens.reduce((sum, value) => sum + value, 0)}`);
+    }
+    if (cost.length > 0) {
+        lines.push(`- Estimated cost: ${money(cost.reduce((sum, value) => sum + value, 0))}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+};
+// ---- Prompts ----------------------------------------------------------------
+export const blockedOnSentinel = "BLOCKED_ON:";
+const blockedPattern = /BLOCKED_ON:\s*(.+)/;
+/** The text after the sentinel, if the coder ended a turn with it. */
+export const blockedOnIn = (text) => {
+    const match = blockedPattern.exec(text);
+    const need = match?.[1]?.trim();
+    return need === undefined || need.length === 0 ? undefined : need;
+};
+const bullets = (items) => items.length === 0 ? "- (none)" : items.map((item) => `- ${item}`).join("\n");
+/** The hard rules every story coder receives; the perimeter check enforces them afterwards. */
+export const perimeterRules = (story) => [
+    `You are implementing ONE story of a larger epic: "${story.title}" (id: ${story.id}).`,
+    "",
+    "Paths you own — create and change files only here:",
+    bullets(story.owned),
+    "",
+    "Shared paths — read them for conventions, NEVER modify them:",
+    bullets(story.sharedReadOnly),
+    "",
+    "What this story must provide for other stories:",
+    bullets(story.provides),
+    "",
+    "Rules:",
+    "- Do not touch any path outside the owned list; a change there fails the story.",
+    "- If the story needs something that does not exist and is not yours to build, do not",
+    `  build it. Reply with exactly \`${blockedOnSentinel} <what you need and which path>\` and stop.`,
+    "- Everything you provide must be implemented completely: other stories depend on it."
+].join("\n");
+export const storyPrompt = (story) => [`Story: ${story.title}`, "", story.description.trim()].join("\n");
+export const storyTaskPlanInstructions = (story) => [
+    "You are planning the implementation of ONE story inside a larger epic. Break the story",
+    "into an ordered list of small, independently verifiable tasks, each described by its",
+    "observable outcome. Every task must stay inside the story's owned paths.",
+    `Use exactly this epicId: "${story.id}".`,
+    'Respond only with JSON: {"epicId":"' + story.id + '","tasks":',
+    '[{"title":"...","description":"...","completed":false}]}'
+].join("\n");
+/** The coder plans its own tasks from the story — the orchestrator split the epic, not the story. */
+export const defaultPlanTasks = (seats, story, prompt) => planFrom(seats.context.coder, prompt, storyTaskPlanInstructions(story));
+// ---- BLOCKED_ON detection ---------------------------------------------------
+const watchStream = (stream, blocked) => Stream.unwrap(Effect.gen(function* () {
+    const text = yield* Ref.make("");
+    const tapped = stream.pipe(Stream.tap((chunk) => Ref.update(text, (current) => current + chunk.delta)));
+    const check = Stream.fromEffect(Effect.gen(function* () {
+        const need = blockedOnIn(yield* Ref.get(text));
+        if (need !== undefined) {
+            yield* Ref.set(blocked, need);
+        }
+    })).pipe(Stream.drain);
+    return Stream.concat(tapped, check);
+}));
+/**
+ * A coder whose turns are watched for the `BLOCKED_ON:` sentinel. The story
+ * loop reads the ref after the coder stops, so a blocked turn ends the story
+ * as a typed `MissingDependency` instead of an empty-diff abort.
+ */
+export const watchForBlockedOn = (service, blocked) => ({
+    ...service,
+    executeStream: (prompt) => watchStream(service.executeStream(prompt), blocked),
+    executeStreamWithHistory: (messages) => watchStream(service.executeStreamWithHistory(messages), blocked)
+});
+const issueLines = (result) => result.issues.map((issue) => `- ${issue.title}: ${issue.description}`).join("\n");
+const failed = (story, reason) => StoryFailed.make({ story: story.id, reason });
+// ---- The executor -------------------------------------------------------------
+export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(function* (context, options) {
+    const plan = yield* validateStoryPlan(options.plan);
+    const { files, board } = options;
+    const events = context.events;
+    const epicBranch = options.epicBranch ?? `epic/${plan.epicId}`;
+    const concurrency = Math.max(1, options.concurrency ?? 3);
+    const judgeRounds = Math.max(1, options.judgeRounds ?? 2);
+    const statePath = (story) => join(options.stateDir, `stories/${story.id}.json`);
+    const planPath = (story) => join(options.stateDir, `stories/${story.id}.plan.md`);
+    yield* stage(events, "epic branch", context.git.checkoutOrCreate(epicBranch));
+    const waves = topologicalWaves(plan);
+    const waveOf = (id) => {
+        const index = waves.findIndex((wave) => wave.includes(id));
+        return index < 0 ? undefined : `${index + 1}`;
+    };
+    yield* board.plan(plan.stories.map((story) => {
+        const wave = waveOf(story.id);
+        return BoardItem.make({
+            id: story.id,
+            title: story.title,
+            status: "planned",
+            ...(wave === undefined ? {} : { wave })
+        });
+    }));
+    const mergeLock = yield* Semaphore.make(1);
+    /** Merge the story branch into the epic branch and re-gate the epic head, one story at a time. */
+    const integrate = (story, branch) => mergeLock.withPermit(Effect.gen(function* () {
+        const checkpoint = yield* context.git.checkpoint;
+        yield* context.git.merge(branch, `${plan.epicId}: merge story ${story.id}`);
+        const gate = yield* options.gates(context.workDir);
+        if (!gate.isClean) {
+            // Never leave a red epic head for the next story to inherit.
+            yield* context.git.rollback(checkpoint);
+            return yield* failed(story, `epic gates failed after merging; merge undone:\n${issueLines(gate)}`);
+        }
+        yield* events.publish(Info.make({ message: `story ${story.id}: merged into ${epicBranch}` }));
+    }));
+    /** The worktree and branch for a story, honouring the hash-guarded resume rules. */
+    const prepareWorktree = Effect.fn("@llm4ts/flow/Stories.prepareWorktree")(function* (story) {
+        const hash = storyHash(story);
+        const branch = `story/${plan.epicId}/${story.id}`;
+        const worktree = join(options.worktreeRoot, story.id);
+        const path = statePath(story);
+        let stored = yield* loadVersioned(files, path, StoryStateVersion, StoryState);
+        if (stored !== undefined && stored.hash !== hash) {
+            yield* events.publish(Info.make({
+                message: `story ${story.id}: plan entry changed since its branch was created; starting over`
+            }));
+            // The old worktree may already be gone (an operator cleaned up); that is
+            // not a failure of this run, so removal errors are reported and dropped.
+            yield* context.git
+                .removeWorktree(stored.worktree, true)
+                .pipe(Effect.catch((error) => events.publish(Info.make({ message: `story ${story.id}: ${describeFlowError(error)}` }))));
+            if (yield* context.git.branchExists(stored.branch)) {
+                yield* context.git.deleteBranch(stored.branch);
+            }
+            stored = undefined;
+        }
+        if (stored !== undefined && stored.status === "merged") {
+            return { state: stored, alreadyMerged: true };
+        }
+        if (stored === undefined) {
+            yield* context.git.addWorktreeNewBranch(worktree, branch, epicBranch);
+            const state = StoryState.make({ id: story.id, hash, branch, worktree, status: "started" });
+            yield* saveVersioned(files, path, StoryStateVersion, StoryState, state);
+            return { state, alreadyMerged: false };
+        }
+        // Resume: the branch exists; the worktree may not (a worktree has a
+        // `.git` FILE at its root, which is how its presence is checked).
+        const marker = yield* files.read(join(stored.worktree, ".git"));
+        if (marker === undefined) {
+            yield* context.git.addWorktree(stored.worktree, stored.branch);
+        }
+        yield* events.publish(Info.make({ message: `story ${story.id}: resuming ${stored.branch}` }));
+        return { state: stored, alreadyMerged: false };
+    });
+    /** Everything that happens inside a story's worktree: plan, implement, judge, perimeter. */
+    const implementStory = Effect.fn("@llm4ts/flow/Stories.implementStory")(function* (story, state) {
+        const seats = yield* options.contextFor(state.worktree);
+        const blocked = yield* Ref.make(undefined);
+        const storyContext = {
+            ...seats.context,
+            coder: watchForBlockedOn(seats.context.coder, blocked)
+        };
+        const watchedSeats = { ...seats, context: storyContext };
+        const extra = options.system === undefined ? undefined : yield* options.system(story);
+        const system = [perimeterRules(story), extra]
+            .filter((part) => part !== undefined && part.trim().length > 0)
+            .join("\n\n");
+        const prompt = storyPrompt(story);
+        const blockedOr = (effect) => effect.pipe(Effect.catch((error) => Effect.flatMap(Ref.get(blocked), (need) => need === undefined
+            ? Effect.fail(error)
+            : Effect.fail(MissingDependency.make({ story: story.id, need })))), Effect.tap(() => Effect.flatMap(Ref.get(blocked), (need) => need === undefined
+            ? Effect.void
+            : Effect.fail(MissingDependency.make({ story: story.id, need })))));
+        yield* blockedOr(implementPlanFlow(storyContext, {
+            store: makePlanStore(files),
+            planPath: planPath(story),
+            plan: (options.planTasks ?? defaultPlanTasks)(watchedSeats, story, prompt),
+            system,
+            chatPerTask: true,
+            checkoutBranch: false,
+            lint: options.gates(state.worktree),
+            ...(options.reviewers === undefined ? {} : { reviewers: options.reviewers }),
+            ...(options.maxRounds === undefined ? {} : { maxRounds: options.maxRounds })
+        }));
+        let judgeNote;
+        if (options.judge !== undefined) {
+            const judge = options.judge;
+            for (let round = 1; round <= judgeRounds; round += 1) {
+                const diff = yield* storyContext.git.diffVsBase(epicBranch);
+                const verdict = yield* judge(story, diff);
+                if (verdict.isClean) {
+                    judgeNote = `judge cleared (round ${round})`;
+                    break;
+                }
+                if (round >= judgeRounds) {
+                    return yield* failed(story, `judge not cleared after ${judgeRounds} round(s):\n${issueLines(verdict)}`);
+                }
+                const feedback = yield* makeChat(storyContext.coder, {
+                    system,
+                    events,
+                    agent: "coder"
+                });
+                yield* blockedOr(feedback.ask([
+                    `The story "${story.title}" scored below the bar. Close these gaps without`,
+                    "weakening any test and without leaving your owned paths, then stop:",
+                    issueLines(verdict)
+                ].join("\n")));
+                const regated = yield* options.gates(state.worktree);
+                if (!regated.isClean) {
+                    return yield* failed(story, `gates broke while addressing judge feedback:\n${issueLines(regated)}`);
+                }
+                yield* storyContext.git.commitAll(`${story.id}: address judge feedback`);
+            }
+        }
+        const changed = yield* storyContext.git.changedFilesVsBase(epicBranch);
+        yield* enforcePerimeter(changed, story);
+        const totals = seats.totals === undefined ? undefined : yield* seats.totals;
+        return { judge: judgeNote, totals };
+    });
+    const runStory = Effect.fn("@llm4ts/flow/Stories.runStory")(function* (story) {
+        yield* board.start(story.id);
+        const { state, alreadyMerged } = yield* prepareWorktree(story);
+        if (alreadyMerged) {
+            yield* events.publish(Info.make({ message: `story ${story.id}: already merged; skipping` }));
+            return StoryOutcome.make({
+                id: story.id,
+                title: story.title,
+                status: "done",
+                branch: state.branch,
+                judge: "merged on a previous run"
+            });
+        }
+        const result = yield* Effect.scoped(implementStory(story, state));
+        yield* integrate(story, state.branch);
+        yield* saveVersioned(files, statePath(story), StoryStateVersion, StoryState, StoryState.make({ ...state, status: "merged" }));
+        return StoryOutcome.make({
+            id: story.id,
+            title: story.title,
+            status: "done",
+            branch: state.branch,
+            ...(result.judge === undefined ? {} : { judge: result.judge }),
+            ...(result.totals === undefined ? {} : { estimatedTokens: result.totals.total }),
+            ...(result.totals?.costUsd === undefined ? {} : { estimatedCostUsd: result.totals.costUsd })
+        });
+    });
+    /** A story's run as a completion — failures become outcomes, never fiber deaths. */
+    const attempt = (story) => stage(events, `story ${story.id}`, runStory(story)).pipe(Effect.map((outcome) => ({ story, outcome })), Effect.catch((error) => Effect.gen(function* () {
+        const reason = describeFlowError(error);
+        const path = statePath(story);
+        const stored = yield* loadVersioned(files, path, StoryStateVersion, StoryState).pipe(Effect.catch(() => Effect.succeed(undefined)));
+        if (stored !== undefined && stored.status !== "merged") {
+            yield* saveVersioned(files, path, StoryStateVersion, StoryState, StoryState.make({ ...stored, status: "failed" })).pipe(Effect.ignore);
+        }
+        return {
+            story,
+            outcome: StoryOutcome.make({
+                id: story.id,
+                title: story.title,
+                status: "failed",
+                reason,
+                ...(stored === undefined ? {} : { branch: stored.branch })
+            })
+        };
+    })));
+    const outcomes = yield* Ref.make([]);
+    const running = yield* Ref.make(new Set());
+    const completions = yield* Queue.unbounded();
+    const progress = Effect.gen(function* () {
+        const known = yield* Ref.get(outcomes);
+        const byStatus = (status) => new Set(known.filter((outcome) => outcome.status === status).map((outcome) => outcome.id));
+        return {
+            done: byStatus("done"),
+            failed: byStatus("failed"),
+            skipped: byStatus("skipped"),
+            running: yield* Ref.get(running)
+        };
+    });
+    const record = (outcome) => Ref.update(outcomes, (current) => [...current, outcome]);
+    const skipDependents = (story) => Effect.gen(function* () {
+        const current = yield* progress;
+        for (const id of dependentsOf(plan, story.id)) {
+            const dependent = plan.story(id);
+            if (dependent === undefined ||
+                current.done.has(id) ||
+                current.failed.has(id) ||
+                current.skipped.has(id)) {
+                continue;
+            }
+            const reason = `blocked by ${story.id}`;
+            yield* record(StoryOutcome.make({ id, title: dependent.title, status: "skipped", reason }));
+            yield* board.skip(id, reason);
+        }
+    });
+    yield* Effect.scoped(Effect.gen(function* () {
+        while (true) {
+            const current = yield* progress;
+            const ready = readyStories(plan, current);
+            const slots = concurrency - current.running.size;
+            for (const story of ready.slice(0, Math.max(0, slots))) {
+                yield* Ref.update(running, (set) => new Set([...set, story.id]));
+                yield* Effect.forkScoped(attempt(story).pipe(Effect.flatMap((completion) => Queue.offer(completions, completion))));
+            }
+            if ((yield* Ref.get(running)).size === 0) {
+                break;
+            }
+            const completion = yield* Queue.take(completions);
+            yield* Ref.update(running, (set) => {
+                const next = new Set(set);
+                next.delete(completion.story.id);
+                return next;
+            });
+            yield* record(completion.outcome);
+            const outcome = completion.outcome;
+            if (outcome.status === "done") {
+                yield* board.complete(outcome.id, {
+                    ...(outcome.branch === undefined ? {} : { branch: outcome.branch }),
+                    ...(outcome.judge === undefined ? {} : { detail: outcome.judge }),
+                    ...(outcome.estimatedTokens === undefined
+                        ? {}
+                        : { estimatedTokens: outcome.estimatedTokens }),
+                    ...(outcome.estimatedCostUsd === undefined
+                        ? {}
+                        : { estimatedCostUsd: outcome.estimatedCostUsd })
+                });
+            }
+            else {
+                yield* board.fail(outcome.id, outcome.reason ?? "failed");
+                if (options.failFast === true) {
+                    return yield* StoryFailed.make({
+                        story: outcome.id,
+                        reason: outcome.reason ?? "failed"
+                    });
+                }
+                yield* skipDependents(completion.story);
+            }
+        }
+    }));
+    const recorded = yield* Ref.get(outcomes);
+    const ordered = plan.stories.flatMap((story) => {
+        const outcome = recorded.find((candidate) => candidate.id === story.id);
+        return outcome === undefined ? [] : [outcome];
+    });
+    const report = EpicReport.make({
+        epicId: plan.epicId,
+        epicBranch,
+        estimated: true,
+        stories: ordered
+    });
+    yield* saveVersioned(files, join(options.stateDir, "report.json"), EpicReportVersion, EpicReport, report);
+    yield* files.writeAtomic(join(options.stateDir, "report.md"), renderEpicReport(report));
+    return report;
+});
+//# sourceMappingURL=Stories.js.map