issue-flow 0.18.0 → 0.20.0

package/dist/chunk-XNK5UN2D.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schemas.ts","../src/policy/schemas.ts"],"sourcesContent":["import { z } from 'zod';\nimport type { ClaudeUsage } from './core/metrics.js';\nimport type { SessionSnapshot } from './core/session-state.js';\nimport type { IssueMetadata, IssuesConfig } from './issues/types.js';\nimport type { ExecutionRecord } from './telemetry/types.js';\n\n/**\n * Zod schemas for validating tasks.json structure, Issue metadata, headless\n * invocation outputs, the web monitoring session snapshot and the web\n * configuration.\n */\n\n/**\n * Token/cost metrics of a single `claude` invocation, mirroring ClaudeUsage in\n * src/core/metrics.ts. Every field is optional: the CLI only reports what it\n * knows, and an absent field means \"not reported\", never zero.\n */\nexport const claudeUsageSchema = z.object({\n  inputTokens: z.number().optional(),\n  outputTokens: z.number().optional(),\n  cacheReadTokens: z.number().optional(),\n  cacheCreationTokens: z.number().optional(),\n  costUsd: z.number().optional(),\n}) satisfies z.ZodType<ClaudeUsage>;\n\nexport const userStoryStatusSchema = z.enum(['backlog', 'in_progress', 'in_review', 'done']);\n\n/**\n * Fine-grained execution stage — mirrors `StoryStage` in `src/types.ts`. See\n * that type's doc comment for what each value means and which pipeline event\n * produces it.\n */\nexport const storyStageSchema = z.enum([\n  'pending',\n  'executing',\n  'awaiting_review',\n  'in_review',\n  'in_correction',\n  'done',\n  'failed',\n]);\n\n/**\n * The metrics fields are additive and optional: plans written before they\n * existed keep parsing, and nothing is filled in with artificial zeros.\n *\n * `status` and `dependencies` follow the same rule and are `.optional()` rather\n * than `.default()` on purpose: a legacy plan must not gain a `'backlog'` and an\n * empty array it never declared just because `saveTaskPlan` rewrote it. `stage`\n * and friends follow the exact same treatment — nothing in the pipeline writes\n * them back onto `tasks.json`, so they stay `.optional()` too.\n */\nexport const userStorySchema = z.object({\n  id: z.string(),\n  title: z.string(),\n  description: z.string(),\n  acceptanceCriteria: z.array(z.string()),\n  priority: z.number().int().positive(),\n  passes: z.boolean(),\n  notes: z.string(),\n  ...claudeUsageSchema.shape,\n  durationSeconds: z.number().optional(),\n  status: userStoryStatusSchema.optional(),\n  dependencies: z.array(z.string()).optional(),\n  stage: storyStageSchema.optional(),\n  stageSince: z.string().optional(),\n  stageDetail: z.string().optional(),\n});\n\nexport const pipelineStateSchema = z.object({\n  analyzeCompleted: z.boolean().optional(),\n  prdCompleted: z.boolean(),\n  jsonCompleted: z.boolean(),\n  executionCompleted: z.boolean(),\n  reviewCompleted: z.boolean(),\n  prCreated: z.boolean(),\n  prReviewCompleted: z.boolean().optional(),\n});\n\n/**\n * Pull Request opened by the `pr` phase. Optional on the plan: plans written\n * before the field existed (and runs with `--no-branch`) simply omit it.\n */\nexport const pullRequestRefSchema = z.object({\n  number: z.number().int().positive(),\n  url: z.string(),\n  headBranch: z.string(),\n  createdAt: z.string(),\n});\n\nexport const prReviewRecommendationSchema = z.enum([\n  'APPROVE',\n  'APPROVE_WITH_SUGGESTIONS',\n  'REQUEST_CHANGES',\n]);\n\n/**\n * State of the opt-in `pr-review` phase. `enabled` and `rounds` carry defaults\n * so a partially written object still parses instead of invalidating the plan.\n */\nexport const prReviewStateSchema = z.object({\n  enabled: z.boolean().default(false),\n  pullRequestNumber: z.number().int().positive().optional(),\n  rounds: z.number().int().min(0).default(0),\n  lastRecommendation: prReviewRecommendationSchema.optional(),\n  lastReviewedAt: z.string().optional(),\n});\n\nconst lastErrorSchema = z.object({\n  category: z.string(),\n  message: z.string(),\n  at: z.string(),\n});\n\n/**\n * Persisted metadata for an Issue stored on disk (issues/<id>/metadata.json).\n * `satisfies` keeps this schema in lockstep with the IssueMetadata interface in\n * src/issues/types.ts — changing one without the other fails the typecheck.\n */\nexport const issueMetadataSchema = z.object({\n  schemaVersion: z.literal(1),\n  id: z.string().min(1),\n  number: z.number().int().positive().nullable(),\n  source: z.enum(['github', 'local']),\n  title: z.string(),\n  labels: z.array(z.string()),\n  state: z.enum(['open', 'closed']),\n  createdAt: z.string(),\n  updatedAt: z.string(),\n  contentHash: z.string(),\n  remote: z\n    .object({\n      provider: z.enum(['github', 'local']),\n      ref: z.string(),\n      syncedAt: z.string(),\n      syncedContentHash: z.string(),\n    })\n    .optional(),\n}) satisfies z.ZodType<IssueMetadata>;\n\n/**\n * tasks.json structure. Deliberately permissive: plans written by older\n * versions must keep loading, so `issueUrl` is optional (Issues with no remote\n * have no URL) and `issueNumber` accepts non-numeric local identifiers.\n */\n/**\n * `TaskPlan.runState`, written by the pipeline and read on resumption.\n *\n * Optional as a whole — a plan from before it existed has none — but every\n * field inside carries a default, so a partially written object (a process\n * killed mid-write) still parses into a usable state instead of invalidating\n * the plan. That is the same discipline `prReviewStateSchema` follows.\n */\nexport const runOwnerSchema = z.object({\n  pid: z.number().int().positive(),\n  host: z.string(),\n  startedAt: z.string(),\n});\n\nexport const issueRunStateSchema = z.object({\n  status: z\n    .enum(['idle', 'running', 'waiting', 'retrying', 'paused', 'blocked', 'failed'])\n    .default('idle'),\n  currentPhase: z.string().nullable().default(null),\n  attempt: z.number().int().min(0).default(0),\n  lastHeartbeatAt: z.string().nullable().default(null),\n  blockedReason: z.string().nullable().default(null),\n  owner: runOwnerSchema.nullable().default(null),\n});\n\nconst failureKindSchema = z.enum([\n  'network',\n  'timeout',\n  'stalled',\n  'rate_limit',\n  'provider_down',\n  'provider_crash',\n  'authentication',\n  'configuration',\n  'repository_state',\n  'task_execution',\n  'internal',\n  'unknown',\n]);\n\nconst normalizedUsageSchema = z.object({\n  inputTokens: z.number().optional(),\n  outputTokens: z.number().optional(),\n  cacheReadTokens: z.number().optional(),\n  cacheCreationTokens: z.number().optional(),\n  reasoningTokens: z.number().optional(),\n  details: z.record(z.string(), z.number()).optional(),\n  source: z.enum(['provider', 'unavailable']),\n});\n\nconst pricingSnapshotSchema = z.object({\n  tableVersion: z.string(),\n  modelKey: z.string(),\n  inputPerMillion: z.number(),\n  outputPerMillion: z.number(),\n  cacheReadPerMillion: z.number().optional(),\n  cacheWritePerMillion: z.number().optional(),\n  capturedAt: z.string(),\n});\n\nconst costRecordSchema = z.discriminatedUnion('status', [\n  z.object({ status: z.literal('reported'), amount: z.number(), currency: z.literal('USD') }),\n  z.object({\n    status: z.literal('estimated'),\n    amount: z.number(),\n    currency: z.literal('USD'),\n    pricing: pricingSnapshotSchema,\n  }),\n  z.object({\n    status: z.literal('unknown'),\n    reason: z.enum(['not_reported', 'no_pricing', 'unknown_model', 'subscription', 'zero_rated']),\n  }),\n]);\n\n/**\n * One agent invocation. Optional on the plan and without a default array:\n * a plan that never recorded executions must not gain `[]` on rewrite.\n */\nexport const executionRecordSchema = z.object({\n  id: z.string(),\n  sessionId: z.string().nullable(),\n  purpose: z.enum([\n    'analyze',\n    'generate',\n    'prd',\n    'plan',\n    'execute',\n    'review',\n    'pr',\n    'pr-review',\n    'verify',\n  ]),\n  attempt: z.number().int().positive(),\n  trigger: z.enum(['initial', 'retry', 'fallback', 'correction', 'escalation']),\n  triggerReason: failureKindSchema.nullable(),\n  agent: z.object({\n    harness: z.string(),\n    provider: z.string().nullable(),\n    harnessVersion: z.string().nullable().optional(),\n    model: z.object({\n      requested: z.string().nullable(),\n      resolved: z.string().nullable(),\n      source: z.enum(['provider', 'config', 'routing', 'unavailable']),\n    }),\n    providerSessionId: z.string().nullable(),\n  }),\n  startedAt: z.string(),\n  finishedAt: z.string().nullable(),\n  durationMs: z.number().nullable(),\n  cliDurationMs: z.number().nullable().optional(),\n  harnessStartupMs: z.number().nullable().optional(),\n  apiDurationMs: z.number().nullable().optional(),\n  ttftMs: z.number().nullable().optional(),\n  numTurns: z.number().nullable().optional(),\n  usage: normalizedUsageSchema.nullable(),\n  cost: costRecordSchema,\n  status: z.enum(['running', 'completed', 'failed', 'timeout', 'cancelled', 'interrupted']),\n  failure: z\n    .object({\n      kind: failureKindSchema,\n      message: z.string(),\n      exitCode: z.number().nullable(),\n    })\n    .nullable(),\n  stopReason: z\n    .enum([\n      'completed',\n      'failed',\n      'timeout',\n      'cancelled',\n      'max_attempts',\n      'max_cost',\n      'max_duration',\n    ])\n    .nullable()\n    .optional(),\n  iteration: z.number().int().optional(),\n  correctionCycle: z.number().int().min(0).optional(),\n  storyIds: z.array(z.string()).optional(),\n  owner: z.object({ pid: z.number().int(), host: z.string() }).nullable().optional(),\n  routingDecision: z\n    .object({\n      selected: z.union([\n        z.string(),\n        z.object({\n          harness: z.string(),\n          provider: z.string(),\n          model: z.string().nullable().optional(),\n          tier: z.string().optional(),\n        }),\n      ]),\n      actual: z\n        .union([\n          z.string(),\n          z.object({\n            harness: z.string(),\n            provider: z.string(),\n            model: z.string().nullable().optional(),\n            tier: z.string().optional(),\n          }),\n        ])\n        .optional(),\n      candidates: z.array(z.unknown()).optional(),\n      reasonCodes: z.array(z.string()).optional(),\n    })\n    .passthrough()\n    .nullable()\n    .optional(),\n  verdict: z\n    .object({\n      status: z.enum(['passed', 'failed', 'unverified']),\n      level: z.string().nullable().optional(),\n      independence: z.string().nullable().optional(),\n    })\n    .nullable()\n    .optional(),\n}) satisfies z.ZodType<ExecutionRecord>;\n\nexport const taskPlanSchema = z.object({\n  closeIssue: z.boolean().optional(),\n  issueClosedAt: z.string().optional(),\n  project: z.string(),\n  issueNumber: z.union([z.number().int().positive(), z.string().min(1)]),\n  issueUrl: z.string().optional().default(''),\n  branchName: z.string(),\n  noBranch: z.boolean().optional().default(false),\n  description: z.string(),\n  issueStatus: z.enum(['pending', 'in_progress', 'completed']),\n  completedAt: z.string().nullable(),\n  lastAttemptAt: z.string().nullable(),\n  lastError: lastErrorSchema.nullable(),\n  correctionCycle: z.number().int().min(0),\n  maxCorrectionCycles: z.number().int().min(0),\n  /**\n   * Findings from the most recent failed review, verbatim. Non-null means the\n   * issue has a pending correction even if every userStories[].passes is\n   * already true — the execute phase must address these before the field is\n   * cleared back to null. See core/engine.ts's early-return guards.\n   */\n  lastReviewFindings: z.string().nullable().optional().default(null),\n  pipeline: pipelineStateSchema,\n  /**\n   * Where the run stands right now. Purely additive: absent in every plan\n   * written before it, and absent is not the same as `idle` — it means the\n   * plan predates the field, which is why there is no `.default()` here.\n   */\n  runState: issueRunStateSchema.optional(),\n  pullRequest: pullRequestRefSchema.optional(),\n  prReview: prReviewStateSchema.optional(),\n  userStories: z.array(userStorySchema),\n  /**\n   * Per-invocation history. `.optional()` and no `.default([])`: a plan that\n   * predates the field must not grow an empty array just because it was saved.\n   */\n  executions: z.array(executionRecordSchema).optional(),\n});\n\nexport const headlessResultSchema = z.object({\n  success: z.boolean(),\n  result: z.string(),\n  cost: claudeUsageSchema.nullable(),\n  error: z.string().nullable(),\n});\n\nconst sessionLogEntrySchema = z.object({\n  at: z.string(),\n  level: z.enum(['info', 'warn', 'error']),\n  message: z.string(),\n});\n\n/**\n * Usage counters attached to a phase or a story in the session snapshot.\n * Unlike claudeUsageSchema (a single invocation, optional fields), these are\n * always present and nullable: null means \"never reported\", not zero.\n *\n * They default to null on input so a session.json written before the metrics\n * existed still parses -- absent and null mean the same thing here, and the\n * parsed value keeps the `number | null` shape the snapshot interface declares.\n */\nconst sessionUsageShape = {\n  inputTokens: z.number().nullable().default(null),\n  outputTokens: z.number().nullable().default(null),\n  cacheReadTokens: z.number().nullable().default(null),\n  cacheCreationTokens: z.number().nullable().default(null),\n  costUsd: z.number().nullable().default(null),\n};\n\nconst sessionPhaseSchema = z.object({\n  name: z.string(),\n  status: z.enum(['pending', 'running', 'completed', 'failed']),\n  startedAt: z.string().nullable(),\n  endedAt: z.string().nullable(),\n  durationSeconds: z.number().nullable(),\n  error: z.string().nullable(),\n  harnessExecutionMs: z.number().nullable().default(null),\n  orchestrationOverheadMs: z.number().nullable().default(null),\n  harnessStartupMs: z.number().nullable().default(null),\n  ttftMs: z.number().nullable().default(null),\n  attemptCount: z.number().nullable().default(null),\n  retryDurationMs: z.number().nullable().default(null),\n  ...sessionUsageShape,\n});\n\nconst sessionStorySchema = z.object({\n  id: z.string(),\n  title: z.string(),\n  priority: z.number(),\n  passes: z.boolean(),\n  completedAt: z.string().nullable(),\n  // Also introduced with the metrics, hence the same tolerant default.\n  durationSeconds: z.number().nullable().default(null),\n  // Snapshot fields are always present on output and defaulted on input, so a\n  // session.json written before they existed still parses. This is the mirror\n  // image of userStorySchema, where the same two fields are plainly optional.\n  status: userStoryStatusSchema.default('backlog'),\n  dependencies: z.array(z.string()).default([]),\n  // Published for the panel's story detail view. Same tolerant default as the\n  // fields above: absent (older session.json) and empty resolve to the same\n  // value, so the client never has to tell them apart.\n  description: z.string().default(''),\n  acceptanceCriteria: z.array(z.string()).default([]),\n  // Additive like the rest of this schema: a session.json written before\n  // `stage` existed parses into 'pending'/null, the same values a fresh\n  // snapshot starts a story at.\n  stage: storyStageSchema.default('pending'),\n  stageSince: z.string().nullable().default(null),\n  stageDetail: z.string().nullable().default(null),\n  history: z\n    .array(\n      z.object({\n        at: z.string(),\n        stage: storyStageSchema,\n        detail: z.string().nullable(),\n      }),\n    )\n    .default([]),\n  ...sessionUsageShape,\n});\n\nconst sessionConfigurationValueSchema = z.object({\n  value: z.string().nullable(),\n  source: z.enum(['default', 'global', 'project', 'env', 'cli', 'fallback', 'recommended']),\n});\n\nconst sessionConfigurationSchema = z.object({\n  precedence: z.array(z.string()),\n  defaultProvider: sessionConfigurationValueSchema,\n  defaultModel: sessionConfigurationValueSchema,\n  phases: z.array(\n    z.object({\n      phase: z.string(),\n      provider: sessionConfigurationValueSchema,\n      model: sessionConfigurationValueSchema,\n    }),\n  ),\n  fallbacks: z.array(z.string()),\n  overrides: z.array(z.string()),\n});\n\n/**\n * Session snapshot served by the web monitoring mode (session.json and the\n * HTTP endpoint). `satisfies` keeps this schema in lockstep with the\n * SessionSnapshot interface in src/core/session-state.ts — changing one\n * without the other fails the typecheck.\n */\nexport const sessionSnapshotSchema = z.object({\n  schemaVersion: z.literal(1),\n  sessionId: z.string().nullable(),\n  readOnly: z.literal(true),\n  capabilities: z.array(z.string()),\n  issue: z.object({\n    number: z.number().nullable(),\n    url: z.string().nullable(),\n    // Additive: a session.json written before the Issue section was enriched\n    // parses into the same \"not reported\" values createInitialSnapshot() uses.\n    title: z.string().nullable().default(null),\n    description: z.string().nullable().default(null),\n    labels: z.array(z.string()).default([]),\n    state: z.string().nullable().default(null),\n  }),\n  status: z.enum(['idle', 'running', 'completed', 'failed']),\n  startedAt: z.string().nullable(),\n  updatedAt: z.string().nullable(),\n  endedAt: z.string().nullable(),\n  elapsedSeconds: z.number().nullable(),\n  estimatedRemainingSeconds: z.number().nullable(),\n  progress: z.object({\n    percent: z.number(),\n    phasesCompleted: z.number(),\n    phasesTotal: z.number(),\n    storiesCompleted: z.number(),\n    storiesTotal: z.number(),\n  }),\n  currentPhase: z.string().nullable(),\n  currentActivity: z\n    .object({\n      story: z.string().nullable(),\n      tool: z.string().nullable(),\n      detail: z.string().nullable(),\n      since: z.string(),\n    })\n    .nullable(),\n  phases: z.array(sessionPhaseSchema),\n  stories: z.array(sessionStorySchema),\n  // The whole aggregate is additive: a snapshot from before it existed parses\n  // into the same \"nothing reported\" object the reducer starts from.\n  metrics: z\n    .object({\n      totalInputTokens: z.number().nullable().default(null),\n      totalOutputTokens: z.number().nullable().default(null),\n      totalCacheReadTokens: z.number().nullable().default(null),\n      totalCacheCreationTokens: z.number().nullable().default(null),\n      totalCostUsd: z.number().nullable().default(null),\n    })\n    .default({\n      totalInputTokens: null,\n      totalOutputTokens: null,\n      totalCacheReadTokens: null,\n      totalCacheCreationTokens: null,\n      totalCostUsd: null,\n    }),\n  execution: z.object({\n    iteration: z.number(),\n    retries: z.number(),\n    correctionCycle: z.number(),\n    maxCorrectionCycles: z.number().nullable(),\n  }),\n  executions: z.array(executionRecordSchema).default([]),\n  processLogs: z\n    .array(\n      z.object({\n        at: z.string(),\n        phase: z.string(),\n        executionId: z.string().nullable(),\n        provider: z.string(),\n        stream: z.enum(['stdout', 'stderr', 'combined']),\n        message: z.string(),\n      }),\n    )\n    .default([]),\n  configuration: sessionConfigurationSchema.nullable().default(null),\n  // Additive resilience projection. Every field defaults so session.json from\n  // before provider failover/observability remains readable without a schema\n  // version bump.\n  resilience: z\n    .object({\n      attempt: z.number().int().nonnegative().default(0),\n      provider: z.string().nullable().default(null),\n      model: z.string().nullable().default(null),\n      lastFailureKind: z\n        .enum([\n          'network',\n          'timeout',\n          'stalled',\n          'rate_limit',\n          'provider_down',\n          'provider_crash',\n          'authentication',\n          'configuration',\n          'repository_state',\n          'task_execution',\n          'internal',\n          'unknown',\n        ])\n        .nullable()\n        .default(null),\n      cooldownUntil: z.string().nullable().default(null),\n      lastActivityAt: z.string().nullable().default(null),\n    })\n    .default({\n      attempt: 0,\n      provider: null,\n      model: null,\n      lastFailureKind: null,\n      cooldownUntil: null,\n      lastActivityAt: null,\n    }),\n  git: z.object({\n    branch: z.string().nullable(),\n    baseBranch: z.string().nullable(),\n    branchCreated: z.boolean().nullable().default(null),\n    startCommit: z.string().nullable().default(null),\n    commits: z.array(\n      z.object({\n        hash: z.string(),\n        subject: z.string(),\n        committedAt: z.string().nullable().default(null),\n        storyId: z.string().nullable().default(null),\n      }),\n    ),\n  }),\n  // Additive like the metrics aggregate: a session.json written before the\n  // repository section existed parses into the same all-null object\n  // createInitialSnapshot() starts from.\n  repository: z\n    .object({\n      name: z.string().nullable().default(null),\n      remoteUrl: z.string().nullable().default(null),\n      branch: z.string().nullable().default(null),\n      headCommit: z.string().nullable().default(null),\n      root: z.string().nullable().default(null),\n    })\n    .default({ name: null, remoteUrl: null, branch: null, headCommit: null, root: null }),\n  pullRequests: z.array(z.object({ number: z.number(), url: z.string(), title: z.string() })),\n  logs: z.array(sessionLogEntrySchema),\n  errors: z.array(sessionLogEntrySchema),\n  warnings: z.array(sessionLogEntrySchema),\n  lastError: z.object({ message: z.string(), at: z.string() }).nullable(),\n  nextSteps: z.array(z.string()),\n  environment: z\n    .object({\n      node: z.string(),\n      platform: z.string(),\n      agent: z.string().nullable().default(null),\n      model: z.string().nullable().default(null),\n      // Additive, like agent/model: a session written before the version was\n      // recorded parses as \"not reported\" instead of failing validation.\n      cliVersion: z.string().nullable().default(null),\n    })\n    .nullable(),\n  // Additive: a session.json written before the acceptance contract existed\n  // parses as \"not reported\". schemaVersion stays 1.\n  verification: z\n    .object({\n      verdict: z.enum(['passed', 'failed', 'unverified']).nullable(),\n      level: z.string().nullable(),\n      independence: z.string().nullable(),\n    })\n    .nullable()\n    .default(null),\n}) satisfies z.ZodType<SessionSnapshot>;\n\n/**\n * Resolved web monitoring configuration. Every field has a default, so\n * parsing a partial object (e.g. the `web` key of .issue-flow.json) fills in\n * the documented defaults.\n */\nexport const webConfigSchema = z.object({\n  enabled: z.boolean().default(false),\n  port: z.number().int().min(1).max(65535).default(3737),\n  host: z.string().min(1).default('0.0.0.0'),\n  refreshSeconds: z.number().positive().default(5),\n  logLimit: z.number().int().positive().default(200),\n  includeLogs: z.boolean().default(true),\n});\n\n/**\n * Resolved Issue provider configuration. Every field has a default that keeps\n * the GitHub-only behaviour, so parsing an empty object yields the exact\n * behaviour of releases without the provider layer.\n */\nexport const issuesConfigSchema = z.object({\n  defaultGenerateTarget: z.enum(['github', 'local', 'both']).default('github'),\n  preferredProvider: z.enum(['github', 'local']).default('github'),\n  conflictPolicy: z.enum(['ask', 'prefer-local', 'prefer-github']).default('ask'),\n  requireConfirmation: z.boolean().default(true),\n}) satisfies z.ZodType<IssuesConfig>;\n\n/**\n * Resolved `pr-review` configuration (the `prReview` key of .issue-flow.json).\n *\n * `publisher` selects the implementation `createPrReviewPublisher()` builds:\n * `local` writes the artifacts under the issue directory, and `github` does\n * that **and** comments on the Pull Request, updating the comment of the same\n * round instead of stacking a new one on every republication.\n *\n * `local` stays the default, so a repository that configures nothing publishes\n * exactly where it always did and never writes to GitHub by surprise.\n */\nexport const prReviewConfigSchema = z.object({\n  publisher: z.enum(['local', 'github']).default('local'),\n});\n\n/**\n * The `policy` key of .issue-flow.json — the repository policy layer. Defined\n * in `policy/schemas.ts` next to the module that consumes it, and re-exported\n * here so `schemas.ts` stays the single index of the file's keys.\n */\nexport {\n  type PolicyConfig,\n  type PolicyConfigInput,\n  type PolicyDiscoveryConfig,\n  policyConfigInputSchema,\n  policyConfigSchema,\n  policyDiscoveryConfigSchema,\n} from './policy/schemas.js';\n\nexport type ValidatedTaskPlan = z.infer<typeof taskPlanSchema>;\nexport type ValidatedIssueMetadata = z.infer<typeof issueMetadataSchema>;\nexport type ValidatedHeadlessResult = z.infer<typeof headlessResultSchema>;\nexport type ValidatedSessionSnapshot = z.infer<typeof sessionSnapshotSchema>;\nexport const verifyCheckSchema = z.object({\n  id: z.string().min(1),\n  run: z.string().optional(),\n  expectFiles: z.array(z.string()).optional(),\n  fatal: z.boolean().optional(),\n});\n\nexport const verifyConfigSchema = z.object({\n  level: z.enum(['L0', 'L1', 'L2', 'L3', 'L5']).default('L1'),\n  triggers: z.array(z.string()).default([]),\n  pairings: z.record(z.string(), z.string()).default({}),\n  contract: z.array(verifyCheckSchema).optional(),\n  crossVerify: z.boolean().default(true),\n});\n\nexport type WebConfig = z.infer<typeof webConfigSchema>;\nexport type PrReviewConfig = z.infer<typeof prReviewConfigSchema>;\nconst routingModeSchema = z.enum(['off', 'shadow', 'recommend', 'active']);\nconst routingProfileSchema = z.enum(['economy', 'balanced', 'quality', 'speed']);\nconst routingPolicySchema = z.literal('recommended');\nconst routingEscalationInputSchema = z\n  .object({\n    enabled: z.boolean(),\n    minAttemptsBeforeEscalation: z.number().int().positive(),\n    maxEscalations: z.number().int().nonnegative(),\n    maxRungs: z.array(z.enum(['effort', 'model', 'harness', 'review', 'decompose'])),\n  })\n  .partial();\nconst routingCeilingsInputSchema = z\n  .object({\n    maxCostUsdPerIssue: z.number().nonnegative().nullable(),\n    maxDurationMsPerIssue: z.number().nonnegative().nullable(),\n    maxExecutionsPerIssue: z.number().int().nonnegative().nullable(),\n    onCeiling: z.literal('block'),\n  })\n  .partial();\n\n/** Intermediate file/API layer: optional fields, with no materialized defaults. */\nexport const routingConfigInputSchema = z\n  .object({\n    mode: routingModeSchema,\n    profile: routingProfileSchema,\n    policy: routingPolicySchema,\n    escalation: routingEscalationInputSchema,\n    ceilings: routingCeilingsInputSchema,\n  })\n  .partial();\n\nexport const routingConfigSchema = z.object({\n  mode: routingModeSchema.default('shadow'),\n  profile: routingProfileSchema.default('balanced'),\n  policy: routingPolicySchema.optional(),\n  escalation: z\n    .object({\n      enabled: z.boolean().default(false),\n      minAttemptsBeforeEscalation: z.number().int().positive().default(2),\n      maxEscalations: z.number().int().nonnegative().default(2),\n      maxRungs: z\n        .array(z.enum(['effort', 'model', 'harness', 'review', 'decompose']))\n        .default(['effort', 'model', 'harness']),\n    })\n    .default({\n      enabled: false,\n      minAttemptsBeforeEscalation: 2,\n      maxEscalations: 2,\n      maxRungs: ['effort', 'model', 'harness'],\n    }),\n  ceilings: z\n    .object({\n      maxCostUsdPerIssue: z.number().nonnegative().nullable().default(null),\n      maxDurationMsPerIssue: z.number().nonnegative().nullable().default(null),\n      maxExecutionsPerIssue: z.number().int().nonnegative().nullable().default(null),\n      onCeiling: z.literal('block').default('block'),\n    })\n    .default({\n      maxCostUsdPerIssue: null,\n      maxDurationMsPerIssue: null,\n      maxExecutionsPerIssue: null,\n      onCeiling: 'block',\n    }),\n});\n\nexport type VerifyConfig = z.infer<typeof verifyConfigSchema>;\nexport type RoutingConfig = z.infer<typeof routingConfigSchema>;\nexport type RoutingConfigInput = z.infer<typeof routingConfigInputSchema>;\n","import { z } from 'zod';\n\n/**\n * Zod schemas for the `policy` key of `.issue-flow.json`.\n *\n * Two shapes, and the difference matters:\n *\n * - {@link policyConfigInputSchema} validates what the user *wrote*, with no\n *   defaults materialized. It is what the file, env and CLI layers are parsed\n *   with, so an absent key stays absent and never shadows the layer below it\n *   (the caveat documented on `mergeConfigLayers`).\n * - {@link policyConfigSchema} is the resolved shape, with `enabled` and the\n *   discovery toggles filled in. The declarations stay optional there too:\n *   materializing them as `null` would make an unset `baseBranch` override the\n *   one discovery found.\n */\n\n/** Which discovery passes run. Every one defaults to on. */\nexport const policyDiscoveryConfigSchema = z.object({\n  issueTemplates: z.boolean().default(true),\n  pullRequestTemplate: z.boolean().default(true),\n  docs: z.boolean().default(true),\n  codeowners: z.boolean().default(true),\n  labels: z.boolean().default(true),\n  issueTypes: z.boolean().default(true),\n});\n\nconst policyIssuesDeclarationSchema = z.object({\n  titleConvention: z.string().min(1).optional(),\n  /**\n   * Whether Issue Flow may create a label the repository does not have.\n   *\n   * `.optional()` rather than `.default(false)`: the resolved declarations must\n   * stay \"only what was written\", or the group would always look declared and\n   * `sources` would report a provenance nobody asked for. The effective default\n   * — false — lives at the call site.\n   *\n   * That default is a deliberate change of behaviour: creating taxonomy without\n   * asking is the defect this exists to stop. A repository that wants the old\n   * behaviour opts back into it.\n   */\n  allowLabelCreation: z.boolean().optional(),\n});\n\nconst policyPullRequestsDeclarationSchema = z.object({\n  baseBranch: z.string().min(1).optional(),\n  titleConvention: z.string().min(1).optional(),\n});\n\nconst policyGitDeclarationSchema = z.object({\n  branchConvention: z.string().min(1).optional(),\n  commitConvention: z.string().min(1).optional(),\n  pullRequestTitleConvention: z.string().min(1).optional(),\n  issueReference: z.enum(['closes', 'refs']).optional(),\n  typeMap: z.record(z.string(), z.string().min(1)).optional(),\n});\n\n/**\n * Resolved policy configuration.\n *\n * `.prefault({})` rather than `.default({})`: in zod 4 a `.default()` value is\n * substituted *without* being parsed by the inner schema, so `discovery` would\n * come back as `{}` with none of its toggles filled in.\n */\nexport const policyConfigSchema = z.object({\n  enabled: z.boolean().default(true),\n  /**\n   * Token budget for the `__REPO_POLICY__` projection. Sections above it are\n   * replaced whole by a pointer rather than truncated — see\n   * `policy/placeholders.ts`.\n   */\n  contextBudget: z.number().int().positive().default(1500),\n  discovery: policyDiscoveryConfigSchema.prefault({}),\n  issues: policyIssuesDeclarationSchema.prefault({}),\n  pullRequests: policyPullRequestsDeclarationSchema.prefault({}),\n  git: policyGitDeclarationSchema.prefault({}),\n});\n\n/**\n * What the user may write. `.nullish()` on every declaration is deliberate:\n * `\"baseBranch\": null` is the natural way to spell \"I do not declare this\",\n * and the loader drops it instead of rejecting the whole key.\n */\nexport const policyConfigInputSchema = z.object({\n  enabled: z.boolean().optional(),\n  contextBudget: z.number().int().positive().optional(),\n  // Spelled out rather than `policyDiscoveryConfigSchema.partial()`: in zod 4\n  // a `.default()` survives `.partial()`, so every toggle would come back\n  // materialized and the input layer would stop meaning \"what the user wrote\".\n  discovery: z\n    .object({\n      issueTemplates: z.boolean().optional(),\n      pullRequestTemplate: z.boolean().optional(),\n      docs: z.boolean().optional(),\n      codeowners: z.boolean().optional(),\n      labels: z.boolean().optional(),\n      issueTypes: z.boolean().optional(),\n    })\n    .optional(),\n  issues: z\n    .object({ titleConvention: z.string().nullish(), allowLabelCreation: z.boolean().optional() })\n    .optional(),\n  pullRequests: z\n    .object({ baseBranch: z.string().nullish(), titleConvention: z.string().nullish() })\n    .optional(),\n  git: z\n    .object({\n      branchConvention: z.string().nullish(),\n      commitConvention: z.string().nullish(),\n      pullRequestTitleConvention: z.string().nullish(),\n      issueReference: z.enum(['closes', 'refs']).nullish(),\n      typeMap: z.record(z.string(), z.string().min(1)).nullish(),\n    })\n    .optional(),\n});\n\nexport type PolicyConfig = z.infer<typeof policyConfigSchema>;\nexport type PolicyDiscoveryConfig = z.infer<typeof policyDiscoveryConfigSchema>;\nexport type PolicyConfigInput = z.infer<typeof policyConfigInputSchema>;\n"],"mappings":"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","names":["z","z"]}

package/dist/{chunk-7UMMFOL2.js → chunk-Y2KOWABB.js}

@@ -4,20 +4,27 @@ import {
   uniqueIds
 } from "./chunk-KMMASOA6.js";
 import {
+  DEFAULT_PIPELINE_STATE,
+  WORKFLOW_PHASES,
   isoNow,
   loadTaskPlan,
   saveTaskPlan
-} from "./chunk-SOM4QA6C.js";
+} from "./chunk-JCR5C5A7.js";
 import {
   executionPlanSchema
-} from "./chunk-ICM463EO.js";
+} from "./chunk-44RF3VFG.js";
+import {
+  getQueueRepository,
+  loadStoredQueue,
+  saveStoredQueue
+} from "./chunk-7MJGYPHF.js";
 import {
   writeFileAtomic
-} from "./chunk-3R27MJ5R.js";
+} from "./chunk-PFWHHYEO.js";
 
 // src/execution/plan.ts
