issue-flow 0.11.1 → 0.13.0

package/dist/{chunk-HC2MT7BX.js → chunk-IYV6KNVF.js}

@@ -1,339 +1,18 @@
 #!/usr/bin/env node
-
-// src/policy/schemas.ts
-import { z } from "zod";
-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(),
-  /**
-   * Whether Issue Flow may create a label the repository does not have.
-   *
-   * `.optional()` rather than `.default(false)`: the resolved declarations must
-   * stay "only what was written", or the group would always look declared and
-   * `sources` would report a provenance nobody asked for. The effective default
-   * — false — lives at the call site.
-   *
-   * That default is a deliberate change of behaviour: creating taxonomy without
-   * asking is the defect this exists to stop. A repository that wants the old
-   * behaviour opts back into it.
-   */
-  allowLabelCreation: z.boolean().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 policyConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  /**
-   * Token budget for the `__REPO_POLICY__` projection. Sections above it are
-   * replaced whole by a pointer rather than truncated — see
-   * `policy/placeholders.ts`.
-   */
-  contextBudget: z.number().int().positive().default(1500),
-  discovery: policyDiscoveryConfigSchema.prefault({}),
-  issues: policyIssuesDeclarationSchema.prefault({}),
-  pullRequests: policyPullRequestsDeclarationSchema.prefault({}),
-  git: policyGitDeclarationSchema.prefault({})
-});
-var policyConfigInputSchema = z.object({
-  enabled: z.boolean().optional(),
-  contextBudget: z.number().int().positive().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(), allowLabelCreation: z.boolean().optional() }).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: z2.number().optional(),
-  status: userStoryStatusSchema.optional(),
-  dependencies: z2.array(z2.string()).optional(),
-  stage: storyStageSchema.optional(),
-  stageSince: z2.string().optional(),
-  stageDetail: z2.string().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 = z2.object({
-  number: z2.number().int().positive(),
-  url: z2.string(),
-  headBranch: z2.string(),
-  createdAt: z2.string()
-});
-var prReviewRecommendationSchema = z2.enum([
-  "APPROVE",
-  "APPROVE_WITH_SUGGESTIONS",
-  "REQUEST_CHANGES"
-]);
-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: z2.string().optional()
-});
-var lastErrorSchema = z2.object({
-  category: z2.string(),
-  message: z2.string(),
-  at: z2.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 = 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: 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: z2.string().nullable().optional().default(null),
-  pipeline: pipelineStateSchema,
-  pullRequest: pullRequestRefSchema.optional(),
-  prReview: prReviewStateSchema.optional(),
-  userStories: z2.array(userStorySchema)
-});
-var headlessResultSchema = z2.object({
-  success: z2.boolean(),
-  result: z2.string(),
-  cost: claudeUsageSchema.nullable(),
-  error: z2.string().nullable()
-});
-var sessionLogEntrySchema = z2.object({
-  at: z2.string(),
-  level: z2.enum(["info", "warn", "error"]),
-  message: z2.string()
-});
-var sessionUsageShape = {
-  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 = 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 = 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: 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: 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: 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 = 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: z2.string().nullable().default(null),
-    description: z2.string().nullable().default(null),
-    labels: z2.array(z2.string()).default([]),
-    state: z2.string().nullable().default(null)
-  }),
-  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: z2.string().nullable(),
-  currentActivity: z2.object({
-    story: z2.string().nullable(),
-    tool: z2.string().nullable(),
-    detail: z2.string().nullable(),
-    since: z2.string()
-  }).nullable(),
-  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: 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,
-    totalCacheReadTokens: null,
-    totalCacheCreationTokens: null,
-    totalCostUsd: null
-  }),
-  execution: z2.object({
-    iteration: z2.number(),
-    retries: z2.number(),
-    correctionCycle: z2.number(),
-    maxCorrectionCycles: z2.number().nullable()
-  }),
-  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: 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: 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 = 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 = 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 = z2.object({
-  publisher: z2.enum(["local"]).default("local")
-});
+import {
+  setTelemetrySessionId
+} from "./chunk-P3LRUNC6.js";
+import {
+  isoNow
+} from "./chunk-DIG5XKQQ.js";
 
 // src/core/session-state.ts
-import { mkdir, rename, writeFile } from "fs/promises";
+import { mkdir, rename, utimes, writeFile } from "fs/promises";
 import { dirname } from "path";
 import { stripVTControlCharacters } from "util";
 var DEFAULT_LOG_LIMIT = 200;
 var DEFAULT_THROTTLE_MS = 1e3;
