issue-flow 0.16.0 → 0.18.0

package/dist/{chunk-ROIIEVZH.js → chunk-DUS5ZNKL.js}

@@ -2,14 +2,224 @@
 import {
   setTelemetrySessionId
 } from "./chunk-P3LRUNC6.js";
+import {
+  writeFileAtomic
+} from "./chunk-3R27MJ5R.js";
 
-// src/core/session-state.ts
-import { mkdir, rename, utimes, writeFile } from "fs/promises";
-import { dirname } from "path";
-import { stripVTControlCharacters } from "util";
+// src/core/session/publishers.ts
+import { utimes } from "fs/promises";
+
+// src/core/session/events.ts
 var DEFAULT_LOG_LIMIT = 200;
 var DEFAULT_THROTTLE_MS = 1e3;
 var DEFAULT_SESSION_HEARTBEAT_MS = 1e4;
+
+// src/core/session/derive.ts
+function accumulate(current, delta) {
+  return delta === void 0 ? current : (current ?? 0) + delta;
+}
+function accumulateUsage(target, event) {
+  return {
+    ...target,
+    inputTokens: accumulate(target.inputTokens, event.inputTokens),
+    outputTokens: accumulate(target.outputTokens, event.outputTokens),
+    cacheReadTokens: accumulate(target.cacheReadTokens, event.cacheReadTokens),
+    cacheCreationTokens: accumulate(target.cacheCreationTokens, event.cacheCreationTokens),
+    costUsd: accumulate(target.costUsd, event.costUsd)
+  };
+}
+function reported(value, previous) {
+  return value === void 0 ? previous : value;
+}
+function secondsBetween(from, to) {
+  if (from === null) return null;
+  const fromMs = Date.parse(from);
+  const toMs = Date.parse(to);
+  if (Number.isNaN(fromMs) || Number.isNaN(toMs)) return null;
+  return Math.max(0, Math.round((toMs - fromMs) / 1e3));
+}
+function computePercent(phasesCompleted, phasesTotal) {
+  if (phasesTotal === 0) return 0;
+  return Math.round(phasesCompleted / phasesTotal * 100);
+}
+function estimateRemainingSeconds(snapshot) {
+  const completions = snapshot.stories.map((story) => story.completedAt === null ? Number.NaN : Date.parse(story.completedAt)).filter((ms) => !Number.isNaN(ms)).sort((a, b) => a - b);
+  if (completions.length < 2) return null;
+  const startMs = snapshot.startedAt === null ? Number.NaN : Date.parse(snapshot.startedAt);
+  const boundaries = Number.isNaN(startMs) ? completions : [startMs, ...completions];
+  const durations = [];
+  for (let i = 1; i < boundaries.length; i++) {
+    durations.push(Math.max(0, boundaries[i] - boundaries[i - 1]));
+  }
+  if (durations.length === 0) return null;
+  const averageMs = durations.reduce((sum, d) => sum + d, 0) / durations.length;
+  const pending = snapshot.stories.filter((story) => !story.passes).length;
+  return Math.round(averageMs * pending / 1e3);
+}
+function deriveNextSteps(snapshot) {
+  if (snapshot.status === "completed") return [];
+  return snapshot.phases.filter((phase) => phase.status === "pending").map((phase) => phase.name);
+}
+function deriveStoryStatus(story, activeStory) {
+  if (story.passes) return "done";
+  if (story.status === "in_review") return "in_review";
+  if (activeStory !== null && activeStory === story.id) return "in_progress";
+  return "backlog";
+}
+function deriveStoryStatuses(snapshot) {
+  const activeStory = snapshot.currentActivity?.story ?? null;
+  return snapshot.stories.map((story) => {
+    const status = deriveStoryStatus(story, activeStory);
+    return status === story.status ? story : { ...story, status };
+  });
+}
+
+// src/core/session/reducer-git.ts
+function applyGitEvent(snapshot, event) {
+  switch (event.type) {
+    case "git:update":
+      return {
+        ...snapshot,
+        git: {
+          branch: event.branch ?? snapshot.git.branch,
+          baseBranch: event.baseBranch ?? snapshot.git.baseBranch,
+          branchCreated: reported(event.branchCreated, snapshot.git.branchCreated),
+          startCommit: snapshot.git.startCommit,
+          commits: event.commits ?? snapshot.git.commits
+        },
+        repository: {
+          // `undefined` is "not collected", so the previous value stands; an
+          // explicit `null` is "collected and unavailable" and overwrites it.
+          name: reported(event.repositoryName, snapshot.repository.name),
+          remoteUrl: reported(event.remoteUrl, snapshot.repository.remoteUrl),
+          branch: event.branch ?? snapshot.repository.branch,
+          headCommit: reported(event.headCommit, snapshot.repository.headCommit),
+          root: reported(event.repositoryRoot, snapshot.repository.root)
+        },
+        pullRequests: event.pullRequests ?? snapshot.pullRequests
+      };
+  }
+}
+
+// src/core/session/reducer-log.ts
+import { stripVTControlCharacters } from "util";
+function applyLogEvent(snapshot, event, options) {
+  switch (event.type) {
+    case "log": {
+      const limit = options?.logLimit ?? DEFAULT_LOG_LIMIT;
+      const entry = {
+        at: event.at,
+        level: event.level,
+        message: stripVTControlCharacters(event.message)
+      };
+      const logs = [...snapshot.logs, entry].slice(-Math.max(1, limit));
+      return { ...snapshot, logs };
+    }
+    case "process:output": {
+      const limit = options?.logLimit ?? DEFAULT_LOG_LIMIT;
+      const entry = {
+        at: event.at,
+        phase: event.phase,
+        executionId: event.executionId,
+        provider: event.provider,
+        stream: event.stream,
+        message: stripVTControlCharacters(event.message)
+      };
+      return {
+        ...snapshot,
+        processLogs: [...snapshot.processLogs, entry].slice(-Math.max(1, limit))
+      };
+    }
+    case "execution:update": {
+      const index = snapshot.executions.findIndex((entry) => entry.id === event.execution.id);
+      const executions = [...snapshot.executions];
+      if (index === -1) executions.push(event.execution);
+      else executions[index] = event.execution;
+      return { ...snapshot, executions };
+    }
+    default: {
+      const _exhaustive = event;
+      return _exhaustive;
+    }
+  }
+}
+
+// src/core/session/reducer-metrics.ts
+function applyMetricsEvent(snapshot, event) {
+  switch (event.type) {
+    case "metrics:update": {
+      if (event.scope === "story") {
+        if (event.storyId === void 0) return snapshot;
+        if (!snapshot.stories.some((s) => s.id === event.storyId)) return snapshot;
+        return {
+          ...snapshot,
+          stories: snapshot.stories.map(
+            (story) => story.id === event.storyId ? {
+              ...accumulateUsage(story, event),
+              durationSeconds: accumulate(story.durationSeconds, event.durationSeconds)
+            } : story
+          )
+        };
+      }
+      if (event.phase === void 0) return snapshot;
+      if (!snapshot.phases.some((p) => p.name === event.phase)) return snapshot;
+      return {
+        ...snapshot,
+        // durationSeconds is deliberately untouched here: phase:start and
+        // phase:end remain the single source of a phase's wall-clock time.
+        phases: snapshot.phases.map(
+          (phase) => phase.name === event.phase ? accumulateUsage(phase, event) : phase
+        ),
+        metrics: {
+          totalInputTokens: accumulate(snapshot.metrics.totalInputTokens, event.inputTokens),
+          totalOutputTokens: accumulate(snapshot.metrics.totalOutputTokens, event.outputTokens),
+          totalCacheReadTokens: accumulate(
+            snapshot.metrics.totalCacheReadTokens,
+            event.cacheReadTokens
+          ),
+          totalCacheCreationTokens: accumulate(
+            snapshot.metrics.totalCacheCreationTokens,
+            event.cacheCreationTokens
+          ),
+          totalCostUsd: accumulate(snapshot.metrics.totalCostUsd, event.costUsd)
+        }
+      };
+    }
+  }
+}
+
+// src/core/session/reducer-phase.ts
+import { stripVTControlCharacters as stripVTControlCharacters2 } from "util";
+
+// src/core/session/reducer-stage.ts
+function isTerminalStage(stage) {
+  return stage === "done" || stage === "failed";
+}
+function transitionStory(story, stage, at, detail) {
+  if (story.stage === stage && story.stageDetail === detail) return story;
+  return {
+    ...story,
+    stage,
+    stageSince: at,
+    stageDetail: detail,
+    history: [...story.history, { at, stage, detail }]
+  };
+}
+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 };
+}
+
+// src/core/session/snapshot.ts
 function emptyUsage() {
   return {
     inputTokens: null,
@@ -93,106 +303,192 @@ function createInitialSnapshot() {
     verification: null
   };
 }
-function accumulate(current, delta) {
-  return delta === void 0 ? current : (current ?? 0) + delta;
+
+// src/core/session/reducer-phase.ts
+function applyPhaseEvent(snapshot, event) {
+  switch (event.type) {
+    case "phase:start":
+      return applyPhaseStart(snapshot, event);
+    case "phase:end":
+      return applyPhaseEnd(snapshot, event);
+    case "iteration:start":
+      return applyIterationStart(snapshot, event);
+    case "iteration:end":
+      return { ...snapshot, currentActivity: null };
+    case "correction:cycle":
+      return applyCorrectionCycle(snapshot, event);
+    default: {
+      const _exhaustive = event;
+      return _exhaustive;
+    }
+  }
 }
-function accumulateUsage(target, event) {
+function applyPhaseStart(snapshot, event) {
+  const known = snapshot.phases.some((p) => p.name === event.phase);
+  const phases = known ? snapshot.phases.map(
+    (p) => p.name === event.phase ? {
+      ...p,
+      status: "running",
+      startedAt: event.at,
+      endedAt: null,
+      error: null
+    } : p
+  ) : [
+    ...snapshot.phases,
+    {
+      name: event.phase,
+      status: "running",
+      startedAt: event.at,
+      endedAt: null,
+      durationSeconds: null,
+      error: null,
+      ...emptyPhaseTiming(),
+      ...emptyUsage()
+    }
+  ];
+  const stories = event.phase === "review" ? snapshot.stories.map(
+    (story) => story.passes ? transitionStory(story, "in_review", event.at, null) : story
+  ) : snapshot.stories;
   return {
-    ...target,
-    inputTokens: accumulate(target.inputTokens, event.inputTokens),
-    outputTokens: accumulate(target.outputTokens, event.outputTokens),
-    cacheReadTokens: accumulate(target.cacheReadTokens, event.cacheReadTokens),
-    cacheCreationTokens: accumulate(target.cacheCreationTokens, event.cacheCreationTokens),
-    costUsd: accumulate(target.costUsd, event.costUsd)
+    ...snapshot,
+    currentPhase: event.phase,
+    phases,
+    stories,
+    progress: known ? snapshot.progress : { ...snapshot.progress, phasesTotal: phases.length }
   };
 }
-function reported(value, previous) {
-  return value === void 0 ? previous : value;
-}
-function secondsBetween(from, to) {
-  if (from === null) return null;
-  const fromMs = Date.parse(from);
-  const toMs = Date.parse(to);
-  if (Number.isNaN(fromMs) || Number.isNaN(toMs)) return null;
-  return Math.max(0, Math.round((toMs - fromMs) / 1e3));
-}
-function computePercent(phasesCompleted, phasesTotal) {
-  if (phasesTotal === 0) return 0;
-  return Math.round(phasesCompleted / phasesTotal * 100);
-}
-function estimateRemainingSeconds(snapshot) {
-  const completions = snapshot.stories.map((story) => story.completedAt === null ? Number.NaN : Date.parse(story.completedAt)).filter((ms) => !Number.isNaN(ms)).sort((a, b) => a - b);
-  if (completions.length < 2) return null;
-  const startMs = snapshot.startedAt === null ? Number.NaN : Date.parse(snapshot.startedAt);
-  const boundaries = Number.isNaN(startMs) ? completions : [startMs, ...completions];
-  const durations = [];
-  for (let i = 1; i < boundaries.length; i++) {
-    durations.push(Math.max(0, boundaries[i] - boundaries[i - 1]));
-  }
-  if (durations.length === 0) return null;
-  const averageMs = durations.reduce((sum, d) => sum + d, 0) / durations.length;
-  const pending = snapshot.stories.filter((story) => !story.passes).length;
-  return Math.round(averageMs * pending / 1e3);
-}
-function deriveNextSteps(snapshot) {
-  if (snapshot.status === "completed") return [];
-  return snapshot.phases.filter((phase) => phase.status === "pending").map((phase) => phase.name);
-}
-function deriveStoryStatus(story, activeStory) {
-  if (story.passes) return "done";
-  if (story.status === "in_review") return "in_review";
-  if (activeStory !== null && activeStory === story.id) return "in_progress";
-  return "backlog";
+function applyPhaseEnd(snapshot, event) {
+  const phases = snapshot.phases.map(
+    (p) => p.name === event.phase ? {
+      ...p,
+      status: event.success ? "completed" : "failed",
+      endedAt: event.at,
+      durationSeconds: secondsBetween(p.startedAt, event.at),
+      error: event.error ? stripVTControlCharacters2(event.error) : null,
+      harnessExecutionMs: event.harnessExecutionMs ?? p.harnessExecutionMs,
+      orchestrationOverheadMs: event.orchestrationOverheadMs ?? p.orchestrationOverheadMs,
+      harnessStartupMs: event.harnessStartupMs ?? p.harnessStartupMs,
+      ttftMs: event.ttftMs ?? p.ttftMs,
+      attemptCount: event.attemptCount ?? p.attemptCount,
+      retryDurationMs: event.retryDurationMs ?? p.retryDurationMs
+    } : p
+  );
+  const phasesCompleted = phases.filter((p) => p.status === "completed").length;
+  const stories = !event.success ? snapshot.stories.map(
+    (story) => isTerminalStage(story.stage) ? story : transitionStory(story, "failed", event.at, null)
+  ) : event.phase === "review" ? snapshot.stories.map(
+    (story) => story.passes ? transitionStory(story, "done", event.at, null) : story
+  ) : snapshot.stories;
+  return {
+    ...snapshot,
+    currentPhase: snapshot.currentPhase === event.phase ? null : snapshot.currentPhase,
+    currentActivity: null,
+    phases,
+    stories,
+    progress: {
+      ...snapshot.progress,
+      phasesCompleted,
+      percent: computePercent(phasesCompleted, snapshot.progress.phasesTotal)
+    }
+  };
 }
-function deriveStoryStatuses(snapshot) {
-  const activeStory = snapshot.currentActivity?.story ?? null;
-  return snapshot.stories.map((story) => {
-    const status = deriveStoryStatus(story, activeStory);
-    return status === story.status ? story : { ...story, status };
+function applyIterationStart(snapshot, event) {
+  const storyId = event.storyId;
+  const stories = snapshot.stories.map((story) => {
+    if (story.passes) return story;
+    if (story.id === storyId) {
+      return transitionStory(story, "executing", event.at, null);
+    }
+    return transitionStory(story, "pending", event.at, null);
   });
-}
-function reduceSessionEvent(snapshot, event, options) {
-  const next = applyEvent(snapshot, event, options);
-  if (next === snapshot) return snapshot;
-  const elapsedSeconds = secondsBetween(next.startedAt, event.at) ?? next.elapsedSeconds;
   return {
-    ...next,
-    updatedAt: event.at,
-    elapsedSeconds,
-    stories: deriveStoryStatuses(next),
-    estimatedRemainingSeconds: estimateRemainingSeconds(next),
-    errors: next.logs.filter((entry) => entry.level === "error"),
-    warnings: next.logs.filter((entry) => entry.level === "warn"),
-    nextSteps: deriveNextSteps(next)
+    ...snapshot,
+    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
   };
 }
-function isTerminalStage(stage) {
-  return stage === "done" || stage === "failed";
-}
-function transitionStory(story, stage, at, detail) {
-  if (story.stage === stage && story.stageDetail === detail) return story;
+function applyCorrectionCycle(snapshot, event) {
+  const stageDetail = `Cycle ${event.cycle}/${event.maxCycles}`;
+  const stories = snapshot.stories.map(
+    (story) => story.passes ? transitionStory(story, "in_correction", event.at, stageDetail) : story
+  );
   return {
-    ...story,
-    stage,
-    stageSince: at,
-    stageDetail: detail,
-    history: [...story.history, { at, stage, detail }]
+    ...snapshot,
+    execution: {
+      ...snapshot.execution,
+      correctionCycle: event.cycle,
+      maxCorrectionCycles: event.maxCycles
+    },
+    stories
   };
 }
-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 };
+
+// src/core/session/reducer-resilience.ts
+function applyResilienceEvent(snapshot, event) {
+  switch (event.type) {
+    case "retry":
+      return {
+        ...snapshot,
+        execution: { ...snapshot.execution, retries: snapshot.execution.retries + 1 }
+      };
+    case "agent:attempt":
+      return {
+        ...snapshot,
+        resilience: {
+          ...snapshot.resilience,
+          attempt: event.attempt,
+          provider: event.provider,
+          model: event.model ?? null,
+          lastActivityAt: event.at
+        }
+      };
+    case "failover":
+      return {
+        ...snapshot,
+        resilience: {
+          ...snapshot.resilience,
+          provider: event.to,
+          lastFailureKind: event.reason,
+          cooldownUntil: event.cooldownUntil ?? null,
+          lastActivityAt: event.at
+        }
+      };
+    case "agent:result":
+      return {
+        ...snapshot,
+        resilience: {
+          ...snapshot.resilience,
+          provider: event.provider,
+          lastFailureKind: event.failureKind ?? snapshot.resilience.lastFailureKind,
+          cooldownUntil: event.cooldownUntil ?? null,
+          lastActivityAt: event.at
+        }
+      };
+    case "agent:activity":
+      return {
+        ...snapshot,
+        resilience: {
+          ...snapshot.resilience,
+          provider: event.provider,
+          lastActivityAt: event.at
+        }
+      };
+    default: {
+      const _exhaustive = event;
+      return _exhaustive;
+    }
   }
-  return { stage: "awaiting_review", stageSince: at, stageDetail: null };
 }
-function applyEvent(snapshot, event, options) {
+
+// src/core/session/reducer-session.ts
+import { stripVTControlCharacters as stripVTControlCharacters3 } from "util";
+function applySessionEvent(snapshot, event) {
   switch (event.type) {
     case "session:start": {
       setTelemetrySessionId(event.sessionId);
@@ -255,145 +551,43 @@ function applyEvent(snapshot, event, options) {
           state: event.state
         }
       };
-    case "phase:start": {
-      const known = snapshot.phases.some((p) => p.name === event.phase);
-      const phases = known ? snapshot.phases.map(
-        (p) => p.name === event.phase ? {
-          ...p,
-          status: "running",
-          startedAt: event.at,
-          endedAt: null,
-          error: null
-        } : p
-      ) : [
-        ...snapshot.phases,
-        {
-          name: event.phase,
-          status: "running",
-          startedAt: event.at,
-          endedAt: null,
-          durationSeconds: null,
-          error: null,
-          ...emptyPhaseTiming(),
-          ...emptyUsage()
-        }
-      ];
-      const stories = event.phase === "review" ? snapshot.stories.map(
-        (story) => story.passes ? transitionStory(story, "in_review", event.at, null) : story
-      ) : snapshot.stories;
-      return {
-        ...snapshot,
-        currentPhase: event.phase,
-        phases,
-        stories,
-        progress: known ? snapshot.progress : { ...snapshot.progress, phasesTotal: phases.length }
-      };
-    }
-    case "phase:end": {
-      const phases = snapshot.phases.map(
-        (p) => p.name === event.phase ? {
-          ...p,
-          status: event.success ? "completed" : "failed",
-          endedAt: event.at,
-          durationSeconds: secondsBetween(p.startedAt, event.at),
-          error: event.error ? stripVTControlCharacters(event.error) : null,
-          harnessExecutionMs: event.harnessExecutionMs ?? p.harnessExecutionMs,
-          orchestrationOverheadMs: event.orchestrationOverheadMs ?? p.orchestrationOverheadMs,
-          harnessStartupMs: event.harnessStartupMs ?? p.harnessStartupMs,
-          ttftMs: event.ttftMs ?? p.ttftMs,
-          attemptCount: event.attemptCount ?? p.attemptCount,
-          retryDurationMs: event.retryDurationMs ?? p.retryDurationMs
-        } : p
-      );
-      const phasesCompleted = phases.filter((p) => p.status === "completed").length;
-      const stories = !event.success ? snapshot.stories.map(
-        (story) => isTerminalStage(story.stage) ? story : transitionStory(story, "failed", event.at, null)
-      ) : event.phase === "review" ? snapshot.stories.map(
-        (story) => story.passes ? transitionStory(story, "done", event.at, null) : story
-      ) : snapshot.stories;
+    case "verify:end":
       return {
         ...snapshot,
-        currentPhase: snapshot.currentPhase === event.phase ? null : snapshot.currentPhase,
-        currentActivity: null,
-        phases,
-        stories,
-        progress: {
-          ...snapshot.progress,
-          phasesCompleted,
-          percent: computePercent(phasesCompleted, snapshot.progress.phasesTotal)
+        verification: {
+          verdict: event.verdict,
+          level: event.level,
+          independence: event.independence
         }
       };
-    }
-    case "iteration:start": {
-      const storyId = event.storyId;
-      const stories = snapshot.stories.map((story) => {
-        if (story.passes) return story;
-        if (story.id === storyId) {
-          return transitionStory(story, "executing", event.at, null);
-        }
-        return transitionStory(story, "pending", event.at, null);
-      });
+    case "session:end":
       return {
         ...snapshot,
-        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
+        status: event.status,
+        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 transitionStory(story, stage, event.at, null);
+        }),
+        lastError: event.error ? { message: stripVTControlCharacters3(event.error), at: event.at } : snapshot.lastError
       };
+    default: {
+      const _exhaustive = event;
+      return _exhaustive;
     }
-    case "iteration:end":
-      return { ...snapshot, currentActivity: null };
-    case "retry":
-      return {
-        ...snapshot,
-        execution: { ...snapshot.execution, retries: snapshot.execution.retries + 1 }
-      };
-    case "agent:attempt":
-      return {
-        ...snapshot,
-        resilience: {
-          ...snapshot.resilience,
-          attempt: event.attempt,
-          provider: event.provider,
-          model: event.model ?? null,
-          lastActivityAt: event.at
-        }
-      };
-    case "failover":
-      return {
-        ...snapshot,
-        resilience: {
-          ...snapshot.resilience,
-          provider: event.to,
-          lastFailureKind: event.reason,
-          cooldownUntil: event.cooldownUntil ?? null,
-          lastActivityAt: event.at
-        }
-      };
-    case "agent:result":
-      return {
-        ...snapshot,
-        resilience: {
-          ...snapshot.resilience,
-          provider: event.provider,
-          lastFailureKind: event.failureKind ?? snapshot.resilience.lastFailureKind,
-          cooldownUntil: event.cooldownUntil ?? null,
-          lastActivityAt: event.at
-        }
-      };
-    case "agent:activity":
-      return {
-        ...snapshot,
-        resilience: {
-          ...snapshot.resilience,
-          provider: event.provider,
-          lastActivityAt: event.at
-        }
-      };
+  }
+}
+
+// src/core/session/reducer-story.ts
+function applyStoryEvent(snapshot, event) {
+  switch (event.type) {
     case "stories:update": {
       const previous = new Map(snapshot.stories.map((story) => [story.id, story]));
       const stories = event.stories.map((story) => {
@@ -450,143 +644,68 @@ function applyEvent(snapshot, event, options) {
         resilience: { ...snapshot.resilience, lastActivityAt: event.at }
       };
     }
-    case "log": {
-      const limit = options?.logLimit ?? DEFAULT_LOG_LIMIT;
-      const entry = {
-        at: event.at,
-        level: event.level,
-        message: stripVTControlCharacters(event.message)
-      };
-      const logs = [...snapshot.logs, entry].slice(-Math.max(1, limit));
-      return { ...snapshot, logs };
-    }
-    case "process:output": {
-      const limit = options?.logLimit ?? DEFAULT_LOG_LIMIT;
-      const entry = {
-        at: event.at,
-        phase: event.phase,
-        executionId: event.executionId,
-        provider: event.provider,
-        stream: event.stream,
-        message: stripVTControlCharacters(event.message)
-      };
-      return {
-        ...snapshot,
-        processLogs: [...snapshot.processLogs, entry].slice(-Math.max(1, limit))
-      };
-    }
-    case "execution:update": {
-      const index = snapshot.executions.findIndex((entry) => entry.id === event.execution.id);
-      const executions = [...snapshot.executions];
-      if (index === -1) executions.push(event.execution);
-      else executions[index] = event.execution;
-      return { ...snapshot, executions };
-    }
-    case "git:update":
-      return {
-        ...snapshot,
-        git: {
-          branch: event.branch ?? snapshot.git.branch,
-          baseBranch: event.baseBranch ?? snapshot.git.baseBranch,
-          branchCreated: reported(event.branchCreated, snapshot.git.branchCreated),
-          startCommit: snapshot.git.startCommit,
-          commits: event.commits ?? snapshot.git.commits
-        },
-        repository: {
-          // `undefined` is "not collected", so the previous value stands; an
-          // explicit `null` is "collected and unavailable" and overwrites it.
-          name: reported(event.repositoryName, snapshot.repository.name),
-          remoteUrl: reported(event.remoteUrl, snapshot.repository.remoteUrl),
-          branch: event.branch ?? snapshot.repository.branch,
-          headCommit: reported(event.headCommit, snapshot.repository.headCommit),
-          root: reported(event.repositoryRoot, snapshot.repository.root)
-        },
-        pullRequests: event.pullRequests ?? snapshot.pullRequests
-      };
-    case "correction:cycle": {
-      const stageDetail = `Cycle ${event.cycle}/${event.maxCycles}`;
-      const stories = snapshot.stories.map(
-        (story) => story.passes ? transitionStory(story, "in_correction", 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;
-        if (!snapshot.stories.some((s) => s.id === event.storyId)) return snapshot;
-        return {
-          ...snapshot,
-          stories: snapshot.stories.map(
-            (story) => story.id === event.storyId ? {
-              ...accumulateUsage(story, event),
-              durationSeconds: accumulate(story.durationSeconds, event.durationSeconds)
-            } : story
-          )
-        };
-      }
-      if (event.phase === void 0) return snapshot;
-      if (!snapshot.phases.some((p) => p.name === event.phase)) return snapshot;
-      return {
-        ...snapshot,
-        // durationSeconds is deliberately untouched here: phase:start and
-        // phase:end remain the single source of a phase's wall-clock time.
-        phases: snapshot.phases.map(
-          (phase) => phase.name === event.phase ? accumulateUsage(phase, event) : phase
-        ),
-        metrics: {
-          totalInputTokens: accumulate(snapshot.metrics.totalInputTokens, event.inputTokens),
-          totalOutputTokens: accumulate(snapshot.metrics.totalOutputTokens, event.outputTokens),
-          totalCacheReadTokens: accumulate(
-            snapshot.metrics.totalCacheReadTokens,
-            event.cacheReadTokens
-          ),
-          totalCacheCreationTokens: accumulate(
-            snapshot.metrics.totalCacheCreationTokens,
-            event.cacheCreationTokens
-          ),
-          totalCostUsd: accumulate(snapshot.metrics.totalCostUsd, event.costUsd)
-        }
-      };
+    default: {
+      const _exhaustive = event;
+      return _exhaustive;
     }
-    case "verify:end":
-      return {
-        ...snapshot,
-        verification: {
-          verdict: event.verdict,
-          level: event.level,
-          independence: event.independence
-        }
-      };
+  }
+}
+
+// src/core/session/reducer.ts
+function reduceSessionEvent(snapshot, event, options) {
+  const next = applyEvent(snapshot, event, options);
+  if (next === snapshot) return snapshot;
+  const elapsedSeconds = secondsBetween(next.startedAt, event.at) ?? next.elapsedSeconds;
+  return {
+    ...next,
+    updatedAt: event.at,
+    elapsedSeconds,
+    stories: deriveStoryStatuses(next),
+    estimatedRemainingSeconds: estimateRemainingSeconds(next),
+    errors: next.logs.filter((entry) => entry.level === "error"),
+    warnings: next.logs.filter((entry) => entry.level === "warn"),
+    nextSteps: deriveNextSteps(next)
+  };
+}
+function applyEvent(snapshot, event, options) {
+  switch (event.type) {
+    case "session:start":
     case "session:end":
-      return {
-        ...snapshot,
-        status: event.status,
-        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 transitionStory(story, stage, event.at, null);
-        }),
-        lastError: event.error ? { message: stripVTControlCharacters(event.error), at: event.at } : snapshot.lastError
-      };
-    default:
+    case "issue:update":
+    case "verify:end":
+      return applySessionEvent(snapshot, event);
+    case "phase:start":
+    case "phase:end":
+    case "iteration:start":
+    case "iteration:end":
+    case "correction:cycle":
+      return applyPhaseEvent(snapshot, event);
+    case "stories:update":
+    case "activity":
+      return applyStoryEvent(snapshot, event);
+    case "metrics:update":
+      return applyMetricsEvent(snapshot, event);
+    case "git:update":
+      return applyGitEvent(snapshot, event);
+    case "log":
+    case "process:output":
+    case "execution:update":
+      return applyLogEvent(snapshot, event, options);
+    case "retry":
+    case "agent:attempt":
+    case "failover":
+    case "agent:result":
+    case "agent:activity":
+      return applyResilienceEvent(snapshot, event);
+    default: {
+      const _exhaustive = event;
+      void _exhaustive;
       return snapshot;
+    }
   }
 }
+
+// src/core/session/publishers.ts
 var NullPublisher = class {
   empty = createInitialSnapshot();
   publish(_event) {
@@ -703,7 +822,7 @@ var FilePublisher = class extends MemoryPublisher {
       const payload = `${JSON.stringify(this.state, null, 2)}
 `;
       try {
-        await atomicWriteFile(this.filePath, payload);
+        await writeFileAtomic(this.filePath, payload);
         this.lastWrittenVersion = version;
       } catch (err) {
         this.warnOnce(err);
@@ -747,12 +866,6 @@ var FilePublisher = class extends MemoryPublisher {
     await this.flush();
   }
 };
-async function atomicWriteFile(path, content) {
-  await mkdir(dirname(path), { recursive: true });
-  const tmpFile = `${path}.tmp`;
-  await writeFile(tmpFile, content, "utf-8");
-  await rename(tmpFile, path);
-}
 
 // src/core/session-publisher.ts
 var NULL_PUBLISHER = new NullPublisher();
@@ -773,4 +886,4 @@ export {
   setSessionPublisher,
   getSessionPublisher
 };
-//# sourceMappingURL=chunk-ROIIEVZH.js.map
+//# sourceMappingURL=chunk-DUS5ZNKL.js.map