issue-flow 0.8.0 → 0.10.0

package/dist/{chunk-BH7DYADV.js → chunk-V5OHFSW4.js}

@@ -1,195 +1,259 @@
 #!/usr/bin/env node
 
-// src/schemas.ts
+// src/policy/schemas.ts
 import { z } from "zod";
-var claudeUsageSchema = z.object({
-  inputTokens: z.number().optional(),
-  outputTokens: z.number().optional(),
-  cacheReadTokens: z.number().optional(),
-  cacheCreationTokens: z.number().optional(),
-  costUsd: z.number().optional()
+var policyDiscoveryConfigSchema = z.object({
+  issueTemplates: z.boolean().default(true),
+  pullRequestTemplate: z.boolean().default(true),
+  docs: z.boolean().default(true),
+  codeowners: z.boolean().default(true),
+  labels: z.boolean().default(true),
+  issueTypes: z.boolean().default(true)
+});
+var policyIssuesDeclarationSchema = z.object({
+  titleConvention: z.string().min(1).optional()
+});
+var policyPullRequestsDeclarationSchema = z.object({
+  baseBranch: z.string().min(1).optional(),
+  titleConvention: z.string().min(1).optional()
+});
+var policyGitDeclarationSchema = z.object({
+  branchConvention: z.string().min(1).optional(),
+  commitConvention: z.string().min(1).optional()
 });
-var userStoryStatusSchema = z.enum(["backlog", "in_progress", "in_review", "done"]);
-var userStorySchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  description: z.string(),
-  acceptanceCriteria: z.array(z.string()),
-  priority: z.number().int().positive(),
-  passes: z.boolean(),
-  notes: z.string(),
+var policyConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  discovery: policyDiscoveryConfigSchema.prefault({}),
+  issues: policyIssuesDeclarationSchema.prefault({}),
+  pullRequests: policyPullRequestsDeclarationSchema.prefault({}),
+  git: policyGitDeclarationSchema.prefault({})
+});
+var policyConfigInputSchema = z.object({
+  enabled: z.boolean().optional(),
+  // Spelled out rather than `policyDiscoveryConfigSchema.partial()`: in zod 4
+  // a `.default()` survives `.partial()`, so every toggle would come back
+  // materialized and the input layer would stop meaning "what the user wrote".
+  discovery: z.object({
+    issueTemplates: z.boolean().optional(),
+    pullRequestTemplate: z.boolean().optional(),
+    docs: z.boolean().optional(),
+    codeowners: z.boolean().optional(),
+    labels: z.boolean().optional(),
+    issueTypes: z.boolean().optional()
+  }).optional(),
+  issues: z.object({ titleConvention: z.string().nullish() }).optional(),
+  pullRequests: z.object({ baseBranch: z.string().nullish(), titleConvention: z.string().nullish() }).optional(),
+  git: z.object({ branchConvention: z.string().nullish(), commitConvention: z.string().nullish() }).optional()
+});
+
+// src/schemas.ts
+import { z as z2 } from "zod";
+var claudeUsageSchema = z2.object({
+  inputTokens: z2.number().optional(),
+  outputTokens: z2.number().optional(),
+  cacheReadTokens: z2.number().optional(),
+  cacheCreationTokens: z2.number().optional(),
+  costUsd: z2.number().optional()
+});
+var userStoryStatusSchema = z2.enum(["backlog", "in_progress", "in_review", "done"]);
+var storyStageSchema = z2.enum([
+  "pending",
+  "executing",
+  "awaiting_review",
+  "in_review",
+  "in_correction",
+  "done",
+  "failed"
+]);
+var userStorySchema = z2.object({
+  id: z2.string(),
+  title: z2.string(),
+  description: z2.string(),
+  acceptanceCriteria: z2.array(z2.string()),
+  priority: z2.number().int().positive(),
+  passes: z2.boolean(),
+  notes: z2.string(),
   ...claudeUsageSchema.shape,
-  durationSeconds: z.number().optional(),
+  durationSeconds: z2.number().optional(),
   status: userStoryStatusSchema.optional(),
-  dependencies: z.array(z.string()).optional()
+  dependencies: z2.array(z2.string()).optional(),
+  stage: storyStageSchema.optional(),
+  stageSince: z2.string().optional(),
+  stageDetail: z2.string().optional()
 });