+var DEFAULT_SESSION_HEARTBEAT_MS = 1e4;
 function emptyUsage() {
   return {
     inputTokens: null,
@@ -343,6 +22,16 @@ function emptyUsage() {
     costUsd: null
   };
 }
+function emptyPhaseTiming() {
+  return {
+    harnessExecutionMs: null,
+    orchestrationOverheadMs: null,
+    harnessStartupMs: null,
+    ttftMs: null,
+    attemptCount: null,
+    retryDurationMs: null
+  };
+}
 function emptyMetrics() {
   return {
     totalInputTokens: null,
@@ -378,6 +67,14 @@ function createInitialSnapshot() {
     stories: [],
     metrics: emptyMetrics(),
     execution: { iteration: 0, retries: 0, correctionCycle: 0, maxCorrectionCycles: null },
+    resilience: {
+      attempt: 0,
+      provider: null,
+      model: null,
+      lastFailureKind: null,
+      cooldownUntil: null,
+      lastActivityAt: null
+    },
     git: { branch: null, baseBranch: null, commits: [] },
     repository: { name: null, remoteUrl: null, branch: null, headCommit: null, root: null },
     pullRequests: [],
@@ -386,7 +83,8 @@ function createInitialSnapshot() {
     warnings: [],
     lastError: null,
     nextSteps: [],
-    environment: null
+    environment: null,
+    verification: null
   };
 }
 function accumulate(current, delta) {
@@ -481,6 +179,7 @@ function deriveStageOnStoriesUpdate(story, before, at) {
 function applyEvent(snapshot, event, options) {
   switch (event.type) {
     case "session:start": {
+      setTelemetrySessionId(event.sessionId);
       const initial = createInitialSnapshot();
       return {
         ...initial,
@@ -499,6 +198,7 @@ function applyEvent(snapshot, event, options) {
           endedAt: null,
           durationSeconds: null,
           error: null,
+          ...emptyPhaseTiming(),
           ...emptyUsage()
         })),
         git: { branch: event.branch ?? null, baseBranch: event.baseBranch ?? null, commits: [] },
@@ -507,7 +207,12 @@ function applyEvent(snapshot, event, options) {
         // keeps git.branch and repository.branch consistent for a poll that
         // lands before the first git:update.
         repository: { ...initial.repository, branch: event.branch ?? null },
-        environment: event.environment ?? null
+        environment: event.environment ? {
+          node: event.environment.node,
+          platform: event.environment.platform,
+          agent: event.environment.agent ?? null,
+          model: event.environment.model ?? null
+        } : null
       };
     }
     case "issue:update":
@@ -545,6 +250,7 @@ function applyEvent(snapshot, event, options) {
           endedAt: null,
           durationSeconds: null,
           error: null,
+          ...emptyPhaseTiming(),
           ...emptyUsage()
         }
       ];
@@ -566,7 +272,13 @@ function applyEvent(snapshot, event, options) {
           status: event.success ? "completed" : "failed",
           endedAt: event.at,
           durationSeconds: secondsBetween(p.startedAt, event.at),
-          error: event.error ? stripVTControlCharacters(event.error) : null
+          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;
@@ -616,6 +328,48 @@ function applyEvent(snapshot, event, options) {
         ...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
+        }
+      };
     case "stories:update": {
       const previous = new Map(snapshot.stories.map((story) => [story.id, story]));
       const stories = event.stories.map((story) => {
@@ -662,7 +416,11 @@ function applyEvent(snapshot, event, options) {
       const detail = event.detail ?? null;
       const current = snapshot.currentActivity;
       const since = current && current.story === story && current.tool === tool && current.detail === detail ? current.since : event.at;
-      return { ...snapshot, currentActivity: { story, tool, detail, since } };
+      return {
+        ...snapshot,
+        currentActivity: { story, tool, detail, since },
+        resilience: { ...snapshot.resilience, lastActivityAt: event.at }
+      };
     }
     case "log": {
       const limit = options?.logLimit ?? DEFAULT_LOG_LIMIT;
@@ -746,6 +504,15 @@ function applyEvent(snapshot, event, options) {
         }
       };
     }
+    case "verify:end":
+      return {
+        ...snapshot,
+        verification: {
+          verdict: event.verdict,
+          level: event.level,
+          independence: event.independence
+        }
+      };
     case "session:end":
       return {
         ...snapshot,
@@ -835,6 +602,7 @@ var FilePublisher = class extends MemoryPublisher {
   filePath;
   throttleMs;
   timer = null;
+  heartbeatTimer = null;
   lastWriteStartedAt = 0;
   lastWrittenVersion = 0;
   writeChain = Promise.resolve();
@@ -843,10 +611,15 @@ var FilePublisher = class extends MemoryPublisher {
     super(options);
     this.filePath = filePath;
     this.throttleMs = options.throttleMs ?? DEFAULT_THROTTLE_MS;
+    const heartbeatMs = options.heartbeatMs ?? DEFAULT_SESSION_HEARTBEAT_MS;
+    if (heartbeatMs > 0) {
+      this.heartbeatTimer = setInterval(() => this.enqueueHeartbeat(), heartbeatMs);
+      this.heartbeatTimer.unref();
+    }
   }
   afterPublish(event) {
     if (this.closed) return;
-    const terminal = event.type === "phase:end" || event.type === "session:end";
+    const terminal = event.type === "phase:end" || event.type === "session:end" || event.type === "verify:end";
     this.scheduleWrite(terminal);
   }
   scheduleWrite(force) {
@@ -885,6 +658,24 @@ var FilePublisher = class extends MemoryPublisher {
       }
     });
   }
+  /**
+   * Keep directory-based discovery alive without changing snapshot content or
+   * its content-derived ETag. The write chain serializes the touch with atomic
+   * snapshot replacement, and no heartbeat is attempted before the first file
+   * has been written successfully.
+   */
+  enqueueHeartbeat() {
+    if (this.closed) return;
+    this.writeChain = this.writeChain.then(async () => {
+      if (this.closed || this.lastWrittenVersion === 0) return;
+      const now = /* @__PURE__ */ new Date();
+      try {
+        await utimes(this.filePath, now, now);
+      } catch (err) {
+        this.warnOnce(err);
+      }
+    });
+  }
   async flush() {
     if (this.timer !== null) {
       clearTimeout(this.timer);
@@ -896,8 +687,12 @@ var FilePublisher = class extends MemoryPublisher {
     await this.writeChain;
   }
   async close() {
-    await this.flush();
+    if (this.heartbeatTimer !== null) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
     this.closed = true;
+    await this.flush();
   }
 };
 async function atomicWriteFile(path, content) {
@@ -917,230 +712,6 @@ function getSessionPublisher() {
   return _publisher;
 }
 
-// src/core/state-manager.ts
-import { readFile } from "fs/promises";
-import { ZodError } from "zod";
-
-// src/utils/fs.ts
-import { copyFile, mkdtemp, rename as rename2, unlink, writeFile as writeFile2 } from "fs/promises";
-import { tmpdir } from "os";
-import { basename, join } from "path";
-async function writeFileAtomic(path, content) {
-  const tmpDir = await mkdtemp(join(tmpdir(), "issue-flow-"));
-  const tmpFile = join(tmpDir, basename(path));
-  await writeFile2(tmpFile, content, "utf-8");
-  try {
-    await rename2(tmpFile, path);
-  } catch (err) {
-    if (err.code === "EXDEV") {
-      await copyFile(tmpFile, path);
-      await unlink(tmpFile);
-    } else {
-      throw err;
-    }
-  }
-}
-
-// src/core/metrics.ts
-var USAGE_FIELDS = [
-  "inputTokens",
-  "outputTokens",
-  "cacheReadTokens",
-  "cacheCreationTokens",
-  "costUsd"
-];
-function num(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function parseUsage(payload) {
-  if (!isRecord(payload)) return null;
-  const usageRaw = isRecord(payload.usage) ? payload.usage : void 0;
-  const usage = {};
-  const inputTokens = usageRaw ? num(usageRaw.input_tokens) : void 0;
-  const outputTokens = usageRaw ? num(usageRaw.output_tokens) : void 0;
-  const cacheReadTokens = usageRaw ? num(usageRaw.cache_read_input_tokens) : void 0;
-  const cacheCreationTokens = usageRaw ? num(usageRaw.cache_creation_input_tokens) : void 0;
-  const costUsd = num(payload.total_cost_usd);
-  const legacyInput = num(payload.num_input_tokens);
-  const legacyOutput = num(payload.num_output_tokens);
-  const legacyCost = num(payload.cost_usd);
-  const resolvedInput = inputTokens ?? legacyInput;
-  const resolvedOutput = outputTokens ?? legacyOutput;
-  const resolvedCost = costUsd ?? legacyCost;
-  if (resolvedInput !== void 0) usage.inputTokens = resolvedInput;
-  if (resolvedOutput !== void 0) usage.outputTokens = resolvedOutput;
-  if (cacheReadTokens !== void 0) usage.cacheReadTokens = cacheReadTokens;
-  if (cacheCreationTokens !== void 0) usage.cacheCreationTokens = cacheCreationTokens;
-  if (resolvedCost !== void 0) usage.costUsd = resolvedCost;
-  return Object.keys(usage).length > 0 ? usage : null;
-}
-function sumUsage(a, b) {
-  const result = {};
-  for (const field of USAGE_FIELDS) {
-    const left = a?.[field];
-    const right = b?.[field];
-    if (left === void 0 && right === void 0) continue;
-    result[field] = (left ?? 0) + (right ?? 0);
-  }
-  return result;
-}
-function divideUsage(usage, parts) {
-  const result = {};
-  if (!usage) return result;
-  const divisor = Number.isFinite(parts) && parts > 1 ? parts : 1;
-  for (const field of USAGE_FIELDS) {
-    const value = usage[field];
-    if (value === void 0) continue;
-    result[field] = field === "costUsd" ? value / divisor : Math.round(value / divisor);
-  }
-  return result;
-}
-function compactTokens(value) {
-  const abs = Math.abs(value);
-  if (abs >= 1e6) return `${(value / 1e6).toFixed(1)}M`;
-  if (abs >= 1e3) return `${(value / 1e3).toFixed(1)}k`;
-  return String(Math.round(value));
-}
-function formatTokens(usage) {
-  if (!usage) return "";
-  const segments = [];
-  const io = [];
-  if (usage.inputTokens !== void 0) io.push(`${compactTokens(usage.inputTokens)} in`);
-  if (usage.outputTokens !== void 0) io.push(`${compactTokens(usage.outputTokens)} out`);
-  if (io.length > 0) segments.push(io.join(" / "));
-  const cache = usage.cacheReadTokens !== void 0 || usage.cacheCreationTokens !== void 0 ? (usage.cacheReadTokens ?? 0) + (usage.cacheCreationTokens ?? 0) : void 0;
-  if (cache !== void 0) segments.push(`${compactTokens(cache)} cache`);
-  if (usage.costUsd !== void 0) segments.push(`~$${usage.costUsd.toFixed(4)}`);
-  return segments.join(" \xB7 ");
-}
-function hasUsageData(usage) {
-  if (!usage) return false;
-  return USAGE_FIELDS.some((field) => usage[field] !== void 0);
-}
-
-// src/core/state-manager.ts
-function isoNow() {
-  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
-}
-async function loadTaskPlan(path) {
-  const content = await readFile(path, "utf-8");
-  const raw = JSON.parse(content);
-  try {
-    return taskPlanSchema.parse(raw);
-  } catch (err) {
-    if (err instanceof ZodError) {
-      const issues = err.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
-      throw new Error(`Invalid tasks.json at ${path}:
-${issues}`);
-    }
-    throw err;
-  }
-}
-async function saveTaskPlan(path, plan) {
-  await writeFileAtomic(path, `${JSON.stringify(plan, null, 2)}
-`);
-}
-function initializeState(plan) {
-  const defaultPipeline = {
-    prdCompleted: false,
-    jsonCompleted: false,
-    executionCompleted: false,
-    reviewCompleted: false,
-    prCreated: false
-  };
-  return {
-    ...plan,
-    issueStatus: plan.issueStatus ?? "pending",
-    completedAt: plan.completedAt ?? null,
-    lastAttemptAt: plan.lastAttemptAt ?? null,
-    lastError: plan.lastError ?? null,
-    correctionCycle: plan.correctionCycle ?? 0,
-    maxCorrectionCycles: plan.maxCorrectionCycles ?? 3,
-    lastReviewFindings: plan.lastReviewFindings ?? null,
-    pipeline: plan.pipeline ? { ...defaultPipeline, ...plan.pipeline } : defaultPipeline
-  };
-}
-function hasPendingCorrection(plan) {
-  return Boolean(plan.lastReviewFindings);
-}
-function allStoriesPass(plan) {
-  if (plan.userStories.length === 0) {
-    return false;
-  }
-  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);
-  return {
-    ...plan,
-    userStories: plan.userStories.map((story) => {
-      if (!targets.has(story.id)) return story;
-      const updated = { ...story, ...sumUsage(story, share) };
-      if (story.durationSeconds !== void 0 || durationSeconds !== void 0) {
-        updated.durationSeconds = (story.durationSeconds ?? 0) + (durationSeconds ?? 0);
-      }
-      return updated;
-    })
-  };
-}
-function markIssueInProgress(plan, timestamp) {
-  const ts = timestamp ?? isoNow();
-  return {
-    ...plan,
-    issueStatus: "in_progress",
-    completedAt: null,
-    lastAttemptAt: ts
-  };
-}
-function markIssueCompleted(plan) {
-  const ts = isoNow();
-  return {
-    ...plan,
-    issueStatus: "completed",
-    completedAt: ts,
-    lastAttemptAt: ts,
-    lastError: null,
-    pipeline: plan.pipeline ? { ...plan.pipeline, executionCompleted: true } : plan.pipeline
-  };
-}
-function setLastError(plan, category, message) {
-  const ts = isoNow();
-  const error = {
-    category,
-    message,
-    at: ts
-  };
-  return {
-    ...plan,
-    lastAttemptAt: ts,
-    lastError: error
-  };
-}
-function clearLastError(plan, attemptStartedAt) {
-  const ts = isoNow();
-  if (plan.lastError && plan.lastError.at > attemptStartedAt) {
-    return {
-      ...plan,
-      lastAttemptAt: ts
-    };
-  }
-  return {
-    ...plan,
-    lastAttemptAt: ts,
-    lastError: null
-  };
-}
-function trimErrorMessage(message) {
-  return message.split("\n").filter((line) => line.trim().length > 0).slice(0, 8).join("\n");
-}
-
 // src/core/verbose.ts
 var _verbose = false;
 function setVerbose(enabled) {
@@ -1170,6 +741,13 @@ function setStoryStageCallback(callback) {
 function getStoryStageCallback() {
   return _onStoryStage;
 }
+var _onActivity;
+function setActivityCallback(callback) {
+  _onActivity = callback;
+}
+function getActivityCallback() {
+  return _onActivity;
+}
 var _globalTimeout;
 function setGlobalTimeout(ms) {
   _globalTimeout = ms;
@@ -1177,6 +755,13 @@ function setGlobalTimeout(ms) {
 function getGlobalTimeout() {
   return _globalTimeout;
 }
+var _inactivityTimeout;
+function setInactivityTimeout(ms) {
+  _inactivityTimeout = ms;
+}
+function getInactivityTimeout() {
+  return _inactivityTimeout;
+}
 
 // src/ui/logger.ts
 import chalk from "chalk";
@@ -1203,7 +788,8 @@ function getIcons() {
       end: "\u25A0",
       notReached: "\u25CB",
       tool: "\u25B8",
-      connector: "\u2502"
+      connector: "\u2502",
+      info: "\xB7"
     };
   }
   return {
@@ -1216,7 +802,8 @@ function getIcons() {
     end: "[END]",
     notReached: "[ ]",
     tool: ">",
-    connector: "|"
+    connector: "|",
+    info: "-"
   };
 }
 function getTermWidth() {
@@ -1266,9 +853,9 @@ function printRetry(message) {
 function printInfo(message) {
   const icons = getIcons();
   if (useColor()) {
-    emit(chalk.blue(`${icons.start} ${message}`));
+    emit(chalk.blue(`${icons.info} ${message}`));
   } else {
-    emit(`${icons.start} ${message}`);
+    emit(`${icons.info} ${message}`);
   }
 }
 function createSpinner(message) {
@@ -1325,38 +912,13 @@ var ElapsedTimer = class {
 };
 
 export {
-  policyConfigSchema,
-  policyConfigInputSchema,
-  pullRequestRefSchema,
-  issueMetadataSchema,
-  taskPlanSchema,
-  sessionSnapshotSchema,
-  webConfigSchema,
-  issuesConfigSchema,
-  prReviewConfigSchema,
+  createInitialSnapshot,
+  reduceSessionEvent,
   NullPublisher,
+  MemoryPublisher,
   FilePublisher,
   setSessionPublisher,
   getSessionPublisher,
-  writeFileAtomic,
-  parseUsage,
-  sumUsage,
-  divideUsage,
-  formatTokens,
-  hasUsageData,
-  isoNow,
-  loadTaskPlan,
-  saveTaskPlan,
-  initializeState,
-  hasPendingCorrection,
-  allStoriesPass,
-  selectActiveStory,
-  applyStoryMetrics,
-  markIssueInProgress,
-  markIssueCompleted,
-  setLastError,
-  clearLastError,
-  trimErrorMessage,
   setVerbose,
   isVerbose,
   setOutputCallback,
@@ -1365,8 +927,12 @@ export {
   getStoryUpdateCallback,
   setStoryStageCallback,
   getStoryStageCallback,
+  setActivityCallback,
+  getActivityCallback,
   setGlobalTimeout,
   getGlobalTimeout,
+  setInactivityTimeout,
+  getInactivityTimeout,
   useUnicode,
   useColor,
   getIcons,
@@ -1380,4 +946,4 @@ export {
   formatDuration,
   ElapsedTimer
 };
-//# sourceMappingURL=chunk-HC2MT7BX.js.map
+//# sourceMappingURL=chunk-IYV6KNVF.js.map