-import { mkdir, readFile } from "fs/promises";
-import { dirname } from "path";
+import { mkdir, readFile } from "node:fs/promises";
+import { dirname } from "node:path";
 import { ZodError } from "zod";
 
 // src/execution/containers.ts
@@ -414,6 +421,11 @@ function buildExecutionPlan(input) {
   };
 }
 async function loadExecutionPlan(path) {
+  const repository = getQueueRepository(path);
+  if (repository !== void 0) {
+    const stored = await loadStoredQueue(repository);
+    if (stored !== null) return stored;
+  }
   const raw = JSON.parse(await readFile(path, "utf-8"));
   try {
     return executionPlanSchema.parse(raw);
@@ -427,8 +439,13 @@ ${issues}`);
   }
 }
 async function saveExecutionPlan(path, plan, now = isoNow) {
-  await mkdir(dirname(path), { recursive: true });
   const stamped = { ...plan, updatedAt: now() };
+  const repository = getQueueRepository(path);
+  if (repository !== void 0) {
+    await saveStoredQueue(repository, stamped);
+    return;
+  }
+  await mkdir(dirname(path), { recursive: true });
   await writeFileAtomic(path, `${JSON.stringify(stamped, null, 2)}
 `);
 }
@@ -539,22 +556,25 @@ function setQueueBranch(plan, branchName) {
 function setQueuePullRequest(plan, pullRequest) {
   return { ...plan, pullRequest };
 }
+function queueNeedsFinalization(plan) {
+  return !plan.noBranch && (!plan.pullRequest || plan.prReview && !plan.prReviewCompleted) || plan.closeIssue === true && plan.issues.some(
+    (entry) => entry.status === "completed" && !(plan.closedIssueIds ?? []).includes(entry.id)
+  );
+}
 
 // src/core/pipeline.ts
-var PIPELINE_PHASES = ["init", "prd", "plan", "execute", "review", "pr"];
+var PIPELINE_PHASES = [
+  "init",
+  ...WORKFLOW_PHASES.filter(({ phase }) => phase !== "pr-review").map(({ phase }) => phase)
+];
 var PIPELINE_PHASES_WITH_PR_REVIEW = [...PIPELINE_PHASES, "pr-review"];
 var PIPELINE_PHASES_NO_BRANCH = PIPELINE_PHASES.filter(
   (p) => p !== "pr"
 );
-var PHASE_TO_FIELD = {
-  init: null,
-  prd: "prdCompleted",
-  plan: "jsonCompleted",
-  execute: "executionCompleted",
-  review: "reviewCompleted",
-  pr: "prCreated",
-  "pr-review": "prReviewCompleted"
-};
+var PHASE_TO_FIELD = Object.fromEntries([
+  ["init", null],
+  ...WORKFLOW_PHASES.map(({ phase, field }) => [phase, field])
+]);
 var PipelineManager = class {
   tasksJsonPath;
   plan;
@@ -619,13 +639,7 @@ var PipelineManager = class {
     this.plan = {
       ...this.plan,
       pipeline: {
-        ...this.plan.pipeline ?? {
-          prdCompleted: false,
-          jsonCompleted: false,
-          executionCompleted: false,
-          reviewCompleted: false,
-          prCreated: false
-        },
+        ...this.plan.pipeline ?? DEFAULT_PIPELINE_STATE,
         [field]: true
       }
     };
@@ -650,9 +664,10 @@ export {
   markQueueIssueBlocked,
   setQueueBranch,
   setQueuePullRequest,
+  queueNeedsFinalization,
   PIPELINE_PHASES,
   PIPELINE_PHASES_WITH_PR_REVIEW,
   PIPELINE_PHASES_NO_BRANCH,
   PipelineManager
 };
-//# sourceMappingURL=chunk-7UMMFOL2.js.map
+//# sourceMappingURL=chunk-Y2KOWABB.js.map

package/dist/chunk-Y2KOWABB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/execution/plan.ts","../src/execution/containers.ts","../src/issues/graph.ts","../src/execution/order.ts","../src/core/pipeline.ts"],"sourcesContent":["import { mkdir, readFile } from 'node:fs/promises';\nimport { dirname } from 'node:path';\nimport { ZodError } from 'zod';\nimport { isoNow } from '../core/state-manager.js';\nimport type { DependencyGraph } from '../issues/graph.js';\nimport type { Issue } from '../issues/types.js';\nimport { getQueueRepository, loadStoredQueue, saveStoredQueue } from '../storage/db/repository.js';\nimport { executionPlanSchema } from '../storage/schemas.js';\nimport type { LastError, PullRequestRef } from '../types.js';\nimport { writeFileAtomic } from '../utils/fs.js';\nimport { isContainer } from './containers.js';\nimport { priorityOf } from './order.js';\nimport type {\n  ExecutionPlan,\n  ExecutionPlanExcluded,\n  ExecutionPlanIssue,\n  QueueIssueRole,\n  QueueIssueStatus,\n  QueueStatus,\n} from './types.js';\n\n/**\n * Building, reading, writing and advancing the execution plan of a queue.\n *\n * The plan is the only state a multi-issue run adds to the storage tree, and it\n * is written **only** for a queue with more than one Issue — a single-issue run\n * leaves the layout exactly as it was.\n */\n\nexport interface BuildExecutionPlanInput {\n  /** Project id of the global storage tree. */\n  projectId: string;\n  /** Identifiers the user asked for, in order; the first one names the queue. */\n  requested: readonly string[];\n  graph: DependencyGraph;\n  /** Ids to run, already ordered by `computeExecutionOrder`. */\n  order: readonly string[];\n  noBranch?: boolean;\n  prReview?: boolean;\n  /** Injectable clock, so tests can assert `createdAt` vs `updatedAt`. */\n  now?: () => string;\n}\n\nfunction parentOf(graph: DependencyGraph, id: string): string | null {\n  for (const node of graph.nodes.values()) {\n    if (node.relations.children.includes(id)) return node.id;\n  }\n  return null;\n}\n\n/** Title/url/number of a node, falling back to what the id alone tells us. */\nfunction describeIssue(\n  issue: Issue | null,\n  id: string,\n): {\n  number: number | null;\n  title: string;\n  url: string | null;\n  source: string;\n} {\n  const parsed = Number.parseInt(id, 10);\n  return {\n    number: issue?.number ?? (Number.isNaN(parsed) ? null : parsed),\n    title: issue?.title ?? '',\n    url: issue?.remoteRef ?? null,\n    source: issue?.source ?? 'github',\n  };\n}\n\n/**\n * Turn a graph plus an order into the persisted plan.\n *\n * Every Issue of the graph that is *not* in the order becomes an `excluded`\n * entry: the consolidated Pull Request reports them as known pending work, so a\n * hierarchy the user chose to trim never disappears silently.\n */\nexport function buildExecutionPlan(input: BuildExecutionPlanInput): ExecutionPlan {\n  const now = input.now ?? isoNow;\n  const at = now();\n  const scheduled = new Set(input.order);\n  const requested = new Set(input.requested);\n\n  const issues: ExecutionPlanIssue[] = input.order.map((id, index) => {\n    const node = input.graph.nodes.get(id);\n    const relations = node?.relations;\n    const described = describeIssue(node?.issue ?? null, id);\n    const children = relations?.children ?? [];\n    const role: QueueIssueRole = isContainer({\n      issue: node?.issue ?? null,\n      children,\n    })\n      ? 'container'\n      : 'executable';\n\n    return {\n      id,\n      number: described.number,\n      title: described.title,\n      url: described.url,\n      source: described.source,\n      position: index + 1,\n      status: 'pending',\n      origin: requested.has(id) ? 'requested' : 'discovered',\n      role,\n      externalDependencies: (relations?.blockedBy ?? []).filter(\n        (blocker) =>\n          !scheduled.has(blocker) && input.graph.nodes.get(blocker)?.issue?.state !== 'closed',\n      ),\n      // Only the constraints that survive inside the queue: a blocker left out\n      // of it is reported in `excluded`, not enforced as a dependency.\n      dependsOn: (relations?.blockedBy ?? []).filter((blocker) => scheduled.has(blocker)),\n      parent: relations?.parent ?? parentOf(input.graph, id),\n      priority: priorityOf(node?.issue?.labels ?? []),\n      heuristic: (relations?.heuristic.length ?? 0) > 0,\n      failedPhase: null,\n      lastError: null,\n      attempts: 0,\n      blockedReason: null,\n      startedAt: null,\n      completedAt: null,\n    };\n  });\n\n  const excluded: ExecutionPlanExcluded[] = [];\n  for (const node of input.graph.nodes.values()) {\n    if (scheduled.has(node.id)) continue;\n    const described = describeIssue(node.issue, node.id);\n    excluded.push({\n      id: node.id,\n      number: described.number,\n      title: described.title,\n      url: described.url,\n      reason:\n        node.issue?.state === 'closed'\n          ? 'Already closed before this run'\n          : 'Discovered in the hierarchy but not selected for this run',\n    });\n  }\n\n  return {\n    schemaVersion: 1,\n    id: input.requested[0] ?? (input.order[0] as string),\n    project: input.projectId,\n    requested: [...input.requested],\n    branchName: null,\n    noBranch: input.noBranch ?? false,\n    prReview: input.prReview ?? false,\n    status: 'pending',\n    createdAt: at,\n    updatedAt: at,\n    truncated: input.graph.truncated,\n    issues,\n    excluded,\n  };\n}\n\n/** Read a persisted plan. Throws with the offending fields on invalid content. */\nexport async function loadExecutionPlan(path: string): Promise<ExecutionPlan> {\n  const repository = getQueueRepository(path);\n  if (repository !== undefined) {\n    const stored = await loadStoredQueue(repository);\n    if (stored !== null) return stored;\n  }\n  const raw: unknown = JSON.parse(await readFile(path, 'utf-8'));\n\n  try {\n    return executionPlanSchema.parse(raw) as ExecutionPlan;\n  } catch (err) {\n    if (err instanceof ZodError) {\n      const issues = err.issues.map((i) => `  - ${i.path.join('.')}: ${i.message}`).join('\\n');\n      throw new Error(`Invalid execution-plan.json at ${path}:\\n${issues}`);\n    }\n    throw err;\n  }\n}\n\n/**\n * Persist a plan atomically, creating the queue directory on first write.\n *\n * `updatedAt` is stamped here so no call site can forget it — the file is the\n * only record of how far a queue got, and a stale timestamp on it is worse than\n * none.\n */\nexport async function saveExecutionPlan(\n  path: string,\n  plan: ExecutionPlan,\n  now: () => string = isoNow,\n): Promise<void> {\n  const stamped: ExecutionPlan = { ...plan, updatedAt: now() };\n  const repository = getQueueRepository(path);\n  if (repository !== undefined) {\n    await saveStoredQueue(repository, stamped);\n    return;\n  }\n  await mkdir(dirname(path), { recursive: true });\n  await writeFileAtomic(path, `${JSON.stringify(stamped, null, 2)}\\n`);\n}\n\n/**\n * The Issue the queue should work on next, or `null` when every one of them is\n * completed.\n *\n * The order of the lookups *is* the resume policy: an interrupted issue\n * (`in_progress`) and a failed one are retried before the queue moves on, and\n * each of them picks up from its own `tasks.json` (phase-level resume) rather\n * than from the start. A `completed` issue is never revisited — that is the\n * whole point of persisting the queue.\n */\nexport interface NextQueueIssueOptions {\n  /**\n   * Ids this invocation is done with, however they ended. A queue that skips a\n   * failing Issue and comes back to it needs a way to say \"not this one again\",\n   * or \"come back later\" becomes \"come back forever\".\n   */\n  exclude?: ReadonlySet<string>;\n}\n\n/**\n * Whether every dependency this Issue declares *inside the queue* is finished.\n *\n * The execution order already places dependencies first, so this only bites\n * once an entry stops being `completed` — skipped, blocked or failed. Handing\n * out an Issue whose blocker was skipped is how a queue produces work that\n * cannot compile.\n */\nfunction dependenciesSatisfied(plan: ExecutionPlan, entry: ExecutionPlanIssue): boolean {\n  return entry.dependsOn.every((id) => {\n    const dependency = plan.issues.find((candidate) => candidate.id === id);\n    if (dependency === undefined) return true;\n    // A container is not work: waiting on it would deadlock the children\n    // that complete it.\n    if (dependency.role === 'container') return true;\n    return dependency.status === 'completed';\n  });\n}\n\n/**\n * The Issue to work on next.\n *\n * The order of the four lookups is the resumption policy:\n * an interrupted Issue first (it was mid-flight), then one that failed on a\n * previous invocation, then the untouched ones, and only at the end the ones\n * this queue deliberately set aside — which is what \"go on with the\n * independent work and come back to it\" means in one line.\n *\n * `blocked` is absent on purpose: it needs a human, and no ordering of the\n * queue changes that.\n */\nexport function nextQueueIssue(\n  plan: ExecutionPlan,\n  options: NextQueueIssueOptions = {},\n): ExecutionPlanIssue | null {\n  const exclude = options.exclude ?? new Set<string>();\n  const eligible = (status: QueueIssueStatus) => (entry: ExecutionPlanIssue) =>\n    entry.role !== 'container' &&\n    entry.status === status &&\n    !exclude.has(entry.id) &&\n    dependenciesSatisfied(plan, entry);\n\n  return (\n    plan.issues.find(eligible('in_progress')) ??\n    plan.issues.find(eligible('failed')) ??\n    plan.issues.find(eligible('pending')) ??\n    plan.issues.find(eligible('skipped')) ??\n    null\n  );\n}\n\n/**\n * Status of the queue derived from its entries.\n *\n * `skipped` is *not* terminal — the queue means to come back to it — so a queue\n * holding one is still `in_progress`. `blocked` is: nothing the queue can do\n * moves it, so a queue that ends with one ends `failed`, which is what a person\n * needs to see.\n */\nexport function queueStatus(plan: ExecutionPlan): QueueStatus {\n  if (plan.issues.some((entry) => entry.status === 'failed' || entry.status === 'blocked')) {\n    return 'failed';\n  }\n  if (plan.issues.every((entry) => entry.status === 'completed')) return 'completed';\n  if (plan.issues.some((entry) => entry.status !== 'pending')) return 'in_progress';\n  return 'pending';\n}\n\n/** Whether every Issue of the queue has been resolved. */\nexport function isQueueComplete(plan: ExecutionPlan): boolean {\n  return plan.issues.every((entry) => entry.status === 'completed');\n}\n\n/** Apply `patch` to one entry and recompute the queue status. Pure. */\nfunction updateIssue(\n  plan: ExecutionPlan,\n  id: string,\n  patch: Partial<ExecutionPlanIssue>,\n): ExecutionPlan {\n  const issues = plan.issues.map((entry) => (entry.id === id ? { ...entry, ...patch } : entry));\n  const next: ExecutionPlan = { ...plan, issues };\n  return { ...next, status: queueStatus(next) };\n}\n\nexport function markQueueIssueInProgress(\n  plan: ExecutionPlan,\n  id: string,\n  now: () => string = isoNow,\n): ExecutionPlan {\n  const current = plan.issues.find((entry) => entry.id === id);\n  return updateIssue(plan, id, {\n    status: 'in_progress',\n    // Preserved across a resume: the queue reports when the work on this Issue\n    // really began, not when it was last picked up.\n    startedAt: current?.startedAt ?? now(),\n    failedPhase: null,\n    lastError: null,\n  });\n}\n\nfunction completeResolvedContainers(plan: ExecutionPlan, now: () => string): ExecutionPlan {\n  let next = plan;\n  let changed = true;\n  while (changed) {\n    changed = false;\n    for (const entry of next.issues) {\n      if (entry.role !== 'container' || entry.status === 'completed') continue;\n      const children = next.issues.filter((candidate) => candidate.parent === entry.id);\n      if (children.length === 0) continue;\n      if (children.every((child) => child.status === 'completed')) {\n        next = updateIssue(next, entry.id, {\n          status: 'completed',\n          completedAt: now(),\n          failedPhase: null,\n          lastError: null,\n        });\n        changed = true;\n      }\n    }\n  }\n  return next;\n}\n\nexport function markQueueIssueCompleted(\n  plan: ExecutionPlan,\n  id: string,\n  now: () => string = isoNow,\n): ExecutionPlan {\n  return completeResolvedContainers(\n    updateIssue(plan, id, {\n      status: 'completed',\n      completedAt: now(),\n      failedPhase: null,\n      lastError: null,\n    }),\n    now,\n  );\n}\n\nexport function markQueueIssueFailed(\n  plan: ExecutionPlan,\n  id: string,\n  failure: { phase: string | null; error: LastError | null },\n): ExecutionPlan {\n  const current = plan.issues.find((entry) => entry.id === id);\n  return updateIssue(plan, id, {\n    status: 'failed',\n    failedPhase: failure.phase,\n    lastError: failure.error,\n    attempts: (current?.attempts ?? 0) + 1,\n  });\n}\n\n/**\n * Set an Issue aside and come back to it later.\n *\n * The difference from `failed` is the whole point of `--on-issue-failure skip`:\n * a failure that stopped this attempt is not a verdict on the eleven other\n * Issues in the queue, and `skipped` is the status that says \"not now\" rather\n * than \"not at all\". `attempts` is incremented here because the counter is what\n * keeps \"come back later\" from becoming \"come back forever\".\n */\nexport function markQueueIssueSkipped(\n  plan: ExecutionPlan,\n  id: string,\n  failure: { phase: string | null; error: LastError | null },\n): ExecutionPlan {\n  const current = plan.issues.find((entry) => entry.id === id);\n  return updateIssue(plan, id, {\n    status: 'skipped',\n    failedPhase: failure.phase,\n    lastError: failure.error,\n    attempts: (current?.attempts ?? 0) + 1,\n  });\n}\n\n/**\n * Stop working on an Issue until a person looks at it.\n *\n * `blocked` is never handed back out by `nextQueueIssue`: waiting cannot fix\n * a missing credential or a repository mid-rebase, and a queue that could\n * unblock itself would spin on the same cause forever.\n */\nexport function markQueueIssueBlocked(\n  plan: ExecutionPlan,\n  id: string,\n  reason: string,\n  failure: { phase: string | null; error: LastError | null },\n): ExecutionPlan {\n  const current = plan.issues.find((entry) => entry.id === id);\n  return updateIssue(plan, id, {\n    status: 'blocked',\n    blockedReason: reason,\n    failedPhase: failure.phase,\n    lastError: failure.error,\n    attempts: (current?.attempts ?? 0) + 1,\n  });\n}\n\n/** Record the branch every Issue of the queue shares. */\nexport function setQueueBranch(plan: ExecutionPlan, branchName: string): ExecutionPlan {\n  return { ...plan, branchName };\n}\n\n/** Record the single Pull Request that consolidated the queue. */\nexport function setQueuePullRequest(\n  plan: ExecutionPlan,\n  pullRequest: PullRequestRef,\n): ExecutionPlan {\n  return { ...plan, pullRequest };\n}\n\n/** Completed implementation can still owe PR delivery, review or explicit closure. */\nexport function queueNeedsFinalization(plan: ExecutionPlan): boolean {\n  return (\n    (!plan.noBranch && (!plan.pullRequest || (plan.prReview && !plan.prReviewCompleted))) ||\n    (plan.closeIssue === true &&\n      plan.issues.some(\n        (entry) => entry.status === 'completed' && !(plan.closedIssueIds ?? []).includes(entry.id),\n      ))\n  );\n}\n","import type { DependencyGraph } from '../issues/graph.js';\nimport type { Issue } from '../issues/types.js';\n\nexport const CONTAINER_SIGNALS = ['children', 'issue-type', 'label', 'title-prefix'] as const;\n\nexport type ContainerSignal = (typeof CONTAINER_SIGNALS)[number];\n\nexport interface ContainerConfig {\n  detect: readonly ContainerSignal[];\n  issueTypes: readonly string[];\n  labels: readonly string[];\n  titlePrefixes: readonly string[];\n}\n\n/** Unconfigured repos: only the universal signal. */\nexport const DEFAULT_CONTAINER_CONFIG: ContainerConfig = {\n  detect: ['children'],\n  issueTypes: ['Epic'],\n  labels: ['epic'],\n  titlePrefixes: ['[Epic]'],\n};\n\nexport interface ContainerProbe {\n  issue: Pick<Issue, 'title' | 'labels' | 'type'> | null;\n  children: readonly string[];\n}\n\nfunction enabled(config: ContainerConfig, signal: ContainerSignal): boolean {\n  return config.detect.includes(signal);\n}\n\nfunction hasTitlePrefix(title: string, prefixes: readonly string[]): boolean {\n  const trimmed = title.trim();\n  return prefixes.some((prefix) => trimmed.toLowerCase().startsWith(prefix.toLowerCase()));\n}\n\n/**\n * Precedence: children > issue type > label > title prefix.\n * Having children always wins when that signal is enabled.\n */\nexport function isContainer(\n  probe: ContainerProbe,\n  config: ContainerConfig = DEFAULT_CONTAINER_CONFIG,\n): boolean {\n  if (enabled(config, 'children') && probe.children.length > 0) return true;\n\n  const issue = probe.issue;\n  if (issue === null) return false;\n\n  if (enabled(config, 'issue-type')) {\n    const type = issue.type?.trim();\n    if (\n      type !== undefined &&\n      type !== '' &&\n      config.issueTypes.some((name) => name.toLowerCase() === type.toLowerCase())\n    ) {\n      return true;\n    }\n  }\n\n  if (enabled(config, 'label')) {\n    const labels = new Set(issue.labels.map((label) => label.toLowerCase()));\n    if (config.labels.some((label) => labels.has(label.toLowerCase()))) return true;\n  }\n\n  if (enabled(config, 'title-prefix') && hasTitlePrefix(issue.title, config.titlePrefixes)) {\n    return true;\n  }\n\n  return false;\n}\n\n/** Root plus every descendant reached through `children`. */\nexport function collectCascadeIds(graph: DependencyGraph, roots: readonly string[]): string[] {\n  const ids = new Set<string>();\n  const walk = (id: string): void => {\n    if (ids.has(id)) return;\n    ids.add(id);\n    for (const child of graph.nodes.get(id)?.relations.children ?? []) {\n      walk(child);\n    }\n  };\n  for (const root of roots) walk(root);\n  return [...ids];\n}\n","import { emptyRelations, uniqueIds } from './relations.js';\nimport type { Issue, IssueRelations } from './types.js';\n\n/**\n * Dependency graph of a set of Issues, built by walking the relations every\n * provider exposes through `fetchRelations`.\n *\n * The traversal is deliberately *structural*: it follows hierarchy\n * (parent/children) and dependencies (blockedBy/blocking) and stops there. Plain\n * mentions are recorded on each node but never expanded — a body citing \"see\n * also #12\" would otherwise drag an unrelated Issue into an execution plan the\n * user is about to confirm.\n */\n\nexport interface DependencyGraphNode {\n  id: string;\n  relations: IssueRelations;\n  /** Distance from the closest root, in traversal hops. */\n  depth: number;\n  /** The Issue itself, when the caller supplied a way to read it. */\n  issue: Issue | null;\n  /** True when the node was requested by the user rather than discovered. */\n  root: boolean;\n}\n\nexport interface DependencyGraph {\n  /** Ids the traversal started from, in the order they were requested. */\n  roots: string[];\n  /** Every discovered node, keyed by id, in discovery order. */\n  nodes: Map<string, DependencyGraphNode>;\n  /**\n   * Dependency cycles found among the discovered nodes, each listed once,\n   * starting at its smallest member. Reported rather than thrown: discovery\n   * must still answer, and it is the ordering layer that refuses to run.\n   */\n  cycles: string[][];\n  /** True when a limit stopped the traversal before it was exhausted. */\n  truncated: boolean;\n  limits: { maxNodes: number; maxDepth: number };\n}\n\n/**\n * Conservative defaults: a real hierarchy is a handful of Issues, and each node\n * costs several API calls. A malformed (or simply huge) graph must not turn a\n * `run` into a rate-limit incident.\n */\nexport const DEFAULT_MAX_NODES = 25;\nexport const DEFAULT_MAX_DEPTH = 3;\n\nexport interface BuildDependencyGraphOptions {\n  maxNodes?: number;\n  maxDepth?: number;\n  /** Issues the caller already resolved, so the traversal does not re-read them. */\n  known?: Iterable<Issue>;\n  /** Reader for the Issues the traversal discovers. Optional. */\n  fetchIssue?: (id: string) => Promise<Issue | null>;\n  /** Warning sink for a source that failed. Silent by default. */\n  warn?: (message: string) => void;\n}\n\n/** Edge `from` → `to`, meaning \"`from` must be resolved before `to`\". */\nexport interface DependencyEdge {\n  from: string;\n  to: string;\n}\n\n/**\n * Ordering constraints of a graph: only hierarchy-free, explicit dependencies.\n *\n * `blockedBy`/`blocking` are the two spellings of the same fact, so both are\n * normalized into a single direction here. Parent/child is **not** a constraint\n * — it is a presentation and tie-breaking concern (see `computeExecutionOrder`),\n * because a parent is usually an umbrella that neither blocks nor is blocked by\n * its children.\n *\n * Edges pointing outside the graph are dropped: an Issue the traversal never\n * reached cannot be scheduled, so a constraint against it is unenforceable.\n */\nexport function dependencyEdges(graph: DependencyGraph): DependencyEdge[] {\n  const edges: DependencyEdge[] = [];\n  const seen = new Set<string>();\n\n  const add = (from: string, to: string): void => {\n    if (from === to || !graph.nodes.has(from) || !graph.nodes.has(to)) return;\n    const key = `${from}->${to}`;\n    if (seen.has(key)) return;\n    seen.add(key);\n    edges.push({ from, to });\n  };\n\n  for (const node of graph.nodes.values()) {\n    for (const blocker of node.relations.blockedBy) {\n      add(blocker, node.id);\n    }\n    for (const blocked of node.relations.blocking) {\n      add(node.id, blocked);\n    }\n  }\n\n  return edges;\n}\n\n/** Every cycle of the dependency edges, each reported once. */\nexport function findCycles(graph: DependencyGraph): string[][] {\n  const adjacency = new Map<string, string[]>();\n  for (const { from, to } of dependencyEdges(graph)) {\n    const list = adjacency.get(from);\n    if (list === undefined) {\n      adjacency.set(from, [to]);\n    } else {\n      list.push(to);\n    }\n  }\n\n  const cycles: string[][] = [];\n  const reported = new Set<string>();\n  const state = new Map<string, 'visiting' | 'done'>();\n  const stack: string[] = [];\n\n  const record = (cycle: string[]): void => {\n    // Rotate to the smallest member so the same cycle found from two entry\n    // points is reported once.\n    let pivot = 0;\n    for (let i = 1; i < cycle.length; i++) {\n      if (compareIds(cycle[i] as string, cycle[pivot] as string) < 0) pivot = i;\n    }\n    const normalized = [...cycle.slice(pivot), ...cycle.slice(0, pivot)];\n    const key = normalized.join('->');\n    if (reported.has(key)) return;\n    reported.add(key);\n    cycles.push(normalized);\n  };\n\n  const visit = (id: string): void => {\n    state.set(id, 'visiting');\n    stack.push(id);\n\n    for (const next of adjacency.get(id) ?? []) {\n      const status = state.get(next);\n      if (status === 'visiting') {\n        record(stack.slice(stack.indexOf(next)));\n        continue;\n      }\n      if (status === undefined) {\n        visit(next);\n      }\n    }\n\n    stack.pop();\n    state.set(id, 'done');\n  };\n\n  for (const id of graph.nodes.keys()) {\n    if (!state.has(id)) visit(id);\n  }\n\n  return cycles;\n}\n\n/** Numeric when both ids are numbers, lexicographic otherwise. */\nexport function compareIds(a: string, b: string): number {\n  const na = Number(a);\n  const nb = Number(b);\n  if (Number.isInteger(na) && Number.isInteger(nb)) {\n    return na - nb;\n  }\n  return a < b ? -1 : a > b ? 1 : 0;\n}\n\n/** Ids a node links to structurally, in traversal order. */\nfunction neighbours(relations: IssueRelations): string[] {\n  return uniqueIds(\n    [\n      ...(relations.parent === null ? [] : [relations.parent]),\n      ...relations.children,\n      ...relations.blockedBy,\n      ...relations.blocking,\n    ],\n    relations.id,\n  );\n}\n\n/**\n * Walk the relations of `roots` breadth-first and return the whole structure.\n *\n * Failures never abort the walk: a node whose relations cannot be read enters\n * the graph with empty relations (and a warning), exactly like an Issue that\n * genuinely relates to nothing. That keeps a partially unavailable API from\n * costing the user the Issues that *were* discovered.\n *\n * Breadth-first is what makes `depth` meaningful under a limit: when the walk is\n * truncated, what is missing is the far edge of the graph, not a random subset.\n */\nexport async function buildDependencyGraph(\n  roots: readonly string[],\n  fetchRelations: (id: string) => Promise<IssueRelations | null>,\n  options: BuildDependencyGraphOptions = {},\n): Promise<DependencyGraph> {\n  const maxNodes = options.maxNodes ?? DEFAULT_MAX_NODES;\n  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;\n  const warn = options.warn ?? ((): void => {});\n\n  const known = new Map<string, Issue>();\n  for (const issue of options.known ?? []) {\n    known.set(issue.id, issue);\n  }\n\n  const rootIds = uniqueIds(roots);\n  const nodes = new Map<string, DependencyGraphNode>();\n  const queued = new Set<string>(rootIds);\n  let truncated = false;\n\n  let frontier: { id: string; depth: number }[] = rootIds.map((id) => ({ id, depth: 0 }));\n\n  while (frontier.length > 0) {\n    const next: { id: string; depth: number }[] = [];\n\n    for (const { id, depth } of frontier) {\n      if (nodes.size >= maxNodes) {\n        truncated = true;\n        break;\n      }\n\n      let relations: IssueRelations | null = null;\n      try {\n        relations = await fetchRelations(id);\n      } catch (err) {\n        warn(\n          `Could not read the relations of issue '${id}': ${err instanceof Error ? err.message : String(err)}`,\n        );\n      }\n\n      let issue = known.get(id) ?? null;\n      if (issue === null && options.fetchIssue !== undefined) {\n        try {\n          issue = await options.fetchIssue(id);\n        } catch (err) {\n          warn(`Could not read issue '${id}': ${err instanceof Error ? err.message : String(err)}`);\n        }\n      }\n\n      const resolved = relations ?? emptyRelations(id);\n      nodes.set(id, { id, relations: resolved, depth, issue, root: rootIds.includes(id) });\n\n      if (depth >= maxDepth) {\n        // Only a node that actually has unexplored neighbours truncates the\n        // graph; a leaf at max depth explored everything there was.\n        if (neighbours(resolved).some((neighbour) => !queued.has(neighbour))) {\n          truncated = true;\n        }\n        continue;\n      }\n\n      for (const neighbour of neighbours(resolved)) {\n        if (queued.has(neighbour)) continue;\n        queued.add(neighbour);\n        next.push({ id: neighbour, depth: depth + 1 });\n      }\n    }\n\n    if (nodes.size >= maxNodes && next.length > 0) {\n      truncated = true;\n      break;\n    }\n    frontier = next;\n  }\n\n  const graph: DependencyGraph = {\n    roots: rootIds,\n    nodes,\n    cycles: [],\n    truncated,\n    limits: { maxNodes, maxDepth },\n  };\n\n  linkReferencedBy(graph);\n  graph.cycles = findCycles(graph);\n\n  return graph;\n}\n\n/**\n * Complete `referencedBy` with the inverse of `references` among the discovered\n * nodes.\n *\n * The origin only reports the citations it can see (GitHub's timeline covers\n * cross-references but not, for instance, a mention added by the textual\n * heuristic); inverting what the graph already holds costs no API call and\n * keeps the two directions consistent inside it.\n */\nfunction linkReferencedBy(graph: DependencyGraph): void {\n  for (const node of graph.nodes.values()) {\n    for (const cited of node.relations.references) {\n      const target = graph.nodes.get(cited);\n      if (target === undefined || target.id === node.id) continue;\n      target.relations.referencedBy = uniqueIds(\n        [...target.relations.referencedBy, node.id],\n        target.id,\n      );\n    }\n  }\n}\n","import { compareIds, type DependencyGraph, dependencyEdges, findCycles } from '../issues/graph.js';\nimport type { IssuePriority } from './types.js';\n\n/**\n * Turning a dependency graph into the order the queue runs in.\n *\n * The criteria are applied in the exact precedence the initiative specifies:\n *\n * 1. **dependencies and blocks** — hard constraints; an Issue never starts\n *    before something it depends on has finished. This is the topological part\n *    and the only one that can make the computation fail (a cycle);\n * 2. **hierarchy** — with two Issues both ready to run, the ancestor goes\n *    first, so an umbrella Issue frames the work of its sub-issues;\n * 3. **priority** — the GitHub labels `high`, `medium` and `low`;\n * 4. **logical order** — the identifier, numerically when it is a number.\n *\n * Everything below the first item is a *tie-break among Issues that are already\n * free to run*, never a constraint: a `high` Issue that depends on a `low` one\n * still runs second, which is the whole point of the feature.\n */\n\nconst PRIORITY_LABELS: Record<string, IssuePriority> = {\n  high: 'high',\n  medium: 'medium',\n  low: 'low',\n};\n\n/** Ranking of a priority; an Issue with no label sorts after every labelled one. */\nconst PRIORITY_RANK: Record<IssuePriority, number> = { high: 0, medium: 1, low: 2 };\nconst NO_PRIORITY_RANK = 3;\n\n/**\n * Priority carried by a label set, or `null` when there is none.\n *\n * Both the bare labels used by this repository (`high`) and the qualified\n * spellings other projects use (`priority: high`, `priority/high`, `P-high`)\n * are accepted; anything else is simply not a priority. The absence of a label\n * is never an error — most Issues have none.\n */\nexport function priorityOf(labels: readonly string[]): IssuePriority | null {\n  for (const label of labels) {\n    const normalized = label.trim().toLowerCase();\n    const direct = PRIORITY_LABELS[normalized];\n    if (direct !== undefined) return direct;\n\n    const qualified = /^(?:priority|prio|p)\\s*[:/-]\\s*(high|medium|low)$/.exec(normalized);\n    const matched = qualified?.[1];\n    if (matched !== undefined) return PRIORITY_LABELS[matched] as IssuePriority;\n  }\n  return null;\n}\n\nexport interface ExecutionOrderOptions {\n  /**\n   * Subset of the graph to schedule. Defaults to every node — the \"run the\n   * whole hierarchy\" answer; the \"only the ones I asked for\" answer passes the\n   * requested ids.\n   */\n  include?: readonly string[];\n}\n\nexport type ExecutionOrderResult =\n  | { ok: true; order: string[] }\n  | { ok: false; cycles: string[][] };\n\n/** Number of ancestors of `id` inside the selection: 0 for a top-level Issue. */\nfunction hierarchyDepth(\n  id: string,\n  parentOf: Map<string, string | null>,\n  selected: Set<string>,\n): number {\n  let depth = 0;\n  let current = parentOf.get(id) ?? null;\n  const seen = new Set<string>([id]);\n\n  while (current !== null && selected.has(current) && !seen.has(current)) {\n    depth++;\n    seen.add(current);\n    current = parentOf.get(current) ?? null;\n  }\n\n  return depth;\n}\n\n/**\n * Order the selected Issues of a graph.\n *\n * Kahn's algorithm with a deterministic tie-break, so the same graph always\n * produces the same order — a plan the user confirmed must not reshuffle itself\n * on the next run.\n *\n * A cycle is reported, never worked around: an arbitrary order would silently\n * implement an Issue before its dependency, which is exactly the failure this\n * whole feature exists to prevent. Constraints pointing outside the selection\n * are dropped — an Issue that is not going to run cannot block anything.\n */\nexport function computeExecutionOrder(\n  graph: DependencyGraph,\n  options: ExecutionOrderOptions = {},\n): ExecutionOrderResult {\n  const selected = new Set(\n    (options.include ?? [...graph.nodes.keys()]).filter((id) => graph.nodes.has(id)),\n  );\n\n  const parentOf = new Map<string, string | null>();\n  const priority = new Map<string, IssuePriority | null>();\n  for (const id of selected) {\n    const node = graph.nodes.get(id);\n    parentOf.set(id, node?.relations.parent ?? null);\n    priority.set(id, priorityOf(node?.issue?.labels ?? []));\n  }\n\n  const incoming = new Map<string, Set<string>>();\n  const outgoing = new Map<string, string[]>();\n  for (const id of selected) {\n    incoming.set(id, new Set());\n    outgoing.set(id, []);\n  }\n  for (const { from, to } of dependencyEdges(graph)) {\n    if (!selected.has(from) || !selected.has(to) || from === to) continue;\n    incoming.get(to)?.add(from);\n    outgoing.get(from)?.push(to);\n  }\n\n  const depth = new Map<string, number>();\n  for (const id of selected) {\n    depth.set(id, hierarchyDepth(id, parentOf, selected));\n  }\n\n  const rank = (id: string): number => {\n    const value = priority.get(id) ?? null;\n    return value === null ? NO_PRIORITY_RANK : PRIORITY_RANK[value];\n  };\n\n  const better = (a: string, b: string): number => {\n    const byHierarchy = (depth.get(a) ?? 0) - (depth.get(b) ?? 0);\n    if (byHierarchy !== 0) return byHierarchy;\n    const byPriority = rank(a) - rank(b);\n    if (byPriority !== 0) return byPriority;\n    return compareIds(a, b);\n  };\n\n  const ready = [...selected].filter((id) => (incoming.get(id)?.size ?? 0) === 0);\n  const order: string[] = [];\n\n  while (ready.length > 0) {\n    ready.sort(better);\n    const next = ready.shift() as string;\n    order.push(next);\n\n    for (const dependent of outgoing.get(next) ?? []) {\n      const pending = incoming.get(dependent);\n      if (pending === undefined) continue;\n      pending.delete(next);\n      if (pending.size === 0) {\n        ready.push(dependent);\n      }\n    }\n  }\n\n  if (order.length !== selected.size) {\n    // Prefer the cycles the graph already recorded; recompute only if the\n    // selection is what closed the loop.\n    const cycles = graph.cycles.length > 0 ? graph.cycles : findCycles(graph);\n    const relevant = cycles.filter((cycle) => cycle.every((id) => selected.has(id)));\n    return { ok: false, cycles: relevant.length > 0 ? relevant : cycles };\n  }\n\n  return { ok: true, order };\n}\n\n/** One-line description of the cycles, for an error message. */\nexport function describeCycles(cycles: readonly string[][]): string {\n  return cycles.map((cycle) => [...cycle, cycle[0]].map((id) => `#${id}`).join(' → ')).join('; ');\n}\n","import type { PipelineState, TaskPlan } from '../types.js';\nimport { loadTaskPlan, saveTaskPlan } from './state-manager.js';\nimport { DEFAULT_PIPELINE_STATE, WORKFLOW_PHASES } from './workflow-contract.js';\n\n/**\n * Ordered pipeline phases. Each phase must complete before the next can start.\n *\n * `pr-review` is deliberately NOT here: it is opt-in via `--pr-review`. Adding\n * it to the default set would make every existing `tasks.json` (which has no\n * `prReviewCompleted`) look unfinished, so `getNextPhase()` would resume into a\n * phase the user never asked for.\n */\nexport type PipelinePhase = 'init' | (typeof WORKFLOW_PHASES)[number]['phase'];\nexport const PIPELINE_PHASES: readonly PipelinePhase[] = [\n  'init',\n  ...WORKFLOW_PHASES.filter(({ phase }) => phase !== 'pr-review').map(({ phase }) => phase),\n];\n\n/**\n * The default set plus the opt-in `pr-review` phase, used when the user passes\n * `--pr-review` (or the flag was persisted in `plan.prReview.enabled`).\n */\nexport const PIPELINE_PHASES_WITH_PR_REVIEW = [...PIPELINE_PHASES, 'pr-review'] as const;\n\n/**\n * Pipeline phases excluding the 'pr' phase, for --no-branch mode.\n * `pr-review` is excluded too: without a branch there is no PR to review.\n */\nexport const PIPELINE_PHASES_NO_BRANCH = PIPELINE_PHASES.filter(\n  (p): p is Exclude<PipelinePhase, 'pr' | 'pr-review'> => p !== 'pr',\n);\n\n/**\n * Map pipeline phases to their corresponding PipelineState field.\n * 'init' has no persisted state — it's a runtime-only check.\n */\nconst PHASE_TO_FIELD = Object.fromEntries([\n  ['init', null],\n  ...WORKFLOW_PHASES.map(({ phase, field }) => [phase, field]),\n]) as Record<PipelinePhase, keyof PipelineState | null>;\n\nexport class PipelineManager {\n  private tasksJsonPath: string;\n  private plan: TaskPlan;\n  private activePhases: readonly PipelinePhase[];\n\n  constructor(plan: TaskPlan, tasksJsonPath: string, activePhases?: readonly PipelinePhase[]) {\n    this.plan = plan;\n    this.tasksJsonPath = tasksJsonPath;\n    this.activePhases = activePhases ?? PIPELINE_PHASES;\n  }\n\n  /**\n   * Reload state from disk.\n   */\n  async reload(): Promise<void> {\n    this.plan = await loadTaskPlan(this.tasksJsonPath);\n  }\n\n  /**\n   * Check if a phase is complete.\n   */\n  isPhaseComplete(phase: PipelinePhase): boolean {\n    const field = PHASE_TO_FIELD[phase];\n    if (field === null) return true; // init is always \"complete\" after running\n    return this.plan.pipeline?.[field] ?? false;\n  }\n\n  /**\n   * Get the first incomplete phase in the pipeline.\n   * Returns null if all phases are complete.\n   */\n  getNextPhase(): PipelinePhase | null {\n    for (const phase of this.activePhases) {\n      if (!this.isPhaseComplete(phase)) {\n        return phase;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Get the current phase (alias for getNextPhase).\n   */\n  getCurrentPhase(): PipelinePhase | null {\n    return this.getNextPhase();\n  }\n\n  /**\n   * Check whether we can resume from a specific phase.\n   * All prerequisite phases must be complete.\n   */\n  canResume(fromPhase: PipelinePhase): boolean {\n    const idx = this.activePhases.indexOf(fromPhase);\n    if (idx < 0) return false;\n\n    // All active phases before fromPhase must be complete\n    for (let i = 0; i < idx; i++) {\n      if (!this.isPhaseComplete(this.activePhases[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Mark a phase as complete and persist to disk.\n   */\n  async markPhaseComplete(phase: PipelinePhase): Promise<void> {\n    const field = PHASE_TO_FIELD[phase];\n    if (field === null) return; // init has no persisted state\n\n    this.plan = {\n      ...this.plan,\n      pipeline: {\n        ...(this.plan.pipeline ?? DEFAULT_PIPELINE_STATE),\n        [field]: true,\n      },\n    };\n\n    await saveTaskPlan(this.tasksJsonPath, this.plan);\n  }\n}\n"],"mappings":"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","names":["parentOf"]}