-var pipelineStateSchema = z.object({
-  analyzeCompleted: z.boolean().optional(),
-  prdCompleted: z.boolean(),
-  jsonCompleted: z.boolean(),
-  executionCompleted: z.boolean(),
-  reviewCompleted: z.boolean(),
-  prCreated: z.boolean(),
-  prReviewCompleted: z.boolean().optional()
+var pipelineStateSchema = z2.object({
+  analyzeCompleted: z2.boolean().optional(),
+  prdCompleted: z2.boolean(),
+  jsonCompleted: z2.boolean(),
+  executionCompleted: z2.boolean(),
+  reviewCompleted: z2.boolean(),
+  prCreated: z2.boolean(),
+  prReviewCompleted: z2.boolean().optional()
 });
-var pullRequestRefSchema = z.object({
-  number: z.number().int().positive(),
-  url: z.string(),
-  headBranch: z.string(),
-  createdAt: z.string()
+var pullRequestRefSchema = z2.object({
+  number: z2.number().int().positive(),
+  url: z2.string(),
+  headBranch: z2.string(),
+  createdAt: z2.string()
 });
-var prReviewRecommendationSchema = z.enum([
+var prReviewRecommendationSchema = z2.enum([
   "APPROVE",
   "APPROVE_WITH_SUGGESTIONS",
   "REQUEST_CHANGES"
 ]);
-var prReviewStateSchema = z.object({
-  enabled: z.boolean().default(false),
-  pullRequestNumber: z.number().int().positive().optional(),
-  rounds: z.number().int().min(0).default(0),
+var prReviewStateSchema = z2.object({
+  enabled: z2.boolean().default(false),
+  pullRequestNumber: z2.number().int().positive().optional(),
+  rounds: z2.number().int().min(0).default(0),
   lastRecommendation: prReviewRecommendationSchema.optional(),
-  lastReviewedAt: z.string().optional()
+  lastReviewedAt: z2.string().optional()
 });
-var lastErrorSchema = z.object({
-  category: z.string(),
-  message: z.string(),
-  at: z.string()
+var lastErrorSchema = z2.object({
+  category: z2.string(),
+  message: z2.string(),
+  at: z2.string()
 });
-var issueMetadataSchema = z.object({
-  schemaVersion: z.literal(1),
-  id: z.string().min(1),
-  number: z.number().int().positive().nullable(),
-  source: z.enum(["github", "local"]),
-  title: z.string(),
-  labels: z.array(z.string()),
-  state: z.enum(["open", "closed"]),
-  createdAt: z.string(),
-  updatedAt: z.string(),
-  contentHash: z.string(),
-  remote: z.object({
-    provider: z.enum(["github", "local"]),
-    ref: z.string(),
-    syncedAt: z.string(),
-    syncedContentHash: z.string()
+var issueMetadataSchema = z2.object({
+  schemaVersion: z2.literal(1),
+  id: z2.string().min(1),
+  number: z2.number().int().positive().nullable(),
+  source: z2.enum(["github", "local"]),
+  title: z2.string(),
+  labels: z2.array(z2.string()),
+  state: z2.enum(["open", "closed"]),
+  createdAt: z2.string(),
+  updatedAt: z2.string(),
+  contentHash: z2.string(),
+  remote: z2.object({
+    provider: z2.enum(["github", "local"]),
+    ref: z2.string(),
+    syncedAt: z2.string(),
+    syncedContentHash: z2.string()
   }).optional()
 });
-var taskPlanSchema = z.object({
-  project: z.string(),
-  issueNumber: z.union([z.number().int().positive(), z.string().min(1)]),
-  issueUrl: z.string().optional().default(""),
-  branchName: z.string(),
-  noBranch: z.boolean().optional().default(false),
-  description: z.string(),
-  issueStatus: z.enum(["pending", "in_progress", "completed"]),
-  completedAt: z.string().nullable(),
-  lastAttemptAt: z.string().nullable(),
+var taskPlanSchema = z2.object({
+  project: z2.string(),
+  issueNumber: z2.union([z2.number().int().positive(), z2.string().min(1)]),
+  issueUrl: z2.string().optional().default(""),
+  branchName: z2.string(),
+  noBranch: z2.boolean().optional().default(false),
+  description: z2.string(),
+  issueStatus: z2.enum(["pending", "in_progress", "completed"]),
+  completedAt: z2.string().nullable(),
+  lastAttemptAt: z2.string().nullable(),
   lastError: lastErrorSchema.nullable(),
-  correctionCycle: z.number().int().min(0),
-  maxCorrectionCycles: z.number().int().min(0),
+  correctionCycle: z2.number().int().min(0),
+  maxCorrectionCycles: z2.number().int().min(0),
   /**
    * Findings from the most recent failed review, verbatim. Non-null means the
    * issue has a pending correction even if every userStories[].passes is
    * already true — the execute phase must address these before the field is
    * cleared back to null. See core/engine.ts's early-return guards.
    */
-  lastReviewFindings: z.string().nullable().optional().default(null),
+  lastReviewFindings: z2.string().nullable().optional().default(null),
   pipeline: pipelineStateSchema,
   pullRequest: pullRequestRefSchema.optional(),
   prReview: prReviewStateSchema.optional(),
-  userStories: z.array(userStorySchema)
+  userStories: z2.array(userStorySchema)
 });
-var headlessResultSchema = z.object({
-  success: z.boolean(),
-  result: z.string(),
+var headlessResultSchema = z2.object({
+  success: z2.boolean(),
+  result: z2.string(),
   cost: claudeUsageSchema.nullable(),
-  error: z.string().nullable()
+  error: z2.string().nullable()
 });
-var sessionLogEntrySchema = z.object({
-  at: z.string(),
-  level: z.enum(["info", "warn", "error"]),
-  message: z.string()
+var sessionLogEntrySchema = z2.object({
+  at: z2.string(),
+  level: z2.enum(["info", "warn", "error"]),
+  message: z2.string()
 });
 var sessionUsageShape = {
-  inputTokens: z.number().nullable().default(null),
-  outputTokens: z.number().nullable().default(null),
-  cacheReadTokens: z.number().nullable().default(null),
-  cacheCreationTokens: z.number().nullable().default(null),
-  costUsd: z.number().nullable().default(null)
+  inputTokens: z2.number().nullable().default(null),
+  outputTokens: z2.number().nullable().default(null),
+  cacheReadTokens: z2.number().nullable().default(null),
+  cacheCreationTokens: z2.number().nullable().default(null),
+  costUsd: z2.number().nullable().default(null)
 };
-var sessionPhaseSchema = z.object({
-  name: z.string(),
-  status: z.enum(["pending", "running", "completed", "failed"]),
-  startedAt: z.string().nullable(),
-  endedAt: z.string().nullable(),
-  durationSeconds: z.number().nullable(),
-  error: z.string().nullable(),
+var sessionPhaseSchema = z2.object({
+  name: z2.string(),
+  status: z2.enum(["pending", "running", "completed", "failed"]),
+  startedAt: z2.string().nullable(),
+  endedAt: z2.string().nullable(),
+  durationSeconds: z2.number().nullable(),
+  error: z2.string().nullable(),
   ...sessionUsageShape
 });
-var sessionStorySchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  priority: z.number(),
-  passes: z.boolean(),
-  completedAt: z.string().nullable(),
+var sessionStorySchema = z2.object({
+  id: z2.string(),
+  title: z2.string(),
+  priority: z2.number(),
+  passes: z2.boolean(),
+  completedAt: z2.string().nullable(),
   // Also introduced with the metrics, hence the same tolerant default.
-  durationSeconds: z.number().nullable().default(null),
+  durationSeconds: z2.number().nullable().default(null),
   // Snapshot fields are always present on output and defaulted on input, so a
   // session.json written before they existed still parses. This is the mirror
   // image of userStorySchema, where the same two fields are plainly optional.
   status: userStoryStatusSchema.default("backlog"),
-  dependencies: z.array(z.string()).default([]),
+  dependencies: z2.array(z2.string()).default([]),
   // Published for the panel's story detail view. Same tolerant default as the
   // fields above: absent (older session.json) and empty resolve to the same
   // value, so the client never has to tell them apart.
-  description: z.string().default(""),
-  acceptanceCriteria: z.array(z.string()).default([]),
+  description: z2.string().default(""),
+  acceptanceCriteria: z2.array(z2.string()).default([]),
+  // Additive like the rest of this schema: a session.json written before
+  // `stage` existed parses into 'pending'/null, the same values a fresh
+  // snapshot starts a story at.
+  stage: storyStageSchema.default("pending"),
+  stageSince: z2.string().nullable().default(null),
+  stageDetail: z2.string().nullable().default(null),
   ...sessionUsageShape
 });
-var sessionSnapshotSchema = z.object({
-  schemaVersion: z.literal(1),
-  sessionId: z.string().nullable(),
-  readOnly: z.literal(true),
-  capabilities: z.array(z.string()),
-  issue: z.object({
-    number: z.number().nullable(),
-    url: z.string().nullable(),
+var sessionSnapshotSchema = z2.object({
+  schemaVersion: z2.literal(1),
+  sessionId: z2.string().nullable(),
+  readOnly: z2.literal(true),
+  capabilities: z2.array(z2.string()),
+  issue: z2.object({
+    number: z2.number().nullable(),
+    url: z2.string().nullable(),
     // Additive: a session.json written before the Issue section was enriched
     // parses into the same "not reported" values createInitialSnapshot() uses.
-    title: z.string().nullable().default(null),
-    description: z.string().nullable().default(null),
-    labels: z.array(z.string()).default([]),
-    state: z.string().nullable().default(null)
+    title: z2.string().nullable().default(null),
+    description: z2.string().nullable().default(null),
+    labels: z2.array(z2.string()).default([]),
+    state: z2.string().nullable().default(null)
   }),
-  status: z.enum(["idle", "running", "completed", "failed"]),
-  startedAt: z.string().nullable(),
-  updatedAt: z.string().nullable(),
-  endedAt: z.string().nullable(),
-  elapsedSeconds: z.number().nullable(),
-  estimatedRemainingSeconds: z.number().nullable(),
-  progress: z.object({
-    percent: z.number(),
-    phasesCompleted: z.number(),
-    phasesTotal: z.number(),
-    storiesCompleted: z.number(),
-    storiesTotal: z.number()
+  status: z2.enum(["idle", "running", "completed", "failed"]),
+  startedAt: z2.string().nullable(),
+  updatedAt: z2.string().nullable(),
+  endedAt: z2.string().nullable(),
+  elapsedSeconds: z2.number().nullable(),
+  estimatedRemainingSeconds: z2.number().nullable(),
+  progress: z2.object({
+    percent: z2.number(),
+    phasesCompleted: z2.number(),
+    phasesTotal: z2.number(),
+    storiesCompleted: z2.number(),
+    storiesTotal: z2.number()
   }),
-  currentPhase: z.string().nullable(),
-  currentActivity: z.object({
-    story: z.string().nullable(),
-    tool: z.string().nullable(),
-    detail: z.string().nullable(),
-    since: z.string()
+  currentPhase: z2.string().nullable(),
+  currentActivity: z2.object({
+    story: z2.string().nullable(),
+    tool: z2.string().nullable(),
+    detail: z2.string().nullable(),
+    since: z2.string()
   }).nullable(),
-  phases: z.array(sessionPhaseSchema),
-  stories: z.array(sessionStorySchema),
+  phases: z2.array(sessionPhaseSchema),
+  stories: z2.array(sessionStorySchema),
   // The whole aggregate is additive: a snapshot from before it existed parses
   // into the same "nothing reported" object the reducer starts from.
-  metrics: z.object({
-    totalInputTokens: z.number().nullable().default(null),
-    totalOutputTokens: z.number().nullable().default(null),
-    totalCacheReadTokens: z.number().nullable().default(null),
-    totalCacheCreationTokens: z.number().nullable().default(null),
-    totalCostUsd: z.number().nullable().default(null)
+  metrics: z2.object({
+    totalInputTokens: z2.number().nullable().default(null),
+    totalOutputTokens: z2.number().nullable().default(null),
+    totalCacheReadTokens: z2.number().nullable().default(null),
+    totalCacheCreationTokens: z2.number().nullable().default(null),
+    totalCostUsd: z2.number().nullable().default(null)
   }).default({
     totalInputTokens: null,
     totalOutputTokens: null,
@@ -197,51 +261,51 @@ var sessionSnapshotSchema = z.object({
     totalCacheCreationTokens: null,
     totalCostUsd: null
   }),
-  execution: z.object({
-    iteration: z.number(),
-    retries: z.number(),
-    correctionCycle: z.number(),
-    maxCorrectionCycles: z.number().nullable()
+  execution: z2.object({
+    iteration: z2.number(),
+    retries: z2.number(),
+    correctionCycle: z2.number(),
+    maxCorrectionCycles: z2.number().nullable()
   }),
-  git: z.object({
-    branch: z.string().nullable(),
-    baseBranch: z.string().nullable(),
-    commits: z.array(z.object({ hash: z.string(), subject: z.string() }))
+  git: z2.object({
+    branch: z2.string().nullable(),
+    baseBranch: z2.string().nullable(),
+    commits: z2.array(z2.object({ hash: z2.string(), subject: z2.string() }))
   }),
   // Additive like the metrics aggregate: a session.json written before the
   // repository section existed parses into the same all-null object
   // createInitialSnapshot() starts from.
-  repository: z.object({
-    name: z.string().nullable().default(null),
-    remoteUrl: z.string().nullable().default(null),
-    branch: z.string().nullable().default(null),
-    headCommit: z.string().nullable().default(null),
-    root: z.string().nullable().default(null)
+  repository: z2.object({
+    name: z2.string().nullable().default(null),
+    remoteUrl: z2.string().nullable().default(null),
+    branch: z2.string().nullable().default(null),
+    headCommit: z2.string().nullable().default(null),
+    root: z2.string().nullable().default(null)
   }).default({ name: null, remoteUrl: null, branch: null, headCommit: null, root: null }),
-  pullRequests: z.array(z.object({ number: z.number(), url: z.string(), title: z.string() })),
-  logs: z.array(sessionLogEntrySchema),
-  errors: z.array(sessionLogEntrySchema),
-  warnings: z.array(sessionLogEntrySchema),
-  lastError: z.object({ message: z.string(), at: z.string() }).nullable(),
-  nextSteps: z.array(z.string()),
-  environment: z.object({ node: z.string(), platform: z.string() }).nullable()
+  pullRequests: z2.array(z2.object({ number: z2.number(), url: z2.string(), title: z2.string() })),
+  logs: z2.array(sessionLogEntrySchema),
+  errors: z2.array(sessionLogEntrySchema),
+  warnings: z2.array(sessionLogEntrySchema),
+  lastError: z2.object({ message: z2.string(), at: z2.string() }).nullable(),
+  nextSteps: z2.array(z2.string()),
+  environment: z2.object({ node: z2.string(), platform: z2.string() }).nullable()
 });
-var webConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  port: z.number().int().min(1).max(65535).default(3737),
-  host: z.string().min(1).default("0.0.0.0"),
-  refreshSeconds: z.number().positive().default(5),
-  logLimit: z.number().int().positive().default(200),
-  includeLogs: z.boolean().default(true)
+var webConfigSchema = z2.object({
+  enabled: z2.boolean().default(false),
+  port: z2.number().int().min(1).max(65535).default(3737),
+  host: z2.string().min(1).default("0.0.0.0"),
+  refreshSeconds: z2.number().positive().default(5),
+  logLimit: z2.number().int().positive().default(200),
+  includeLogs: z2.boolean().default(true)
 });
-var issuesConfigSchema = z.object({
-  defaultGenerateTarget: z.enum(["github", "local", "both"]).default("github"),
-  preferredProvider: z.enum(["github", "local"]).default("github"),
-  conflictPolicy: z.enum(["ask", "prefer-local", "prefer-github"]).default("ask"),
-  requireConfirmation: z.boolean().default(true)
+var issuesConfigSchema = z2.object({
+  defaultGenerateTarget: z2.enum(["github", "local", "both"]).default("github"),
+  preferredProvider: z2.enum(["github", "local"]).default("github"),
+  conflictPolicy: z2.enum(["ask", "prefer-local", "prefer-github"]).default("ask"),
+  requireConfirmation: z2.boolean().default(true)
 });
-var prReviewConfigSchema = z.object({
-  publisher: z.enum(["local"]).default("local")
+var prReviewConfigSchema = z2.object({
+  publisher: z2.enum(["local"]).default("local")
 });
 
 // src/core/session-state.ts
@@ -378,6 +442,22 @@ function reduceSessionEvent(snapshot, event, options) {
     nextSteps: deriveNextSteps(next)
   };
 }
+function isTerminalStage(stage) {
+  return stage === "done" || stage === "failed";
+}
+function deriveStageOnStoriesUpdate(story, before, at) {
+  if (!story.passes) {
+    return {
+      stage: before?.stage ?? "pending",
+      stageSince: before?.stageSince ?? at,
+      stageDetail: before?.stageDetail ?? null
+    };
+  }
+  if (before?.passes) {
+    return { stage: before.stage, stageSince: before.stageSince, stageDetail: before.stageDetail };
+  }
+  return { stage: "awaiting_review", stageSince: at, stageDetail: null };
+}
 function applyEvent(snapshot, event, options) {
   switch (event.type) {
     case "session:start": {
@@ -448,10 +528,14 @@ function applyEvent(snapshot, event, options) {
           ...emptyUsage()
         }
       ];
+      const stories = event.phase === "review" ? snapshot.stories.map(
+        (story) => story.passes ? { ...story, stage: "in_review", stageSince: event.at, stageDetail: null } : story
+      ) : snapshot.stories;
       return {
         ...snapshot,
         currentPhase: event.phase,
         phases,
+        stories,
         progress: known ? snapshot.progress : { ...snapshot.progress, phasesTotal: phases.length }
       };
     }
@@ -466,11 +550,17 @@ function applyEvent(snapshot, event, options) {
         } : p
       );
       const phasesCompleted = phases.filter((p) => p.status === "completed").length;
+      const stories = !event.success ? snapshot.stories.map(
+        (story) => isTerminalStage(story.stage) ? story : { ...story, stage: "failed", stageSince: event.at, stageDetail: null }
+      ) : event.phase === "review" ? snapshot.stories.map(
+        (story) => story.passes ? { ...story, stage: "done", stageSince: event.at, stageDetail: null } : story
+      ) : snapshot.stories;
       return {
         ...snapshot,
         currentPhase: snapshot.currentPhase === event.phase ? null : snapshot.currentPhase,
         currentActivity: null,
         phases,
+        stories,
         progress: {
           ...snapshot.progress,
           phasesCompleted,
@@ -478,11 +568,27 @@ function applyEvent(snapshot, event, options) {
         }
       };
     }
-    case "iteration:start":
+    case "iteration:start": {
+      const storyId = event.storyId;
+      const stories = snapshot.stories.map((story) => {
+        if (story.passes) return story;
+        if (story.id === storyId) {
+          return story.stage === "executing" ? story : { ...story, stage: "executing", stageSince: event.at, stageDetail: null };
+        }
+        return story.stage === "pending" ? story : { ...story, stage: "pending", stageSince: event.at, stageDetail: null };
+      });
       return {
         ...snapshot,
-        execution: { ...snapshot.execution, iteration: event.iteration }
+        execution: { ...snapshot.execution, iteration: event.iteration },
+        stories,
+        // Finally populates the `story` field of the activity payload during
+        // execute — today this phase never publishes an `activity` event at
+        // all (no streaming), so `currentActivity` stays whatever an earlier
+        // phase left it at. Left untouched when storyId is absent (every
+        // story already passes, or the caller could not determine one).
+        currentActivity: storyId !== void 0 ? { story: storyId, tool: null, detail: null, since: event.at } : snapshot.currentActivity
       };
+    }
     case "iteration:end":
       return { ...snapshot, currentActivity: null };
     case "retry":
@@ -516,7 +622,8 @@ function applyEvent(snapshot, event, options) {
           outputTokens: before?.outputTokens ?? null,
           cacheReadTokens: before?.cacheReadTokens ?? null,
           cacheCreationTokens: before?.cacheCreationTokens ?? null,
-          costUsd: before?.costUsd ?? null
+          costUsd: before?.costUsd ?? null,
+          ...deriveStageOnStoriesUpdate(story, before, event.at)
         };
       });
       return {
@@ -566,15 +673,21 @@ function applyEvent(snapshot, event, options) {
         },
         pullRequests: event.pullRequests ?? snapshot.pullRequests
       };
-    case "correction:cycle":
+    case "correction:cycle": {
+      const stageDetail = `Cycle ${event.cycle}/${event.maxCycles}`;
+      const stories = snapshot.stories.map(
+        (story) => story.passes ? { ...story, stage: "in_correction", stageSince: event.at, stageDetail } : story
+      );
       return {
         ...snapshot,
         execution: {
           ...snapshot.execution,
           correctionCycle: event.cycle,
           maxCorrectionCycles: event.maxCycles
-        }
+        },
+        stories
       };
+    }
     case "metrics:update": {
       if (event.scope === "story") {
         if (event.storyId === void 0) return snapshot;
@@ -620,6 +733,15 @@ function applyEvent(snapshot, event, options) {
         endedAt: event.at,
         currentPhase: null,
         currentActivity: null,
+        // Close every non-terminal stage: the run is over, so nothing can be
+        // 'executing'/'in_review'/'in_correction' any more. A story that never
+        // reached `passes` on a run that did not complete is exactly what the
+        // 'failed' stage means; anything else settles as 'done'.
+        stories: snapshot.stories.map((story) => {
+          if (isTerminalStage(story.stage)) return story;
+          const stage = event.status === "completed" && story.passes ? "done" : "failed";
+          return { ...story, stage, stageSince: event.at, stageDetail: null };
+        }),
         lastError: event.error ? { message: stripVTControlCharacters(event.error), at: event.at } : snapshot.lastError
       };
     default:
@@ -930,6 +1052,9 @@ function allStoriesPass(plan) {
   }
   return plan.userStories.every((story) => story.passes === true);
 }
+function selectActiveStory(stories) {
+  return [...stories].filter((story) => !story.passes).sort((a, b) => a.priority - b.priority)[0];
+}
 function applyStoryMetrics(plan, storyIds, share, durationSeconds) {
   if (storyIds.length === 0) return plan;
   const targets = new Set(storyIds);
@@ -1018,6 +1143,13 @@ function setStoryUpdateCallback(callback) {
 function getStoryUpdateCallback() {
   return _onStoryUpdate;
 }
+var _onStoryStage;
+function setStoryStageCallback(callback) {
+  _onStoryStage = callback;
+}
+function getStoryStageCallback() {
+  return _onStoryStage;
+}
 var _globalTimeout;
 function setGlobalTimeout(ms) {
   _globalTimeout = ms;
@@ -1173,6 +1305,9 @@ var ElapsedTimer = class {
 };
 
 export {
+  policyConfigSchema,
+  policyConfigInputSchema,
+  pullRequestRefSchema,
   issueMetadataSchema,
   taskPlanSchema,
   sessionSnapshotSchema,
@@ -1195,6 +1330,7 @@ export {
   initializeState,
   hasPendingCorrection,
   allStoriesPass,
+  selectActiveStory,
   applyStoryMetrics,
   markIssueInProgress,
   markIssueCompleted,
@@ -1207,6 +1343,8 @@ export {
   getOutputCallback,
   setStoryUpdateCallback,
   getStoryUpdateCallback,
+  setStoryStageCallback,
+  getStoryStageCallback,
   setGlobalTimeout,
   getGlobalTimeout,
   useUnicode,
@@ -1222,4 +1360,4 @@ export {
   formatDuration,
   ElapsedTimer
 };
-//# sourceMappingURL=chunk-BH7DYADV.js.map
+//# sourceMappingURL=chunk-V5OHFSW4.js.map