issue-flow 0.12.0 → 0.14.0

package/dist/chunk-LBGHI4S2.js

@@ -0,0 +1,1264 @@
+#!/usr/bin/env node
+
+// src/agents/types.ts
+var AGENT_PHASES = [
+  "analyze",
+  "generate",
+  "prd",
+  "plan",
+  "execute",
+  "review",
+  "pr",
+  "pr-review"
+];
+function isAgentPhase(value) {
+  return AGENT_PHASES.includes(value);
+}
+function isAgentProviderId(value) {
+  return value === "claude" || value === "codex" || value === "cursor" || value === "antigravity";
+}
+var CLAUDE_CAPABILITIES = {
+  extraDirectories: "flag",
+  addDirs: true,
+  toolAllowlist: true,
+  maxTurns: true,
+  osSandbox: false,
+  modelSelection: true,
+  modelDiscovery: false,
+  usage: "tokens-and-cost",
+  reportsUsage: true,
+  reportsCost: true,
+  sessionResume: false,
+  authProbe: "none",
+  bareModelAliases: true,
+  promptChannel: "both",
+  nativeTimeout: false,
+  contextFileName: "CLAUDE.md",
+  contextFileMaxBytes: null,
+  toolNameCase: "CamelCase",
+  readOnlyMode: "native"
+};
+var CODEX_CAPABILITIES = {
+  extraDirectories: "flag",
+  addDirs: true,
+  toolAllowlist: false,
+  maxTurns: false,
+  osSandbox: true,
+  modelSelection: true,
+  modelDiscovery: false,
+  usage: "tokens-only",
+  reportsUsage: true,
+  reportsCost: false,
+  sessionResume: true,
+  authProbe: "exit-code",
+  bareModelAliases: false,
+  promptChannel: "both",
+  nativeTimeout: false,
+  contextFileName: "AGENTS.md",
+  contextFileMaxBytes: 32 * 1024,
+  toolNameCase: "none",
+  readOnlyMode: "sandbox"
+};
+var CURSOR_CAPABILITIES = {
+  extraDirectories: "permission-file",
+  addDirs: false,
+  toolAllowlist: false,
+  maxTurns: false,
+  osSandbox: true,
+  modelSelection: true,
+  modelDiscovery: true,
+  usage: "none",
+  reportsUsage: false,
+  reportsCost: false,
+  sessionResume: true,
+  authProbe: "text",
+  bareModelAliases: false,
+  promptChannel: "argv",
+  nativeTimeout: false,
+  contextFileName: "AGENTS.md",
+  contextFileMaxBytes: null,
+  toolNameCase: "lowercase",
+  readOnlyMode: "native"
+};
+var ANTIGRAVITY_CAPABILITIES = {
+  extraDirectories: "flag",
+  addDirs: true,
+  toolAllowlist: false,
+  maxTurns: false,
+  osSandbox: true,
+  modelSelection: true,
+  modelDiscovery: true,
+  usage: "tokens-only",
+  reportsUsage: true,
+  reportsCost: false,
+  sessionResume: true,
+  authProbe: "none",
+  bareModelAliases: false,
+  promptChannel: "argv",
+  nativeTimeout: true,
+  contextFileName: "AGENTS.md",
+  contextFileMaxBytes: null,
+  toolNameCase: "CamelCase",
+  readOnlyMode: "native"
+};
+var AGENT_SCHEMA_VERSION = 1;
+
+// 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(),
+  pullRequestTitleConvention: z.string().min(1).optional(),
+  issueReference: z.enum(["closes", "refs"]).optional(),
+  typeMap: z.record(z.string(), 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(),
+    pullRequestTitleConvention: z.string().nullish(),
+    issueReference: z.enum(["closes", "refs"]).nullish(),
+    typeMap: z.record(z.string(), z.string().min(1)).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 runOwnerSchema = z2.object({
+  pid: z2.number().int().positive(),
+  host: z2.string(),
+  startedAt: z2.string()
+});
+var issueRunStateSchema = z2.object({
+  status: z2.enum(["idle", "running", "waiting", "retrying", "paused", "blocked", "failed"]).default("idle"),
+  currentPhase: z2.string().nullable().default(null),
+  attempt: z2.number().int().min(0).default(0),
+  lastHeartbeatAt: z2.string().nullable().default(null),
+  blockedReason: z2.string().nullable().default(null),
+  owner: runOwnerSchema.nullable().default(null)
+});
+var failureKindSchema = z2.enum([
+  "network",
+  "timeout",
+  "stalled",
+  "rate_limit",
+  "provider_down",
+  "provider_crash",
+  "authentication",
+  "configuration",
+  "repository_state",
+  "task_execution",
+  "internal",
+  "unknown"
+]);
+var normalizedUsageSchema = z2.object({
+  inputTokens: z2.number().optional(),
+  outputTokens: z2.number().optional(),
+  cacheReadTokens: z2.number().optional(),
+  cacheCreationTokens: z2.number().optional(),
+  reasoningTokens: z2.number().optional(),
+  details: z2.record(z2.string(), z2.number()).optional(),
+  source: z2.enum(["provider", "unavailable"])
+});
+var pricingSnapshotSchema = z2.object({
+  tableVersion: z2.string(),
+  modelKey: z2.string(),
+  inputPerMillion: z2.number(),
+  outputPerMillion: z2.number(),
+  cacheReadPerMillion: z2.number().optional(),
+  cacheWritePerMillion: z2.number().optional(),
+  capturedAt: z2.string()
+});
+var costRecordSchema = z2.discriminatedUnion("status", [
+  z2.object({ status: z2.literal("reported"), amount: z2.number(), currency: z2.literal("USD") }),
+  z2.object({
+    status: z2.literal("estimated"),
+    amount: z2.number(),
+    currency: z2.literal("USD"),
+    pricing: pricingSnapshotSchema
+  }),
+  z2.object({
+    status: z2.literal("unknown"),
+    reason: z2.enum(["not_reported", "no_pricing", "unknown_model", "subscription", "zero_rated"])
+  })
+]);
+var executionRecordSchema = z2.object({
+  id: z2.string(),
+  sessionId: z2.string().nullable(),
+  purpose: z2.enum([
+    "analyze",
+    "generate",
+    "prd",
+    "plan",
+    "execute",
+    "review",
+    "pr",
+    "pr-review",
+    "verify"
+  ]),
+  attempt: z2.number().int().positive(),
+  trigger: z2.enum(["initial", "retry", "fallback", "correction", "escalation"]),
+  triggerReason: failureKindSchema.nullable(),
+  agent: z2.object({
+    harness: z2.string(),
+    provider: z2.string().nullable(),
+    harnessVersion: z2.string().nullable().optional(),
+    model: z2.object({
+      requested: z2.string().nullable(),
+      resolved: z2.string().nullable(),
+      source: z2.enum(["provider", "config", "unavailable"])
+    }),
+    providerSessionId: z2.string().nullable()
+  }),
+  startedAt: z2.string(),
+  finishedAt: z2.string().nullable(),
+  durationMs: z2.number().nullable(),
+  cliDurationMs: z2.number().nullable().optional(),
+  harnessStartupMs: z2.number().nullable().optional(),
+  apiDurationMs: z2.number().nullable().optional(),
+  ttftMs: z2.number().nullable().optional(),
+  numTurns: z2.number().nullable().optional(),
+  usage: normalizedUsageSchema.nullable(),
+  cost: costRecordSchema,
+  status: z2.enum(["running", "completed", "failed", "timeout", "cancelled", "interrupted"]),
+  failure: z2.object({
+    kind: failureKindSchema,
+    message: z2.string(),
+    exitCode: z2.number().nullable()
+  }).nullable(),
+  stopReason: z2.enum([
+    "completed",
+    "failed",
+    "timeout",
+    "cancelled",
+    "max_attempts",
+    "max_cost",
+    "max_duration"
+  ]).nullable().optional(),
+  iteration: z2.number().int().optional(),
+  correctionCycle: z2.number().int().min(0).optional(),
+  storyIds: z2.array(z2.string()).optional(),
+  owner: z2.object({ pid: z2.number().int(), host: z2.string() }).nullable().optional(),
+  routingDecision: z2.object({
+    selected: z2.string(),
+    actual: z2.string().optional(),
+    candidates: z2.array(z2.unknown()).optional(),
+    reasonCodes: z2.array(z2.string()).optional()
+  }).passthrough().nullable().optional(),
+  verdict: z2.object({
+    status: z2.enum(["passed", "failed", "unverified"]),
+    level: z2.string().nullable().optional(),
+    independence: z2.string().nullable().optional()
+  }).nullable().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,
+  /**
+   * Where the run stands right now. Purely additive: absent in every plan
+   * written before it, and absent is not the same as `idle` — it means the
+   * plan predates the field, which is why there is no `.default()` here.
+   */
+  runState: issueRunStateSchema.optional(),
+  pullRequest: pullRequestRefSchema.optional(),
+  prReview: prReviewStateSchema.optional(),
+  userStories: z2.array(userStorySchema),
+  /**
+   * Per-invocation history. `.optional()` and no `.default([])`: a plan that
+   * predates the field must not grow an empty array just because it was saved.
+   */
+  executions: z2.array(executionRecordSchema).optional()
+});
+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(),
+  harnessExecutionMs: z2.number().nullable().default(null),
+  orchestrationOverheadMs: z2.number().nullable().default(null),
+  harnessStartupMs: z2.number().nullable().default(null),
+  ttftMs: z2.number().nullable().default(null),
+  attemptCount: z2.number().nullable().default(null),
+  retryDurationMs: z2.number().nullable().default(null),
+  ...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),
+  history: z2.array(
+    z2.object({
+      at: z2.string(),
+      stage: storyStageSchema,
+      detail: z2.string().nullable()
+    })
+  ).default([]),
+  ...sessionUsageShape
+});
+var sessionConfigurationValueSchema = z2.object({
+  value: z2.string().nullable(),
+  source: z2.enum(["default", "global", "project", "env", "cli", "fallback"])
+});
+var sessionConfigurationSchema = z2.object({
+  precedence: z2.array(z2.string()),
+  defaultProvider: sessionConfigurationValueSchema,
+  defaultModel: sessionConfigurationValueSchema,
+  phases: z2.array(
+    z2.object({
+      phase: z2.string(),
+      provider: sessionConfigurationValueSchema,
+      model: sessionConfigurationValueSchema
+    })
+  ),
+  fallbacks: z2.array(z2.string()),
+  overrides: z2.array(z2.string())
+});
+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()
+  }),
+  executions: z2.array(executionRecordSchema).default([]),
+  processLogs: z2.array(
+    z2.object({
+      at: z2.string(),
+      phase: z2.string(),
+      executionId: z2.string().nullable(),
+      provider: z2.string(),
+      stream: z2.enum(["stdout", "stderr", "combined"]),
+      message: z2.string()
+    })
+  ).default([]),
+  configuration: sessionConfigurationSchema.nullable().default(null),
+  // Additive resilience projection. Every field defaults so session.json from
+  // before provider failover/observability remains readable without a schema
+  // version bump.
+  resilience: z2.object({
+    attempt: z2.number().int().nonnegative().default(0),
+    provider: z2.string().nullable().default(null),
+    model: z2.string().nullable().default(null),
+    lastFailureKind: z2.enum([
+      "network",
+      "timeout",
+      "stalled",
+      "rate_limit",
+      "provider_down",
+      "provider_crash",
+      "authentication",
+      "configuration",
+      "repository_state",
+      "task_execution",
+      "internal",
+      "unknown"
+    ]).nullable().default(null),
+    cooldownUntil: z2.string().nullable().default(null),
+    lastActivityAt: z2.string().nullable().default(null)
+  }).default({
+    attempt: 0,
+    provider: null,
+    model: null,
+    lastFailureKind: null,
+    cooldownUntil: null,
+    lastActivityAt: null
+  }),
+  git: z2.object({
+    branch: z2.string().nullable(),
+    baseBranch: z2.string().nullable(),
+    branchCreated: z2.boolean().nullable().default(null),
+    startCommit: z2.string().nullable().default(null),
+    commits: z2.array(
+      z2.object({
+        hash: z2.string(),
+        subject: z2.string(),
+        committedAt: z2.string().nullable().default(null),
+        storyId: z2.string().nullable().default(null)
+      })
+    )
+  }),
+  // 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(),
+    agent: z2.string().nullable().default(null),
+    model: z2.string().nullable().default(null)
+  }).nullable(),
+  // Additive: a session.json written before the acceptance contract existed
+  // parses as "not reported". schemaVersion stays 1.
+  verification: z2.object({
+    verdict: z2.enum(["passed", "failed", "unverified"]).nullable(),
+    level: z2.string().nullable(),
+    independence: z2.string().nullable()
+  }).nullable().default(null)
+});
+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", "github"]).default("local")
+});
+var verifyCheckSchema = z2.object({
+  id: z2.string().min(1),
+  run: z2.string().optional(),
+  expectFiles: z2.array(z2.string()).optional(),
+  fatal: z2.boolean().optional()
+});
+var verifyConfigSchema = z2.object({
+  level: z2.enum(["L0", "L1", "L2", "L3", "L5"]).default("L1"),
+  triggers: z2.array(z2.string()).default([]),
+  pairings: z2.record(z2.string(), z2.string()).default({}),
+  contract: z2.array(verifyCheckSchema).optional(),
+  crossVerify: z2.boolean().default(true)
+});
+var routingConfigSchema = z2.object({
+  mode: z2.enum(["off", "shadow", "recommend", "active"]).default("shadow"),
+  profile: z2.enum(["economy", "balanced", "quality", "speed"]).default("balanced"),
+  escalation: z2.object({
+    enabled: z2.boolean().default(false),
+    minAttemptsBeforeEscalation: z2.number().int().positive().default(2),
+    maxEscalations: z2.number().int().nonnegative().default(2),
+    maxRungs: z2.array(z2.enum(["effort", "model", "harness", "review", "decompose"])).default(["effort", "model", "harness"])
+  }).default({
+    enabled: false,
+    minAttemptsBeforeEscalation: 2,
+    maxEscalations: 2,
+    maxRungs: ["effort", "model", "harness"]
+  }),
+  ceilings: z2.object({
+    maxCostUsdPerIssue: z2.number().nonnegative().nullable().default(null),
+    maxDurationMsPerIssue: z2.number().nonnegative().nullable().default(null),
+    maxExecutionsPerIssue: z2.number().int().nonnegative().nullable().default(null),
+    onCeiling: z2.literal("block").default("block")
+  }).default({
+    maxCostUsdPerIssue: null,
+    maxDurationMsPerIssue: null,
+    maxExecutionsPerIssue: null,
+    onCeiling: "block"
+  })
+});
+
+// src/agents/schemas.ts
+import { z as z3 } from "zod";
+var agentProviderIdSchema = z3.enum(["claude", "codex", "cursor", "antigravity"]);
+var codexSandboxSchema = z3.enum(["read-only", "workspace-write", "danger-full-access"]);
+var codexReasoningEffortSchema = z3.enum(["minimal", "low", "medium", "high", "xhigh"]);
+var claudeSettingsSchema = z3.object({
+  ignoreUserConfig: z3.boolean(),
+  strictMcpConfig: z3.boolean()
+}).partial();
+var codexSettingsSchema = z3.object({
+  reasoningEffort: codexReasoningEffortSchema,
+  sandbox: codexSandboxSchema,
+  ignoreUserConfig: z3.boolean(),
+  skipGitRepoCheck: z3.boolean(),
+  configOverrides: z3.record(z3.string(), z3.union([z3.string(), z3.number(), z3.boolean()]))
+}).partial();
+var cursorSandboxSchema = z3.enum(["enabled", "disabled"]);
+var cursorPermissionsFileSchema = z3.enum(["global", "project", "none"]);
+var cursorSettingsSchema = z3.object({
+  sandbox: cursorSandboxSchema,
+  approveMcps: z3.boolean(),
+  permissionsFile: cursorPermissionsFileSchema,
+  minVersion: z3.string().min(1),
+  force: z3.boolean().refine((value) => value !== false, {
+    message: "agent.cursor.force cannot be false: without --force, Cursor finishes with exit 0 and writes nothing."
+  })
+}).partial();
+var antigravityEffortSchema = z3.enum(["low", "medium", "high"]);
+var antigravitySettingsSchema = z3.object({
+  effort: antigravityEffortSchema,
+  sandbox: z3.boolean(),
+  executeTimeout: z3.union([z3.number().int(), z3.string().min(1), z3.null()]),
+  maxPromptBytes: z3.number().int().positive(),
+  minVersion: z3.string().min(1),
+  skipPermissions: z3.boolean().refine((value) => value !== false, {
+    message: "agent.antigravity.skipPermissions cannot be false: without --dangerously-skip-permissions, Antigravity finishes SUCCESS and writes nothing."
+  })
+}).partial();
+var agentBlockSchema = z3.object({
+  provider: agentProviderIdSchema,
+  model: z3.string().min(1).nullable(),
+  claude: claudeSettingsSchema,
+  codex: codexSettingsSchema,
+  cursor: cursorSettingsSchema,
+  antigravity: antigravitySettingsSchema
+}).partial();
+var agentPhasesSchema = z3.object({
+  analyze: agentBlockSchema,
+  generate: agentBlockSchema,
+  prd: agentBlockSchema,
+  plan: agentBlockSchema,
+  execute: agentBlockSchema,
+  review: agentBlockSchema,
+  pr: agentBlockSchema,
+  "pr-review": agentBlockSchema
+}).partial();
+var agentConfigInputSchema = z3.object({
+  provider: agentProviderIdSchema,
+  model: z3.string().min(1).nullable(),
+  claude: claudeSettingsSchema,
+  codex: codexSettingsSchema,
+  cursor: cursorSettingsSchema,
+  antigravity: antigravitySettingsSchema,
+  phases: agentPhasesSchema
+}).partial();
+function parsePhasesInput(value, warn) {
+  if (value === void 0 || value === null) return {};
+  if (typeof value !== "object" || Array.isArray(value)) {
+    warn('Ignoring "agent.phases": expected an object.');
+    return {};
+  }
+  const result = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (!AGENT_PHASES.includes(key)) {
+      warn(`Ignoring unknown agent phase "${key}".`);
+      continue;
+    }
+    const parsed = agentBlockSchema.safeParse(raw);
+    if (!parsed.success) {
+      warn(`Ignoring agent.phases.${key}: ${parsed.error.issues[0]?.message ?? "invalid value"}.`);
+      continue;
+    }
+    result[key] = parsed.data;
+  }
+  return result;
+}
+
+// src/storage/schemas.ts
+import { z as z4 } from "zod";
+var STORAGE_SCHEMA_VERSION = 1;
+var userStoryNumberingSourceSchema = z4.enum(["history", "start-us", "none"]);
+var userStoryNumberingDecisionSchema = z4.object({
+  /** The `US-NNN` number the `plan` prompt was told to continue from. */
+  nextNumber: z4.number().int().positive(),
+  source: userStoryNumberingSourceSchema,
+  /** Issue the decision was made for. */
+  issueNumber: z4.string().min(1),
+  decidedAt: z4.string().min(1),
+  /** Human-readable origin, e.g. the previous story id and issue it came from. */
+  detail: z4.string().optional()
+});
+var projectMetadataSchema = z4.object({
+  schemaVersion: z4.number().int().positive(),
+  projectId: z4.string().min(1),
+  root: z4.string().min(1),
+  /** Normalized remote (`host/org/repo`), or null when the project has none. */
+  remoteUrl: z4.string().nullable(),
+  createdAt: z4.string().min(1),
+  updatedAt: z4.string().min(1),
+  /** Null until the project is used by a pipeline run. */
+  lastAttemptAt: z4.string().nullable(),
+  /**
+   * Most recent User Story numbering decision made by `plan` (issue #36).
+   * Absent on a project whose `plan` never ran through the numbering
+   * resolver, or on a `metadata.json` written before the feature existed.
+   */
+  userStoryNumbering: userStoryNumberingDecisionSchema.optional()
+});
+var webShape = webConfigSchema.shape;
+var globalWebConfigSchema = z4.object({
+  port: webShape.port.unwrap(),
+  host: webShape.host.unwrap(),
+  refreshSeconds: webShape.refreshSeconds.unwrap(),
+  logLimit: webShape.logLimit.unwrap()
+}).partial();
+var globalRetryConfigSchema = z4.object({
+  retryLimit: z4.number().int().nonnegative(),
+  retryForever: z4.boolean(),
+  backoffBaseSeconds: z4.number().nonnegative(),
+  backoffMaxSeconds: z4.number().nonnegative()
+}).partial();
+var resilienceProfileSchema = z4.enum([
+  "default",
+  "continuous"
+]);
+var jitterSchema = z4.enum(["none", "full"]);
+var failoverModeSchema = z4.enum([
+  "never",
+  "after_attempts",
+  "immediate"
+]);
+var exhaustedActionSchema = z4.enum(["fail", "block"]);
+var retryPolicyOverrideSchema = z4.object({
+  maxAttempts: z4.number().int().nonnegative(),
+  initialDelayMs: z4.number().nonnegative(),
+  maxDelayMs: z4.number().nonnegative(),
+  backoffFactor: z4.number().min(1),
+  jitter: jitterSchema,
+  retryForever: z4.boolean(),
+  failover: failoverModeSchema,
+  failoverAfterAttempts: z4.number().int().positive(),
+  onExhausted: exhaustedActionSchema
+}).partial();
+var retryOverridesByKind = {
+  network: retryPolicyOverrideSchema,
+  timeout: retryPolicyOverrideSchema,
+  stalled: retryPolicyOverrideSchema,
+  rateLimit: retryPolicyOverrideSchema,
+  providerDown: retryPolicyOverrideSchema,
+  providerCrash: retryPolicyOverrideSchema,
+  authentication: retryPolicyOverrideSchema,
+  configuration: retryPolicyOverrideSchema,
+  repositoryState: retryPolicyOverrideSchema,
+  taskExecution: retryPolicyOverrideSchema,
+  internal: retryPolicyOverrideSchema,
+  unknown: retryPolicyOverrideSchema
+};
+var resilienceRetryConfigSchema = z4.object(retryOverridesByKind).partial();
+var resilienceProvidersConfigSchema = z4.object({
+  failover: z4.boolean(),
+  chain: z4.array(z4.string().min(1)),
+  cooldownMs: z4.number().nonnegative(),
+  maxCooldownMs: z4.number().nonnegative(),
+  failureWindowMs: z4.number().positive(),
+  failuresToTrip: z4.number().int().positive()
+}).partial();
+var providerHealthStatusSchema = z4.enum([
+  "healthy",
+  "degraded",
+  "unavailable",
+  "rate_limited",
+  "auth_failed",
+  "half_open"
+]);
+var providerHealthRecordSchema = z4.object({
+  status: providerHealthStatusSchema.default("healthy"),
+  failures: z4.array(
+    z4.object({
+      at: z4.string(),
+      kind: z4.enum([
+        "network",
+        "timeout",
+        "stalled",
+        "rate_limit",
+        "provider_down",
+        "provider_crash",
+        "authentication",
+        "configuration",
+        "repository_state",
+        "task_execution",
+        "internal",
+        "unknown"
+      ])
+    })
+  ).default([]),
+  consecutiveFailures: z4.number().int().nonnegative().default(0),
+  cooldownLevel: z4.number().int().nonnegative().default(0),
+  cooldownUntil: z4.string().nullable().default(null),
+  lastFailureKind: z4.enum([
+    "network",
+    "timeout",
+    "stalled",
+    "rate_limit",
+    "provider_down",
+    "provider_crash",
+    "authentication",
+    "configuration",
+    "repository_state",
+    "task_execution",
+    "internal",
+    "unknown"
+  ]).nullable().default(null),
+  lastFailureAt: z4.string().nullable().default(null),
+  lastSuccessAt: z4.string().nullable().default(null),
+  probeInFlight: z4.boolean().default(false),
+  probeStartedAt: z4.string().nullable().default(null)
+});
+var providersHealthSchema = z4.object({
+  schemaVersion: z4.literal(1).default(1),
+  providers: z4.record(z4.string(), providerHealthRecordSchema).default({})
+});
+var resilienceQueueConfigSchema = z4.object({
+  onIssueFailure: z4.enum(["stop", "skip", "block"]),
+  maxIssueAttempts: z4.number().int().positive()
+}).partial();
+var resilienceWatchdogConfigSchema = z4.object({
+  inactivityTimeoutMs: z4.number().int().nonnegative()
+}).partial();
+var resilienceJournalConfigSchema = z4.object({
+  enabled: z4.boolean(),
+  maxFileBytes: z4.number().int().positive()
+}).partial();
+var resilienceDecomposeConfigSchema = z4.object({
+  auto: z4.boolean()
+}).partial();
+var resilienceConfigSchema = z4.object({
+  profile: resilienceProfileSchema,
+  /** Whether a credential failure may migrate to another provider. */
+  failoverOnAuth: z4.boolean(),
+  retry: resilienceRetryConfigSchema,
+  providers: resilienceProvidersConfigSchema,
+  queue: resilienceQueueConfigSchema,
+  watchdog: resilienceWatchdogConfigSchema,
+  journal: resilienceJournalConfigSchema,
+  decompose: resilienceDecomposeConfigSchema
+}).partial();
+var telemetryPricingOverrideSchema = z4.object({
+  inputPerMillion: z4.number(),
+  outputPerMillion: z4.number(),
+  cacheReadPerMillion: z4.number(),
+  cacheWritePerMillion: z4.number()
+}).partial();
+var telemetryConfigInputSchema = z4.object({
+  enabled: z4.boolean(),
+  maxExecutions: z4.number().int().positive(),
+  pricing: z4.object({
+    estimate: z4.boolean(),
+    overrides: z4.record(z4.string(), telemetryPricingOverrideSchema)
+  }).partial()
+}).partial();
+var globalCommitConfigSchema = z4.object({
+  signoff: z4.boolean(),
+  conventional: z4.boolean()
+}).partial();
+var globalConfigSchema = z4.object({
+  schemaVersion: z4.number().int().positive(),
+  /** Override for the directory holding `projects/`. */
+  storageDir: z4.string().min(1),
+  web: globalWebConfigSchema,
+  retry: globalRetryConfigSchema,
+  commit: globalCommitConfigSchema,
+  resilience: resilienceConfigSchema,
+  agent: agentConfigInputSchema,
+  telemetry: telemetryConfigInputSchema
+}).partial();
+var webLockSchema = z4.object({
+  pid: z4.number().int().positive(),
+  port: z4.number().int().positive(),
+  host: z4.string().min(1),
+  startedAt: z4.string().min(1)
+});
+var runLockSchema = z4.object({
+  pid: z4.number().int().positive(),
+  /** `os.hostname()`. A pid only means something on the host that wrote it. */
+  host: z4.string().min(1),
+  /** The issue (or queue) identifier the owner is running. */
+  target: z4.string().min(1),
+  startedAt: z4.string().min(1),
+  lastHeartbeatAt: z4.string().min(1),
+  /** Absent on a foreground run written before this field existed. */
+  detached: z4.boolean().optional()
+});
+var executionPlanIssueSchema = z4.object({
+  id: z4.string().min(1),
+  number: z4.number().int().positive().nullable(),
+  title: z4.string(),
+  url: z4.string().nullable(),
+  source: z4.string().min(1),
+  position: z4.number().int().positive(),
+  // `blocked` and `skipped` are additive: no plan written before them can
+  // carry one, and a reader that does not know them was never given one.
+  status: z4.enum(["pending", "in_progress", "completed", "failed", "blocked", "skipped"]),
+  origin: z4.enum(["requested", "discovered"]),
+  role: z4.enum(["executable", "container"]).default("executable"),
+  externalDependencies: z4.array(z4.string()).default([]),
+  dependsOn: z4.array(z4.string()).default([]),
+  parent: z4.string().nullable().default(null),
+  priority: z4.enum(["high", "medium", "low"]).nullable().default(null),
+  heuristic: z4.boolean().default(false),
+  failedPhase: z4.string().nullable().default(null),
+  lastError: z4.object({ category: z4.string(), message: z4.string(), at: z4.string() }).nullable().default(null),
+  startedAt: z4.string().nullable().default(null),
+  completedAt: z4.string().nullable().default(null),
+  // Both default, so an execution-plan.json written by an earlier release
+  // parses unchanged and reads as "never attempted, not blocked".
+  attempts: z4.number().int().min(0).default(0),
+  blockedReason: z4.string().nullable().default(null)
+});
+var executionPlanSchema = z4.object({
+  schemaVersion: z4.literal(1),
+  id: z4.string().min(1),
+  project: z4.string().min(1),
+  requested: z4.array(z4.string().min(1)),
+  branchName: z4.string().nullable().default(null),
+  noBranch: z4.boolean().default(false),
+  prReview: z4.boolean().default(false),
+  status: z4.enum(["pending", "in_progress", "completed", "failed"]),
+  createdAt: z4.string().min(1),
+  updatedAt: z4.string().min(1),
+  truncated: z4.boolean().default(false),
+  issues: z4.array(executionPlanIssueSchema),
+  excluded: z4.array(
+    z4.object({
+      id: z4.string().min(1),
+      number: z4.number().int().positive().nullable(),
+      title: z4.string(),
+      url: z4.string().nullable(),
+      reason: z4.string()
+    })
+  ).default([]),
+  pullRequest: pullRequestRefSchema.optional()
+});
+
+// src/storage/lock.ts
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { hostname } from "os";
+import { dirname } from "path";
+var RUN_LOCK_HEARTBEAT_MS = 1e4;
+var RUN_LOCK_STALE_INTERVALS = 3;
+var CLAIM_RETRIES = 3;
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+async function readRunLock(lockFile) {
+  let raw;
+  try {
+    raw = await readFile(lockFile, "utf-8");
+  } catch {
+    return null;
+  }
+  try {
+    const result = runLockSchema.safeParse(JSON.parse(raw));
+    return result.success ? result.data : null;
+  } catch {
+    return null;
+  }
+}
+async function removeRunLock(lockFile) {
+  try {
+    await rm(lockFile, { force: true });
+  } catch {
+  }
+}
+function isRunLockStale(lock, options = {}) {
+  const heartbeatMs = options.heartbeatMs ?? RUN_LOCK_HEARTBEAT_MS;
+  const staleIntervals = options.staleIntervals ?? RUN_LOCK_STALE_INTERVALS;
+  const now = (options.clock ?? Date.now)();
+  const host = options.host ?? hostname();
+  const beat = Date.parse(lock.lastHeartbeatAt);
+  const silent = Number.isNaN(beat) || now - beat > heartbeatMs * staleIntervals;
+  if (lock.host !== host) return silent;
+  return silent || !isProcessAlive(lock.pid);
+}
+function isSelf(lock, pid, host) {
+  return lock.pid === pid && lock.host === host;
+}
+function describeRunLockOwner(lock) {
+  return `pid ${lock.pid} on ${lock.host} (issue ${lock.target}, started ${lock.startedAt}, last heartbeat ${lock.lastHeartbeatAt})`;
+}
+async function touchRunLock(lockFile, lock, at) {
+  const next = { ...lock, lastHeartbeatAt: at };
+  try {
+    await writeFile(lockFile, `${JSON.stringify(next, null, 2)}
+`, "utf-8");
+  } catch {
+  }
+  return next;
+}
+async function claim(lockFile, lock) {
+  try {
+    await mkdir(dirname(lockFile), { recursive: true });
+    await writeFile(lockFile, `${JSON.stringify(lock, null, 2)}
+`, {
+      encoding: "utf-8",
+      flag: "wx"
+    });
+    return true;
+  } catch (err) {
+    if (err.code === "EEXIST") return false;
+    throw err;
+  }
+}
+async function acquireRunLock(lockFile, options) {
+  const pid = options.pid ?? process.pid;
+  const host = options.host ?? hostname();
+  const heartbeatMs = options.heartbeatMs ?? RUN_LOCK_HEARTBEAT_MS;
+  const clock = options.clock ?? Date.now;
+  const staleness = {
+    heartbeatMs,
+    ...options.staleIntervals === void 0 ? {} : { staleIntervals: options.staleIntervals },
+    clock,
+    pid,
+    host
+  };
+  let reclaimedFrom = null;
+  for (let attempt = 0; attempt <= CLAIM_RETRIES; attempt++) {
+    const at = new Date(clock()).toISOString();
+    const mine = {
+      pid,
+      host,
+      target: options.target,
+      startedAt: at,
+      lastHeartbeatAt: at,
+      ...options.detached === true ? { detached: true } : {}
+    };
+    if (await claim(lockFile, mine)) {
+      return { ok: true, handle: startHandle(lockFile, mine, reclaimedFrom, options) };
+    }
+    const existing = await readRunLock(lockFile);
+    if (existing === null) {
+      await removeRunLock(lockFile);
+      continue;
+    }
+    if (isSelf(existing, pid, host)) {
+      return { ok: true, handle: nestedHandle(existing) };
+    }
+    if (!isRunLockStale(existing, staleness)) {
+      return { ok: false, owner: existing };
+    }
+    reclaimedFrom = existing;
+    try {
+      options.onTakeover?.(existing);
+    } catch {
+    }
+    await removeRunLock(lockFile);
+  }
+  const owner = await readRunLock(lockFile);
+  if (owner !== null) return { ok: false, owner };
+  return {
+    ok: false,
+    owner: {
+      pid: 0,
+      host,
+      target: options.target,
+      startedAt: new Date(clock()).toISOString(),
+      lastHeartbeatAt: new Date(clock()).toISOString()
+    }
+  };
+}
+function startHandle(lockFile, lock, reclaimedFrom, options) {
+  const heartbeatMs = options.heartbeatMs ?? RUN_LOCK_HEARTBEAT_MS;
+  const clock = options.clock ?? Date.now;
+  let current = lock;
+  let timer = null;
+  if (options.heartbeat !== false) {
+    timer = setInterval(() => {
+      void touchRunLock(lockFile, current, new Date(clock()).toISOString()).then((next) => {
+        current = next;
+      });
+    }, heartbeatMs);
+    timer.unref();
+  }
+  return {
+    lock,
+    reclaimedFrom,
+    release: async () => {
+      if (timer !== null) {
+        clearInterval(timer);
+        timer = null;
+      }
+      await removeRunLock(lockFile);
+    }
+  };
+}
+function nestedHandle(lock) {
+  return { lock, reclaimedFrom: null, release: async () => {
+  } };
+}
+
+export {
+  AGENT_PHASES,
+  isAgentPhase,
+  isAgentProviderId,
+  CLAUDE_CAPABILITIES,
+  CODEX_CAPABILITIES,
+  CURSOR_CAPABILITIES,
+  ANTIGRAVITY_CAPABILITIES,
+  AGENT_SCHEMA_VERSION,
+  policyConfigSchema,
+  policyConfigInputSchema,
+  issueMetadataSchema,
+  taskPlanSchema,
+  sessionSnapshotSchema,
+  webConfigSchema,
+  issuesConfigSchema,
+  prReviewConfigSchema,
+  verifyConfigSchema,
+  routingConfigSchema,
+  agentConfigInputSchema,
+  parsePhasesInput,
+  STORAGE_SCHEMA_VERSION,
+  projectMetadataSchema,
+  providersHealthSchema,
+  resilienceConfigSchema,
+  telemetryConfigInputSchema,
+  globalConfigSchema,
+  webLockSchema,
+  executionPlanSchema,
+  isProcessAlive,
+  readRunLock,
+  isRunLockStale,
+  describeRunLockOwner,
+  acquireRunLock
+};
+//# sourceMappingURL=chunk-LBGHI4S2.js.map