issue-flow 0.11.1 → 0.12.0

package/dist/chunk-BAUPQXPE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/storage/lock.ts"],"sourcesContent":["import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';\nimport { hostname } from 'node:os';\nimport { dirname } from 'node:path';\nimport { type RunLock, runLockSchema } from './schemas.js';\n\n/**\n * Run ownership: who is executing in this project right now.\n *\n * Generalised from `web/lock.ts`, which has guarded the monitoring server the\n * same way since it existed — atomic `wx` create, `process.kill(pid, 0)` for\n * liveness, and a read that degrades to \"no lock\" on anything malformed. What\n * this module adds is the piece a *long* run needs and a server does not: a\n * **heartbeat**. A web server proves it is alive by answering a health probe;\n * a pipeline has no port to probe, so it says so in the file instead.\n *\n * The two signals answer different questions and both are needed:\n *\n * - the **pid** catches the machine that rebooted or the process that was\n *   `kill -9`ed — the lock outlives its owner, and nothing else would notice;\n * - the **heartbeat** catches the owner that is technically alive but no longer\n *   running (a pid reused by an unrelated process is the same case), and it is\n *   the only signal that survives being read from another host.\n *\n * Nothing here is destructive by inference: a lock is only taken over when it\n * is stale by both measures the policy states, and taking one over is reported\n * to the caller (`reclaimedFrom`) so the run can be recorded as interrupted\n * rather than silently restarted.\n */\n\n/** The lock is rewritten this often while a run holds it. */\nexport const RUN_LOCK_HEARTBEAT_MS = 10_000;\n\n/**\n * How many missed heartbeats make a lock stale.\n *\n * Three, not one: a machine under load, a suspended laptop or a slow\n * filesystem can miss a beat without the run being dead, and stealing a lock\n * from a live owner is the failure this module exists to prevent.\n */\nexport const RUN_LOCK_STALE_INTERVALS = 3;\n\n/** How many times a claim is retried after clearing a stale lock. */\nconst CLAIM_RETRIES = 3;\n\nexport interface RunLockHandle {\n  readonly lock: RunLock;\n  /**\n   * The dead owner this lock was taken from, when it was taken from one.\n   *\n   * `null` on a clean acquisition. Non-null is the fact a caller records as an\n   * *interrupted* run: something was executing here and never finished.\n   */\n  readonly reclaimedFrom: RunLock | null;\n  /** Stop the heartbeat and remove the lock. Never rejects. */\n  release(): Promise<void>;\n}\n\nexport type AcquireRunLockResult =\n  | { ok: true; handle: RunLockHandle }\n  | { ok: false; owner: RunLock };\n\nexport interface AcquireRunLockOptions {\n  /** Issue (or queue) identifier this run works on. */\n  target: string;\n  /** Rewrite interval. Also the unit `staleIntervals` counts. */\n  heartbeatMs?: number;\n  staleIntervals?: number;\n  /** Injectable identity, so a test can pretend to be another process. */\n  pid?: number;\n  host?: string;\n  /** Injectable clock, so staleness is testable without waiting. */\n  clock?: () => number;\n  /** Called once, when a stale lock is taken over. Never throws through. */\n  onTakeover?: (previous: RunLock) => void;\n  /**\n   * Start the rewriting timer. Default true; a test that drives the clock by\n   * hand turns it off and calls `touchRunLock` itself.\n   */\n  heartbeat?: boolean;\n}\n\n/**\n * `process.kill(pid, 0)` throws `ESRCH` when the pid is gone and `EPERM` when\n * it is alive but owned by another user — **only `ESRCH` means \"not alive\"**.\n * Reading `EPERM` as death is how a lock gets stolen from a healthy run\n * started by another user.\n */\nexport function isProcessAlive(pid: number): boolean {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch (err) {\n    return (err as NodeJS.ErrnoException).code === 'EPERM';\n  }\n}\n\n/**\n * Read a lock, degrading anything unreadable to \"no lock\".\n *\n * A partial write, a file from an incompatible release, a truncated JSON: all\n * of them mean the same thing operationally, and none of them justifies\n * failing a run. Same behaviour as `readWebLock` and `loadGlobalConfig`.\n */\nexport async function readRunLock(lockFile: string): Promise<RunLock | null> {\n  let raw: string;\n  try {\n    raw = await readFile(lockFile, 'utf-8');\n  } catch {\n    return null;\n  }\n  try {\n    const result = runLockSchema.safeParse(JSON.parse(raw));\n    return result.success ? result.data : null;\n  } catch {\n    return null;\n  }\n}\n\n/** Remove a lock file. Best effort; never rejects. */\nexport async function removeRunLock(lockFile: string): Promise<void> {\n  try {\n    await rm(lockFile, { force: true });\n  } catch {\n    /* best-effort cleanup */\n  }\n}\n\nexport interface StalenessOptions {\n  heartbeatMs?: number;\n  staleIntervals?: number;\n  clock?: () => number;\n  /** Treat this pid as our own, so a re-entrant claim is not \"stale\". */\n  pid?: number;\n  host?: string;\n}\n\n/**\n * Whether `lock` may be taken over.\n *\n * A lock written on another host cannot be judged by pid — `process.kill` there\n * says nothing about a process here — so on a foreign host only the heartbeat\n * decides. That is the case a shared filesystem creates, and reading it wrong\n * is how two machines end up on the same branch.\n */\nexport function isRunLockStale(lock: RunLock, options: StalenessOptions = {}): boolean {\n  const heartbeatMs = options.heartbeatMs ?? RUN_LOCK_HEARTBEAT_MS;\n  const staleIntervals = options.staleIntervals ?? RUN_LOCK_STALE_INTERVALS;\n  const now = (options.clock ?? Date.now)();\n  const host = options.host ?? hostname();\n\n  const beat = Date.parse(lock.lastHeartbeatAt);\n  const silent = Number.isNaN(beat) || now - beat > heartbeatMs * staleIntervals;\n\n  if (lock.host !== host) return silent;\n  return silent || !isProcessAlive(lock.pid);\n}\n\n/** Whether this very process already owns `lock`. */\nfunction isSelf(lock: RunLock, pid: number, host: string): boolean {\n  return lock.pid === pid && lock.host === host;\n}\n\n/**\n * One line naming the owner, for the message a refused invocation prints.\n *\n * The pid alone is useless to a person; the pid *plus the host plus when it\n * last said anything* is what lets them decide between waiting and killing it.\n */\nexport function describeRunLockOwner(lock: RunLock): string {\n  return `pid ${lock.pid} on ${lock.host} (issue ${lock.target}, started ${lock.startedAt}, last heartbeat ${lock.lastHeartbeatAt})`;\n}\n\n/** Rewrite the lock with a fresh heartbeat. Never rejects. */\nexport async function touchRunLock(lockFile: string, lock: RunLock, at: string): Promise<RunLock> {\n  const next: RunLock = { ...lock, lastHeartbeatAt: at };\n  try {\n    await writeFile(lockFile, `${JSON.stringify(next, null, 2)}\\n`, 'utf-8');\n  } catch {\n    // A heartbeat that cannot be written is not worth failing a run over: the\n    // worst case is that another invocation eventually judges us stale, which\n    // is the same outcome as this process having died.\n  }\n  return next;\n}\n\n/**\n * Atomic exclusive create. `wx` fails with `EEXIST` when someone else won the\n * race, which is what lets two concurrent invocations agree on one winner\n * without a lock for the lock.\n */\nasync function claim(lockFile: string, lock: RunLock): Promise<boolean> {\n  try {\n    await mkdir(dirname(lockFile), { recursive: true });\n    await writeFile(lockFile, `${JSON.stringify(lock, null, 2)}\\n`, {\n      encoding: 'utf-8',\n      flag: 'wx',\n    });\n    return true;\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === 'EEXIST') return false;\n    throw err;\n  }\n}\n\n/**\n * Take ownership of the run in this project, or report who already has it.\n *\n * Three outcomes, and only three:\n *\n * 1. **free** — the lock is claimed and a heartbeat starts;\n * 2. **held by a dead owner** — the stale lock is cleared, claimed, and the\n *    previous owner comes back on `reclaimedFrom` so the caller can record the\n *    interrupted run;\n * 3. **held by a live owner** — `{ ok: false, owner }`, and the caller refuses\n *    with a message naming it. Nothing is deleted, nothing is retried into\n *    submission.\n *\n * A lock this very process already holds is outcome 1 with a no-op release:\n * re-entering is not a conflict, and a nested acquisition must not remove the\n * file the outer one still owns.\n */\nexport async function acquireRunLock(\n  lockFile: string,\n  options: AcquireRunLockOptions,\n): Promise<AcquireRunLockResult> {\n  const pid = options.pid ?? process.pid;\n  const host = options.host ?? hostname();\n  const heartbeatMs = options.heartbeatMs ?? RUN_LOCK_HEARTBEAT_MS;\n  const clock = options.clock ?? Date.now;\n  const staleness: StalenessOptions = {\n    heartbeatMs,\n    ...(options.staleIntervals === undefined ? {} : { staleIntervals: options.staleIntervals }),\n    clock,\n    pid,\n    host,\n  };\n\n  let reclaimedFrom: RunLock | null = null;\n\n  for (let attempt = 0; attempt <= CLAIM_RETRIES; attempt++) {\n    const at = new Date(clock()).toISOString();\n    const mine: RunLock = {\n      pid,\n      host,\n      target: options.target,\n      startedAt: at,\n      lastHeartbeatAt: at,\n    };\n\n    if (await claim(lockFile, mine)) {\n      return { ok: true, handle: startHandle(lockFile, mine, reclaimedFrom, options) };\n    }\n\n    const existing = await readRunLock(lockFile);\n\n    if (existing === null) {\n      // Unreadable: a partial write, or a file from a shape we do not know.\n      // Treated as absent, exactly as `readRunLock` documents.\n      await removeRunLock(lockFile);\n      continue;\n    }\n\n    if (isSelf(existing, pid, host)) {\n      return { ok: true, handle: nestedHandle(existing) };\n    }\n\n    if (!isRunLockStale(existing, staleness)) {\n      return { ok: false, owner: existing };\n    }\n\n    reclaimedFrom = existing;\n    try {\n      options.onTakeover?.(existing);\n    } catch {\n      // A caller's bookkeeping must not decide whether the run starts.\n    }\n    await removeRunLock(lockFile);\n  }\n\n  // Every attempt lost the race and every lock read was stale or unreadable:\n  // something else is fighting for this file. Refusing is the safe answer.\n  const owner = await readRunLock(lockFile);\n  if (owner !== null) return { ok: false, owner };\n  return {\n    ok: false,\n    owner: {\n      pid: 0,\n      host,\n      target: options.target,\n      startedAt: new Date(clock()).toISOString(),\n      lastHeartbeatAt: new Date(clock()).toISOString(),\n    },\n  };\n}\n\nfunction startHandle(\n  lockFile: string,\n  lock: RunLock,\n  reclaimedFrom: RunLock | null,\n  options: AcquireRunLockOptions,\n): RunLockHandle {\n  const heartbeatMs = options.heartbeatMs ?? RUN_LOCK_HEARTBEAT_MS;\n  const clock = options.clock ?? Date.now;\n  let current = lock;\n  let timer: NodeJS.Timeout | null = null;\n\n  if (options.heartbeat !== false) {\n    timer = setInterval(() => {\n      void touchRunLock(lockFile, current, new Date(clock()).toISOString()).then((next) => {\n        current = next;\n      });\n    }, heartbeatMs);\n    // The heartbeat must never be the reason a process stays alive.\n    timer.unref();\n  }\n\n  return {\n    lock,\n    reclaimedFrom,\n    release: async () => {\n      if (timer !== null) {\n        clearInterval(timer);\n        timer = null;\n      }\n      await removeRunLock(lockFile);\n    },\n  };\n}\n\n/** A re-entrant acquisition: same owner, no timer of its own, no removal. */\nfunction nestedHandle(lock: RunLock): RunLockHandle {\n  return { lock, reclaimedFrom: null, release: async () => {} };\n}\n"],"mappings":"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","names":[]}

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

@@ -1,332 +1,7 @@
 #!/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 {
+  isoNow
+} from "./chunk-CD5ULRVC.js";
 
 // src/core/session-state.ts
 import { mkdir, rename, writeFile } from "fs/promises";
@@ -917,230 +592,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) {
@@ -1177,6 +628,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";
@@ -1325,38 +783,11 @@ var ElapsedTimer = class {
 };
 
 export {
-  policyConfigSchema,
-  policyConfigInputSchema,
-  pullRequestRefSchema,
-  issueMetadataSchema,
-  taskPlanSchema,
-  sessionSnapshotSchema,
-  webConfigSchema,
-  issuesConfigSchema,
-  prReviewConfigSchema,
   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,
@@ -1367,6 +798,8 @@ export {
   getStoryStageCallback,
   setGlobalTimeout,
   getGlobalTimeout,
+  setInactivityTimeout,
+  getInactivityTimeout,
   useUnicode,
   useColor,
   getIcons,
@@ -1380,4 +813,4 @@ export {
   formatDuration,
   ElapsedTimer
 };
-//# sourceMappingURL=chunk-HC2MT7BX.js.map
+//# sourceMappingURL=chunk-BYZDPR7N.js.map