issue-flow 0.17.0 → 0.19.1

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-Z5O2XBWA.js → chunk-XQLNZW7I.js}

@@ -1,53 +1,51 @@
 #!/usr/bin/env node
 import {
   listPullRequests
-} from "./chunk-YUNBOUQH.js";
+} from "./chunk-ERAG5IQB.js";
 import {
   publishPhaseMetrics,
   resolvePolicyPlaceholders
-} from "./chunk-HLAPOUEM.js";
+} from "./chunk-WB2FVIUS.js";
 import {
   applyPlaceholders,
   loadPrompt
-} from "./chunk-7F7LGMVO.js";
+} from "./chunk-XKR3VD2Z.js";
 import {
   DEFAULT_HEADLESS_TIMEOUT_MS,
   runHeadless
-} from "./chunk-UK4E2FUA.js";
+} from "./chunk-MQTVMB7W.js";
 import {
   loadPrReviewConfig
-} from "./chunk-HY5HLFDU.js";
-import {
-  resolveIssuePaths
-} from "./chunk-DV7HUC4Z.js";
+} from "./chunk-UHDXXLYH.js";
 import {
   getGlobalTimeout,
   printError,
   printInfo,
   printSuccess,
-  printWarning
-} from "./chunk-XZUEFTUP.js";
-import {
-  getCurrentBranch,
-  run
-} from "./chunk-YVPZUN6X.js";
+  printWarning,
+  resolveIssuePaths
+} from "./chunk-J6VJ5M2U.js";
 import {
   getSessionPublisher
-} from "./chunk-DUS5ZNKL.js";
+} from "./chunk-DIMDAYZS.js";
 import {
   isoNow,
   loadTaskPlan,
   saveTaskPlan
-} from "./chunk-SOM4QA6C.js";
+} from "./chunk-GD7JZMSJ.js";
+import {
+  getCurrentBranch,
+  run
+} from "./chunk-TJVX42KY.js";
 import {
   writeFileAtomic
-} from "./chunk-3R27MJ5R.js";
+} from "./chunk-PFWHHYEO.js";
 
 // src/commands/pr-review.ts
-import { join as join3 } from "path";
+import { join as join3 } from "node:path";
 
 // src/core/pr-review/discovery.ts
-import { createInterface } from "readline";
+import { createInterface } from "node:readline";
 var PrDiscoveryError = class extends Error {
   exitCode;
   constructor(message, exitCode = 1) {
@@ -270,12 +268,12 @@ async function discover(sources, issue, warn) {
 }
 
 // src/core/pr-review/publisher.ts
-import { mkdir } from "fs/promises";
-import { join as join2 } from "path";
+import { mkdir } from "node:fs/promises";
+import { join as join2 } from "node:path";
 
 // src/core/pr-review/report.ts
-import { readdir, readFile } from "fs/promises";
-import { join } from "path";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
 var RECOMMENDATIONS = {
   APPROVE: "APPROVE",
   APPROVE_WITH_SUGGESTIONS: "APPROVE_WITH_SUGGESTIONS",
@@ -631,7 +629,7 @@ async function fetchPullRequestMetadata(number) {
       "view",
       String(number),
       "--json",
-      "title,url,headRefName,headRefOid"
+      "title,url,headRefName,headRefOid,baseRefOid"
     ]);
     if (result.exitCode !== 0) {
       return null;
@@ -701,11 +699,20 @@ async function runPrReview(prArg, opts = {}) {
   const dir = await prReviewDir({ issue, pullRequest: target.number });
   const round = await resolveRound(dir, target.number, explicitRound);
   const reportPath = join3(dir, reportFileName(target.number, round));
+  const meta = await fetchPullRequestMetadata(target.number);
+  const previous = (await readPrReviewIndex(dir))?.rounds.filter((entry) => entry.round < round).sort((a, b) => b.round - a.round)[0];
   const template = await loadPrompt("pr-review");
   const prompt = applyPlaceholders(template, {
     // The repository's own conventions. Empty when it declares none, which is
     // what keeps the rendered prompt identical to the pre-policy one.
-    ...await resolvePolicyPlaceholders(),
+    ...await resolvePolicyPlaceholders({ phase: "pr-review" }),
+    __PR_HEAD__: meta?.headRefOid ?? "unavailable",
+    __PR_BASE__: meta?.baseRefOid ?? "unavailable",
+    __PREVIOUS_REVIEW__: previous ? JSON.stringify({
+      headSha: previous.headSha,
+      reportPath: join3(dir, reportFileName(target.number, previous.round))
+    }) : "",
+    __ISSUE_CONTEXT__: issue === void 0 ? "" : "enabled",
     __PR_NUMBER__: String(target.number),
     __ISSUE_NUMBER__: issue ?? NO_ISSUE,
     __TASKS_PATH__: tasksPath ?? NO_PATH,
@@ -735,9 +742,10 @@ async function runPrReview(prArg, opts = {}) {
     return 1;
   }
   const parsed = parsePrReviewResult(result.result);
-  const recommendation = parsed.ok ? parsed.result.recommendation : null;
+  const latest = await fetchPullRequestMetadata(target.number);
+  const revisionError = !meta?.headRefOid || !meta.baseRefOid || !latest?.headRefOid || !latest.baseRefOid ? "PR revision could not be verified before and after review." : meta.headRefOid !== latest.headRefOid || meta.baseRefOid !== latest.baseRefOid ? "PR head or base changed during review; this report describes the earlier revision." : null;
+  const recommendation = parsed.ok && revisionError === null ? parsed.result.recommendation : null;
   const blockers = parsed.ok ? parsed.result.blockers : [];
-  const meta = await fetchPullRequestMetadata(target.number);
   const pullRequest = mergePullRequest(target, meta);
   const at = isoNow();
   const headSha = meta?.headRefOid ?? null;
@@ -756,7 +764,7 @@ async function runPrReview(prArg, opts = {}) {
       headSha,
       recommendation,
       body: result.result,
-      parseError: parsed.ok ? null : parsed.error
+      parseError: revisionError ?? (parsed.ok ? null : parsed.error)
     })
   };
   const publisher = opts.publisher ?? createPrReviewPublisher(dir, (await loadPrReviewConfig()).publisher);
@@ -779,7 +787,9 @@ async function runPrReview(prArg, opts = {}) {
   }
   printInfo(`Report: ${reportPath}`);
   if (!parsed.ok || recommendation === null) {
-    printError(`PR review could not be parsed: ${parsed.ok ? "no recommendation" : parsed.error}`);
+    printError(
+      revisionError ?? `PR review could not be parsed: ${parsed.ok ? "no recommendation" : parsed.error}`
+    );
     return 1;
   }
   if (recommendation === "REQUEST_CHANGES") {
@@ -802,4 +812,4 @@ export {
   exitCodeFor,
   runPrReview
 };
-//# sourceMappingURL=chunk-Z5O2XBWA.js.map
+//# sourceMappingURL=chunk-XQLNZW7I.js.map

package/dist/chunk-XQLNZW7I.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/pr-review.ts","../src/core/pr-review/discovery.ts","../src/core/pr-review/publisher.ts","../src/core/pr-review/report.ts"],"sourcesContent":["import { join } from 'node:path';\nimport { loadPrReviewConfig } from '../config.js';\nimport { DEFAULT_HEADLESS_TIMEOUT_MS, runHeadless } from '../core/headless.js';\nimport {\n  PrDiscoveryError,\n  type ResolvedPullRequest,\n  resolvePullRequest,\n} from '../core/pr-review/discovery.js';\nimport { createPrReviewPublisher, type PrReviewPublisher } from '../core/pr-review/publisher.js';\nimport {\n  buildReportMarkdown,\n  type PrReviewPullRequest,\n  parseFindings,\n  parsePrReviewResult,\n  prReviewDir,\n  readPrReviewIndex,\n  reportFileName,\n  resolveRound,\n} from '../core/pr-review/report.js';\nimport { applyPlaceholders, loadPrompt } from '../core/prompt-resolver.js';\nimport { publishPhaseMetrics } from '../core/session-metrics.js';\nimport { isoNow, loadTaskPlan, saveTaskPlan } from '../core/state-manager.js';\nimport { getGlobalTimeout } from '../core/verbose.js';\nimport { resolvePolicyPlaceholders } from '../policy/placeholders.js';\nimport { resolveIssuePaths } from '../storage/resolve.js';\nimport type { PrReviewRecommendation } from '../types.js';\nimport { printError, printInfo, printSuccess } from '../ui/logger.js';\nimport { run } from '../utils/shell.js';\n\n/**\n * The `pr-review` phase: review a Pull Request as a whole.\n *\n * It follows the five steps of `review.ts` — resolve the target, build the\n * prompt, run headless, parse deterministically, persist state — with two\n * differences that come from reviewing a Pull Request instead of an Issue: the\n * target has to be discovered (`core/pr-review/discovery.ts`) and the outcome\n * is an artifact on disk, written through a `PrReviewPublisher`.\n *\n * The phase is intended to be read-only: Write/Edit are not allowed, and the\n * prompt forbids commits and `gh pr review|comment|merge`. Bash remains\n * available for `gh`/`git` inspection, so the restriction is policy plus tool\n * allow-list — not a sandbox that can stop every write.\n */\n\n/** Which verdicts make the command fail. */\nexport type PrReviewFailOn = 'request-changes' | 'suggestions' | 'none';\n\nconst FAIL_ON_LEVELS: PrReviewFailOn[] = ['request-changes', 'suggestions', 'none'];\nconst DEFAULT_FAIL_ON: PrReviewFailOn = 'request-changes';\n\n/** Placeholder value for context the run does not have. */\nconst NO_ISSUE = 'none';\nconst NO_PATH = '(none)';\n\nexport interface PrReviewOptions {\n  /** Issue the Pull Request belongs to; enables plan lookup and state writes. */\n  issue?: string;\n  /** `--round <n>`: rewrite one specific round instead of appending a new one. */\n  round?: string | number;\n  /** Skip the discovery confirmation (`--yes`, and every call from `run`). */\n  yes?: boolean;\n  failOn?: string;\n  /** Injection point for tests and for future publishers (GitHub). */\n  publisher?: PrReviewPublisher;\n}\n\n/**\n * Exit code for a parsed verdict. `1` is reserved for execution failures, so a\n * review that ran to completion answers only `0` or `2`.\n */\nexport function exitCodeFor(\n  recommendation: PrReviewRecommendation,\n  failOn: PrReviewFailOn,\n): number {\n  if (failOn === 'none') {\n    return 0;\n  }\n  if (recommendation === 'REQUEST_CHANGES') {\n    return 2;\n  }\n  return failOn === 'suggestions' && recommendation === 'APPROVE_WITH_SUGGESTIONS' ? 2 : 0;\n}\n\nfunction parseFailOn(value: string | undefined): PrReviewFailOn | null {\n  if (value === undefined || value === '') {\n    return DEFAULT_FAIL_ON;\n  }\n  const normalized = value.trim().toLowerCase();\n  return FAIL_ON_LEVELS.find((level) => level === normalized) ?? null;\n}\n\n/** Metadata `gh` knows and the discovery may not — title, URL, head revision. */\ninterface GhPullRequest {\n  title?: string;\n  url?: string;\n  headRefName?: string;\n  headRefOid?: string;\n  baseRefOid?: string;\n}\n\n/**\n * Collect revision metadata without throwing. Missing revisions leave the\n * report available for inspection but cannot produce a verified recommendation.\n */\nasync function fetchPullRequestMetadata(number: number): Promise<GhPullRequest | null> {\n  try {\n    const result = await run('gh', [\n      'pr',\n      'view',\n      String(number),\n      '--json',\n      'title,url,headRefName,headRefOid,baseRefOid',\n    ]);\n    if (result.exitCode !== 0) {\n      return null;\n    }\n    const parsed: unknown = JSON.parse(result.stdout);\n    return typeof parsed === 'object' && parsed !== null ? (parsed as GhPullRequest) : null;\n  } catch {\n    return null;\n  }\n}\n\nfunction mergePullRequest(\n  target: ResolvedPullRequest,\n  meta: GhPullRequest | null,\n): PrReviewPullRequest {\n  return {\n    number: target.number,\n    url: target.url ?? meta?.url ?? null,\n    title: target.title ?? meta?.title ?? null,\n    headBranch: target.headBranch ?? meta?.headRefName ?? null,\n  };\n}\n\ninterface PersistInput {\n  tasksPath: string;\n  pullRequestNumber: number;\n  round: number;\n  /** null when the verdict could not be parsed. */\n  recommendation: PrReviewRecommendation | null;\n  at: string;\n}\n\n/**\n * Record the round on the plan. Only `prReviewCompleted` and `prReview` are\n * touched: the other phases own the rest of `pipeline`.\n *\n * Best-effort like `review.ts`: reviewing a Pull Request with no associated\n * Issue (or whose plan is gone) is a supported use of the command, not a\n * failure — the report on disk is the deliverable either way.\n */\nasync function persistState(input: PersistInput): Promise<void> {\n  try {\n    const plan = await loadTaskPlan(input.tasksPath);\n    plan.pipeline.prReviewCompleted =\n      input.recommendation === 'APPROVE' || input.recommendation === 'APPROVE_WITH_SUGGESTIONS';\n    plan.prReview = {\n      // Preserved, never turned on here: opting the pipeline in is `run\n      // --pr-review`'s decision, not a side effect of a manual review.\n      enabled: plan.prReview?.enabled ?? false,\n      pullRequestNumber: input.pullRequestNumber,\n      // `--round <n>` rewrites an earlier round, which must not shrink the count.\n      rounds: Math.max(plan.prReview?.rounds ?? 0, input.round),\n      lastRecommendation: input.recommendation ?? plan.prReview?.lastRecommendation,\n      lastReviewedAt: input.at,\n    };\n    await saveTaskPlan(input.tasksPath, plan);\n  } catch {\n    // tasks.json may not exist.\n  }\n}\n\nexport async function runPrReview(prArg?: string, opts: PrReviewOptions = {}): Promise<number> {\n  const failOn = parseFailOn(opts.failOn);\n  if (failOn === null) {\n    printError(`Invalid --fail-on value '${opts.failOn}'. Expected ${FAIL_ON_LEVELS.join(', ')}.`);\n    return 1;\n  }\n\n  const explicitRound = opts.round === undefined ? undefined : Number(opts.round);\n  if (explicitRound !== undefined && (!Number.isInteger(explicitRound) || explicitRound < 1)) {\n    printError(`Invalid --round value '${opts.round}'. Expected a positive integer.`);\n    return 1;\n  }\n\n  const issueRef = opts.issue?.replace(/^#/, '').trim();\n  const issue = issueRef === undefined || issueRef === '' ? undefined : issueRef;\n\n  let target: ResolvedPullRequest;\n  try {\n    target = await resolvePullRequest(prArg, { issue, yes: opts.yes });\n  } catch (err) {\n    if (err instanceof PrDiscoveryError) {\n      printError(err.message);\n      return err.exitCode;\n    }\n    printError(\n      `Could not determine which Pull Request to review: ${err instanceof Error ? err.message : String(err)}`,\n    );\n    return 1;\n  }\n\n  // With no Issue there is nothing to resolve: the placeholders take NO_PATH\n  // and the report lands under the synthetic `pr-<N>` slug resolved below.\n  const issuePaths = issue === undefined ? null : await resolveIssuePaths(issue);\n  const issueDir = issuePaths?.issueDir ?? null;\n  const tasksPath = issuePaths?.tasksFile ?? null;\n  const prdPath = issuePaths?.prdFile ?? null;\n\n  const dir = await prReviewDir({ issue, pullRequest: target.number });\n  const round = await resolveRound(dir, target.number, explicitRound);\n  const reportPath = join(dir, reportFileName(target.number, round));\n\n  const meta = await fetchPullRequestMetadata(target.number);\n  const previous = (await readPrReviewIndex(dir))?.rounds\n    .filter((entry) => entry.round < round)\n    .sort((a, b) => b.round - a.round)[0];\n  const template = await loadPrompt('pr-review');\n  const prompt = applyPlaceholders(template, {\n    // The repository's own conventions. Empty when it declares none, which is\n    // what keeps the rendered prompt identical to the pre-policy one.\n    ...(await resolvePolicyPlaceholders({ phase: 'pr-review' })),\n    __PR_HEAD__: meta?.headRefOid ?? 'unavailable',\n    __PR_BASE__: meta?.baseRefOid ?? 'unavailable',\n    __PREVIOUS_REVIEW__: previous\n      ? JSON.stringify({\n          headSha: previous.headSha,\n          reportPath: join(dir, reportFileName(target.number, previous.round)),\n        })\n      : '',\n    __ISSUE_CONTEXT__: issue === undefined ? '' : 'enabled',\n    __PR_NUMBER__: String(target.number),\n    __ISSUE_NUMBER__: issue ?? NO_ISSUE,\n    __TASKS_PATH__: tasksPath ?? NO_PATH,\n    __PRD_PATH__: prdPath ?? NO_PATH,\n    __REPORT_PATH__: reportPath,\n    __ROUND__: String(round),\n  });\n\n  const startedAtMs = Date.now();\n  const result = await runHeadless({\n    prompt,\n    maxTurns: 40,\n    timeout: getGlobalTimeout() ?? DEFAULT_HEADLESS_TIMEOUT_MS,\n    // json (not text) so the CLI reports usage: the envelope's `result` field\n    // carries the same assistant text the parsers below already consumed.\n    outputFormat: 'json',\n    allowedTools: ['Bash', 'Read', 'Glob', 'Grep'],\n    // With an Issue, `dir` sits under `issueDir`, so the parent covers both the\n    // report destination and the tasks.json/prd.md the prompt points at.\n    addDirs: issueDir === null ? [dir] : [issueDir],\n    statusMessage: `Reviewing Pull Request #${target.number} (round ${round})...`,\n    phase: 'pr-review',\n    permission: 'read-only',\n  });\n  // Before the success check: the tokens were spent either way.\n  publishPhaseMetrics('pr-review', result.cost, startedAtMs, result.agent?.provider);\n\n  if (!result.success) {\n    printError(`PR review failed: ${result.error}`);\n    return 1;\n  }\n\n  const parsed = parsePrReviewResult(result.result);\n  const latest = await fetchPullRequestMetadata(target.number);\n  const revisionError =\n    !meta?.headRefOid || !meta.baseRefOid || !latest?.headRefOid || !latest.baseRefOid\n      ? 'PR revision could not be verified before and after review.'\n      : meta.headRefOid !== latest.headRefOid || meta.baseRefOid !== latest.baseRefOid\n        ? 'PR head or base changed during review; this report describes the earlier revision.'\n        : null;\n  const recommendation = parsed.ok && revisionError === null ? parsed.result.recommendation : null;\n  const blockers = parsed.ok ? parsed.result.blockers : [];\n\n  const pullRequest = mergePullRequest(target, meta);\n  const at = isoNow();\n  const headSha = meta?.headRefOid ?? null;\n\n  const report = {\n    pullRequest,\n    round,\n    at,\n    headSha,\n    recommendation,\n    blockers,\n    findings: parseFindings(result.result),\n    markdown: buildReportMarkdown({\n      pullRequest,\n      round,\n      at,\n      headSha,\n      recommendation,\n      body: result.result,\n      parseError: revisionError ?? (parsed.ok ? null : parsed.error),\n    }),\n  };\n\n  // Which publisher runs is configuration (`prReview.publisher`), never a code\n  // path here: the command only ever holds the interface.\n  const publisher =\n    opts.publisher ?? createPrReviewPublisher(dir, (await loadPrReviewConfig()).publisher);\n  try {\n    await publisher.publish(report);\n  } catch (err) {\n    printError(\n      `Could not publish the review report: ${err instanceof Error ? err.message : String(err)}`,\n    );\n    return 1;\n  }\n\n  if (tasksPath !== null) {\n    await persistState({\n      tasksPath,\n      pullRequestNumber: target.number,\n      round,\n      recommendation,\n      at,\n    });\n  }\n\n  printInfo(`Report: ${reportPath}`);\n\n  // A verdict that could not be read is an execution failure, never an\n  // approval — the raw output is in the report for whoever has to look.\n  if (!parsed.ok || recommendation === null) {\n    printError(\n      revisionError ??\n        `PR review could not be parsed: ${parsed.ok ? 'no recommendation' : parsed.error}`,\n    );\n    return 1;\n  }\n\n  if (recommendation === 'REQUEST_CHANGES') {\n    printError(`PR review #${target.number}: REQUEST_CHANGES`);\n    for (const blocker of blockers) {\n      console.log(`  - ${blocker}`);\n    }\n    return exitCodeFor(recommendation, failOn);\n  }\n\n  printSuccess(\n    recommendation === 'APPROVE'\n      ? `PR review #${target.number}: APPROVE`\n      : `PR review #${target.number}: APPROVE_WITH_SUGGESTIONS — no blockers, improvements suggested`,\n  );\n  return exitCodeFor(recommendation, failOn);\n}\n","import { createInterface } from 'node:readline';\nimport { resolveIssuePaths } from '../../storage/resolve.js';\nimport type { PullRequestRef } from '../../types.js';\nimport { printInfo, printWarning } from '../../ui/logger.js';\nimport { getCurrentBranch } from '../../utils/git.js';\nimport { listPullRequests } from '../session-git.js';\nimport { getSessionPublisher } from '../session-publisher.js';\nimport type { SessionPullRequest } from '../session-state.js';\nimport { loadTaskPlan } from '../state-manager.js';\n\n/**\n * Which Pull Request the `pr-review` phase should look at.\n *\n * The order is deterministic and the search never falls back to \"some PR of\n * this repository\": a review pointed at an unrelated Pull Request is worse\n * than no review at all, so an exhausted search is an actionable error.\n */\n\n/** Origin of the resolved Pull Request, in precedence order. */\nexport type PullRequestSource = 'argument' | 'session' | 'plan' | 'branch';\n\nexport interface ResolvedPullRequest {\n  number: number;\n  /** Only known when the origin carried it; never synthesized. */\n  url: string | null;\n  title: string | null;\n  headBranch: string | null;\n  source: PullRequestSource;\n}\n\n/**\n * Failure to settle on a Pull Request. Carries the exit code the CLI should\n * return, mirroring IssueResolutionError (`issues/resolver.ts`).\n */\nexport class PrDiscoveryError extends Error {\n  readonly exitCode: number;\n\n  constructor(message: string, exitCode = 1) {\n    super(message);\n    this.name = 'PrDiscoveryError';\n    this.exitCode = exitCode;\n  }\n}\n\n/** Data sources, injectable for tests — the pattern of `GitStateSources`. */\nexport interface PrDiscoverySources {\n  /** PRs already known to the active session publisher (`--web` runs). */\n  sessionPullRequests(): SessionPullRequest[];\n  /** `plan.pullRequest` persisted by the `pr` phase, or null. */\n  planPullRequest(issue: string): Promise<PullRequestRef | null>;\n  currentBranch(): Promise<string>;\n  branchPullRequests(branch: string): Promise<SessionPullRequest[]>;\n}\n\nexport interface ResolvePullRequestOptions {\n  /** Issue the pipeline is working on; enables the `plan` source. */\n  issue?: string;\n  /** `--yes`, or any non-interactive caller (`run`): skip the confirmation. */\n  yes?: boolean;\n  /**\n   * Whether a prompt may be shown. Defaults to a real TTY on both ends outside\n   * CI, which is what keeps the confirmation from blocking a headless run.\n   */\n  interactive?: boolean;\n  /** Input stream for the confirmation. Defaults to process.stdin. */\n  stdin?: NodeJS.ReadableStream;\n  /** Output stream for the confirmation. Defaults to process.stdout. */\n  stdout?: NodeJS.WritableStream;\n  /** Informational sink. Defaults to printInfo. */\n  info?: (message: string) => void;\n  /** Warning sink. Defaults to printWarning. */\n  warn?: (message: string) => void;\n  sources?: Partial<PrDiscoverySources>;\n}\n\n/** How many invalid answers are tolerated before the prompt gives up. */\nconst MAX_PROMPT_ATTEMPTS = 3;\n\nconst SOURCE_LABELS: Record<PullRequestSource, string> = {\n  argument: 'the command argument',\n  session: 'the current session',\n  plan: 'tasks.json',\n  branch: 'the current branch',\n};\n\n/**\n * `plan.pullRequest` of the issue's global tasks.json. Best-effort: a missing\n * plan, an invalid one or a plan written before the `pr` phase ran is simply\n * \"no candidate\", never a failure — the next source still gets its turn.\n */\nasync function loadPlanPullRequest(issue: string): Promise<PullRequestRef | null> {\n  try {\n    const plan = await loadTaskPlan((await resolveIssuePaths(issue)).tasksFile);\n    return plan.pullRequest ?? null;\n  } catch {\n    return null;\n  }\n}\n\nconst defaultSources: PrDiscoverySources = {\n  sessionPullRequests: () => getSessionPublisher().snapshot().pullRequests,\n  planPullRequest: loadPlanPullRequest,\n  currentBranch: getCurrentBranch,\n  branchPullRequests: listPullRequests,\n};\n\n/**\n * The most recent of several Pull Requests: the highest number, which does not\n * depend on the order the source returned them.\n */\nexport function mostRecent(pullRequests: SessionPullRequest[]): SessionPullRequest | null {\n  let latest: SessionPullRequest | null = null;\n  for (const pr of pullRequests) {\n    if (latest === null || pr.number > latest.number) {\n      latest = pr;\n    }\n  }\n  return latest;\n}\n\n/**\n * The PR number inside an explicit argument: `184`, `#184` or a GitHub URL.\n * Returns null for anything else, so a typo fails loudly instead of being\n * coerced into a number that addresses an unrelated Pull Request.\n */\nfunction parsePrArgument(arg: string): number | null {\n  const trimmed = arg.trim();\n  const fromUrl = trimmed.match(/\\/pull\\/(\\d+)/);\n  if (fromUrl?.[1] !== undefined) {\n    return Number(fromUrl[1]);\n  }\n  const plain = trimmed.match(/^#?(\\d+)$/);\n  return plain?.[1] === undefined ? null : Number(plain[1]);\n}\n\nfunction isInteractiveByDefault(): boolean {\n  const ci = process.env.CI;\n  const inCi = ci !== undefined && ci !== '' && ci !== '0' && ci.toLowerCase() !== 'false';\n  return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && !inCi;\n}\n\n/** Human-readable one-liner for logs and the confirmation prompt. */\nfunction describe(pr: ResolvedPullRequest): string {\n  const parts = [`#${pr.number}`];\n  if (pr.title !== null) parts.push(`\"${pr.title}\"`);\n  if (pr.headBranch !== null) parts.push(`(${pr.headBranch})`);\n  return parts.join(' ');\n}\n\n/**\n * Ask for confirmation, defaulting to yes on an empty answer.\n *\n * Lines are queued rather than read on demand for the same reason as\n * `issues/resolver.ts`: `rl.question` drops input that arrives before the\n * prompt is written, which silently loses a piped answer. EOF answers null,\n * which the caller treats as a refusal — never as consent.\n */\nasync function confirm(\n  query: string,\n  stdin: NodeJS.ReadableStream,\n  stdout: NodeJS.WritableStream,\n  warn: (message: string) => void,\n): Promise<boolean> {\n  const rl = createInterface({ input: stdin, output: stdout });\n  const queued: string[] = [];\n  let pending: ((line: string | null) => void) | null = null;\n  let closed = false;\n\n  rl.on('line', (line: string) => {\n    if (pending !== null) {\n      const resolve = pending;\n      pending = null;\n      resolve(line);\n      return;\n    }\n    queued.push(line);\n  });\n  rl.on('close', () => {\n    closed = true;\n    if (pending !== null) {\n      const resolve = pending;\n      pending = null;\n      resolve(null);\n    }\n  });\n\n  const ask = (): Promise<string | null> =>\n    new Promise<string | null>((resolve) => {\n      const buffered = queued.shift();\n      if (buffered !== undefined) {\n        resolve(buffered);\n        return;\n      }\n      if (closed) {\n        resolve(null);\n        return;\n      }\n      stdout.write(query);\n      pending = resolve;\n    });\n\n  try {\n    for (let attempt = 0; attempt < MAX_PROMPT_ATTEMPTS; attempt++) {\n      const answer = await ask();\n      if (answer === null) {\n        return false;\n      }\n      const normalized = answer.trim().toLowerCase();\n      if (normalized === '' || normalized === 'y' || normalized === 'yes') {\n        return true;\n      }\n      if (normalized === 'n' || normalized === 'no') {\n        return false;\n      }\n      warn(`Invalid answer: '${answer.trim()}'. Enter y or n.`);\n    }\n    return false;\n  } finally {\n    rl.close();\n  }\n}\n\n/**\n * Settle on the Pull Request to review, in this order:\n *\n * 1. the explicit argument;\n * 2. `plan.pullRequest`, written by the `pr` phase (when an issue is known);\n * 3. the PRs the active in-memory session publisher already knows about\n *    (populated during `run --web` via `publishGitState` — not by reading\n *    `session.json` from disk);\n * 4. the PRs of the current branch, via `gh`;\n * 5. an actionable failure.\n *\n * The plan is preferred over the session: after `pr`, `plan.pullRequest` is the\n * authoritative record of what this pipeline opened, while the session may\n * still list older PRs for the same branch (`gh pr list --state all`).\n *\n * Sources 2–4 were discovered rather than requested, so an interactive\n * terminal is asked to confirm before a long (and paid) review runs against\n * the wrong Pull Request. Anywhere else — `--yes`, CI, a pipe or the `run`\n * command — the discovery is only logged.\n */\nexport async function resolvePullRequest(\n  prArg?: string,\n  opts: ResolvePullRequestOptions = {},\n): Promise<ResolvedPullRequest> {\n  const info = opts.info ?? printInfo;\n  const warn = opts.warn ?? printWarning;\n  const sources: PrDiscoverySources = { ...defaultSources, ...opts.sources };\n\n  if (prArg !== undefined && prArg.trim() !== '') {\n    const number = parsePrArgument(prArg);\n    if (number === null) {\n      throw new PrDiscoveryError(\n        `Invalid Pull Request reference '${prArg.trim()}'. ` +\n          'Use a number (e.g. 184) or a GitHub Pull Request URL.',\n      );\n    }\n    const url = prArg.trim().includes('/pull/') ? prArg.trim() : null;\n    return { number, url, title: null, headBranch: null, source: 'argument' };\n  }\n\n  const discovered = await discover(sources, opts.issue, warn);\n  if (discovered === null) {\n    throw new PrDiscoveryError(\n      'No Pull Request found for this branch, in tasks.json or in the current session. ' +\n        'Run `issue-flow pr-review <number>` with the Pull Request number.',\n    );\n  }\n\n  const interactive = opts.yes === true ? false : (opts.interactive ?? isInteractiveByDefault());\n  if (!interactive) {\n    info(\n      `Reviewing Pull Request ${describe(discovered)}, found in ${SOURCE_LABELS[discovered.source]}.`,\n    );\n    return discovered;\n  }\n\n  info(`Pull Request found in ${SOURCE_LABELS[discovered.source]}:`);\n  info(`  number: #${discovered.number}`);\n  info(`  title:  ${discovered.title ?? '(unknown)'}`);\n  info(`  branch: ${discovered.headBranch ?? '(unknown)'}`);\n\n  const accepted = await confirm(\n    `Review Pull Request #${discovered.number}? (Y/n): `,\n    opts.stdin ?? process.stdin,\n    opts.stdout ?? process.stdout,\n    warn,\n  );\n  if (!accepted) {\n    throw new PrDiscoveryError(\n      `Cancelled: Pull Request #${discovered.number} was not confirmed. ` +\n        'Run `issue-flow pr-review <number>` to review a specific Pull Request.',\n    );\n  }\n  return discovered;\n}\n\n/**\n * Sources 2–4, in order, stopping at the first hit. Every source is allowed to\n * fail on its own: a broken `gh` or an unreadable plan must not mask a\n * candidate another source could still provide.\n */\nasync function discover(\n  sources: PrDiscoverySources,\n  issue: string | undefined,\n  warn: (message: string) => void,\n): Promise<ResolvedPullRequest | null> {\n  if (issue !== undefined && issue !== '') {\n    try {\n      const fromPlan = await sources.planPullRequest(issue);\n      if (fromPlan !== null) {\n        return {\n          number: fromPlan.number,\n          url: fromPlan.url,\n          title: null,\n          headBranch: fromPlan.headBranch,\n          source: 'plan',\n        };\n      }\n    } catch {\n      // An unreadable plan is \"no candidate\", never a hard failure.\n    }\n  }\n\n  let sessionPrs: SessionPullRequest[] = [];\n  try {\n    sessionPrs = sources.sessionPullRequests();\n  } catch {\n    // The monitoring snapshot is an optimization, never a requirement.\n  }\n  const fromSession = mostRecent(sessionPrs);\n  if (fromSession !== null) {\n    return {\n      number: fromSession.number,\n      url: fromSession.url,\n      title: fromSession.title,\n      headBranch: null,\n      source: 'session',\n    };\n  }\n\n  let branch = '';\n  try {\n    branch = await sources.currentBranch();\n  } catch (err) {\n    warn(\n      `Could not detect the current branch: ${err instanceof Error ? err.message : String(err)}`,\n    );\n  }\n  if (branch === '') {\n    return null;\n  }\n\n  let branchPrs: SessionPullRequest[] = [];\n  try {\n    branchPrs = await sources.branchPullRequests(branch);\n  } catch (err) {\n    warn(\n      `Could not list Pull Requests for branch '${branch}': ${err instanceof Error ? err.message : String(err)}`,\n    );\n    return null;\n  }\n  const fromBranch = mostRecent(branchPrs);\n  if (fromBranch === null) {\n    return null;\n  }\n  return {\n    number: fromBranch.number,\n    url: fromBranch.url,\n    title: fromBranch.title,\n    headBranch: branch,\n    source: 'branch',\n  };\n}\n","import { mkdir } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport type { PrReviewRecommendation } from '../../types.js';\nimport { writeFileAtomic } from '../../utils/fs.js';\nimport { run } from '../../utils/shell.js';\nimport {\n  type PrReviewFinding,\n  type PrReviewIndex,\n  type PrReviewPullRequest,\n  readPrReviewIndex,\n  reportFileName,\n  upsertRound,\n} from './report.js';\n\n/**\n * Where the outcome of a review round goes.\n *\n * The phase itself only knows this interface, so pointing the results at\n * GitHub later (a review comment, a check run) is a new implementation and a\n * configuration change — not a change to the phase.\n */\n\n/** One finished review round, ready to be published. */\nexport interface PrReviewReport {\n  pullRequest: PrReviewPullRequest;\n  round: number;\n  at: string;\n  headSha: string | null;\n  /** null when the agent output could not be parsed. */\n  recommendation: PrReviewRecommendation | null;\n  blockers: string[];\n  findings: PrReviewFinding[];\n  /** The full Markdown report, already assembled by `buildReportMarkdown()`. */\n  markdown: string;\n}\n\nexport interface PrReviewPublisher {\n  publish(report: PrReviewReport): Promise<void>;\n}\n\n/**\n * Writes `pr-<N>-round-<k>.md` plus `index.json` under the artifact directory.\n *\n * Rounds are additive: an existing index is loaded and merged instead of being\n * replaced, so round N+1 never erases the trail of the rounds before it. Both\n * files go through `writeFileAtomic()`, the mechanism `saveTaskPlan()` uses —\n * an interrupted write leaves the previous artifacts intact rather than a\n * truncated report.\n *\n * This publisher never writes to GitHub.\n */\nexport class LocalReportPublisher implements PrReviewPublisher {\n  constructor(private readonly dir: string) {}\n\n  async publish(report: PrReviewReport): Promise<void> {\n    await mkdir(this.dir, { recursive: true });\n\n    const fileName = reportFileName(report.pullRequest.number, report.round);\n    await writeFileAtomic(join(this.dir, fileName), report.markdown);\n\n    const existing = await readPrReviewIndex(this.dir);\n    const index: PrReviewIndex = {\n      schemaVersion: 1,\n      pullRequest: report.pullRequest,\n      rounds: existing?.rounds ?? [],\n    };\n\n    const updated = upsertRound(index, {\n      round: report.round,\n      at: report.at,\n      recommendation: report.recommendation,\n      headSha: report.headSha,\n      reportPath: fileName,\n      findings: report.findings,\n    });\n\n    await writeFileAtomic(join(this.dir, 'index.json'), `${JSON.stringify(updated, null, 2)}\\n`);\n  }\n}\n\n/**\n * The marker that makes a published review addressable.\n *\n * A review round is *republished* more often than it is first published — a\n * retry of the phase, a re-run after a correction cycle, a resume — and without\n * a way to recognise its own previous comment every one of those leaves another\n * copy on the Pull Request. The marker is per round on purpose: round 2 is a\n * different statement from round 1 and gets its own comment, while a second\n * publication of round 1 updates the one that is there.\n *\n * It is an HTML comment, so it is invisible in the rendered body and survives\n * GitHub's Markdown untouched.\n */\nexport function reviewCommentMarker(round: number): string {\n  return `<!-- issue-flow:review:${round} -->`;\n}\n\ninterface GitHubComment {\n  id: number;\n  body: string;\n}\n\nfunction parseComments(stdout: string): GitHubComment[] {\n  try {\n    const parsed: unknown = JSON.parse(stdout || '[]');\n    if (!Array.isArray(parsed)) return [];\n    return parsed.filter(\n      (entry): entry is GitHubComment =>\n        typeof entry === 'object' &&\n        entry !== null &&\n        typeof (entry as { id?: unknown }).id === 'number' &&\n        typeof (entry as { body?: unknown }).body === 'string',\n    );\n  } catch {\n    return [];\n  }\n}\n\n/**\n * Publishes the report as a comment on the Pull Request, **updating** the\n * comment of the same round instead of adding a second one.\n *\n * The sequence is: read the existing comments, look for this round's marker,\n * and either `PATCH` that comment or post a new one. A `gh` that cannot answer\n * the first question falls through to posting — the failure mode of a\n * duplicated comment is better than the failure mode of a review nobody sees —\n * and nothing here throws: a Pull Request comment is a report, and a report\n * that fails to publish must not fail the phase.\n */\nexport class GitHubCommentPublisher implements PrReviewPublisher {\n  async publish(report: PrReviewReport): Promise<void> {\n    const marker = reviewCommentMarker(report.round);\n    const body = `${marker}\\n${report.markdown}`;\n    const pr = report.pullRequest.number;\n\n    const listed = await run('gh', [\n      'api',\n      `repos/{owner}/{repo}/issues/${pr}/comments`,\n      '--paginate',\n    ]);\n\n    const existing =\n      listed.exitCode === 0\n        ? parseComments(listed.stdout).find((comment) => comment.body.includes(marker))\n        : undefined;\n\n    if (existing !== undefined) {\n      await run('gh', [\n        'api',\n        '--method',\n        'PATCH',\n        `repos/{owner}/{repo}/issues/comments/${existing.id}`,\n        '-f',\n        `body=${body}`,\n      ]);\n      return;\n    }\n\n    await run('gh', ['pr', 'comment', String(pr), '--body', body]);\n  }\n}\n\n/** Runs several publishers over one report, in order. */\nexport class CompositePrReviewPublisher implements PrReviewPublisher {\n  constructor(private readonly members: readonly PrReviewPublisher[]) {}\n\n  async publish(report: PrReviewReport): Promise<void> {\n    for (const member of this.members) {\n      await member.publish(report);\n    }\n  }\n}\n\n/**\n * Publishers selectable by configuration.\n *\n * `github` composes rather than replaces: the local artifacts are what the\n * correction cycle and `resume` read, and a Pull Request comment is an\n * additional audience, never a substitute for them.\n */\nexport type PrReviewPublisherKind = 'local' | 'github';\n\nconst PUBLISHERS: Record<PrReviewPublisherKind, (dir: string) => PrReviewPublisher> = {\n  local: (dir) => new LocalReportPublisher(dir),\n  github: (dir) =>\n    new CompositePrReviewPublisher([new LocalReportPublisher(dir), new GitHubCommentPublisher()]),\n};\n\n/**\n * The publisher the phase should use. Going through the factory is what keeps\n * the command bound to `PrReviewPublisher` alone: adding a GitHub adapter is a\n * new entry here plus a configuration key, never a change to the phase.\n */\nexport function createPrReviewPublisher(\n  dir: string,\n  kind: PrReviewPublisherKind = 'local',\n): PrReviewPublisher {\n  return PUBLISHERS[kind](dir);\n}\n","import { readdir, readFile } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport { resolveIssuePaths } from '../../storage/resolve.js';\nimport type { PrReviewRecommendation } from '../../types.js';\n\n/**\n * Everything the `pr-review` phase produces out of a headless run: the parsed\n * verdict, the Markdown report and the structured index.\n *\n * The Markdown is what a human reads; `index.json` is what an automation reads.\n * Keeping both means a future GitHub publisher never has to re-parse Markdown\n * to know what the review concluded.\n */\n\n/** The Pull Request a report is about. Fields the source never knew stay null. */\nexport interface PrReviewPullRequest {\n  number: number;\n  url: string | null;\n  title: string | null;\n  headBranch: string | null;\n}\n\nexport type FindingSeverity = 'blocker' | 'high' | 'medium' | 'low';\n\nexport interface PrReviewFinding {\n  severity: FindingSeverity;\n  file: string | null;\n  line: number | null;\n  title: string;\n}\n\nexport interface PrReviewResult {\n  recommendation: PrReviewRecommendation;\n  /** Items listed under `BLOCKERS:`; empty when the review found none. */\n  blockers: string[];\n}\n\n/**\n * Parsing outcome. A failure is explicit rather than an `APPROVE` default:\n * silently approving a Pull Request because the agent's output was malformed\n * is the one failure mode this phase must never have.\n */\nexport type PrReviewParse = { ok: true; result: PrReviewResult } | { ok: false; error: string };\n\nexport interface PrReviewRoundEntry {\n  round: number;\n  at: string;\n  /** null when the output could not be parsed — never coerced to APPROVE. */\n  recommendation: PrReviewRecommendation | null;\n  headSha: string | null;\n  /** Relative to the directory holding index.json. */\n  reportPath: string;\n  findings: PrReviewFinding[];\n}\n\nexport interface PrReviewIndex {\n  schemaVersion: 1;\n  pullRequest: PrReviewPullRequest;\n  rounds: PrReviewRoundEntry[];\n}\n\nconst RECOMMENDATIONS: Record<string, PrReviewRecommendation> = {\n  APPROVE: 'APPROVE',\n  APPROVE_WITH_SUGGESTIONS: 'APPROVE_WITH_SUGGESTIONS',\n  REQUEST_CHANGES: 'REQUEST_CHANGES',\n};\n\n/**\n * Read the `<pr-review-result>` block. Tolerant in the spirit of\n * `parseReviewResult()` (`commands/review.ts`): without the block, a bare\n * `RECOMMENDATION:` line in the raw output still counts. Anything else — no\n * recommendation at all, or one outside the enum — is a parse failure.\n */\nexport function parsePrReviewResult(output: string): PrReviewParse {\n  const block = output.match(/<pr-review-result>([\\s\\S]*?)<\\/pr-review-result>/);\n  const scope = block?.[1] ?? output;\n\n  const line = scope.match(/RECOMMENDATION:\\s*([^\\n\\r]+)/i);\n  if (line?.[1] === undefined) {\n    return {\n      ok: false,\n      error: block\n        ? 'The <pr-review-result> block has no RECOMMENDATION line.'\n        : 'No <pr-review-result> block and no RECOMMENDATION line in the output.',\n    };\n  }\n\n  // Markdown emphasis around the verdict is stripped, but never the inner\n  // underscores of APPROVE_WITH_SUGGESTIONS.\n  const raw = line[1]\n    .trim()\n    .replace(/[*`]/g, '')\n    .replace(/^_+|[_.]+$/g, '')\n    .trim();\n  const normalized = raw.toUpperCase().replace(/[\\s-]+/g, '_');\n  const recommendation = RECOMMENDATIONS[normalized];\n  if (recommendation === undefined) {\n    return {\n      ok: false,\n      error:\n        `Unknown recommendation '${raw}'. ` +\n        'Expected APPROVE, APPROVE_WITH_SUGGESTIONS or REQUEST_CHANGES.',\n    };\n  }\n\n  return { ok: true, result: { recommendation, blockers: parseBlockers(scope) } };\n}\n\n/** Items under `BLOCKERS:`, up to the end of the block or the next label. */\nfunction parseBlockers(scope: string): string[] {\n  const match = scope.match(/BLOCKERS:([\\s\\S]*)/i);\n  if (match?.[1] === undefined) return [];\n\n  return match[1]\n    .split('\\n')\n    .map((entry) => entry.trim())\n    .filter((entry) => /^[-*]\\s+/.test(entry))\n    .map((entry) => entry.replace(/^[-*]\\s+/, '').trim())\n    .filter((entry) => entry !== '' && !/^(none|nenhum|n\\/a)\\.?$/i.test(entry));\n}\n\n/** The sections every report carries, in order. */\nexport const REPORT_SECTIONS = [\n  'Executive summary',\n  'Strengths',\n  'Issues found',\n  'Suggested improvements',\n  'Architectural observations',\n  'Risks identified',\n  'Required before merge',\n  'Final recommendation',\n] as const;\n\nexport type ReportSection = (typeof REPORT_SECTIONS)[number];\n\n/**\n * Headings that map onto a canonical section. The agent writes prose, so the\n * mapping is deliberately forgiving — an unmatched heading is not dropped, it\n * lands in \"Additional notes\".\n */\nconst SECTION_ALIASES: Record<ReportSection, string[]> = {\n  'Executive summary': ['executive summary', 'summary', 'overview', 'resumo executivo', 'resumo'],\n  Strengths: ['strengths', 'positives', 'highlights', 'what went well', 'pontos positivos'],\n  'Issues found': ['issues found', 'issues', 'problems', 'findings', 'problemas encontrados'],\n  'Suggested improvements': [\n    'suggested improvements',\n    'suggestions',\n    'improvements',\n    'sugestoes de melhoria',\n    'sugestoes',\n  ],\n  'Architectural observations': [\n    'architectural observations',\n    'architecture',\n    'architectural notes',\n    'observacoes arquiteturais',\n    'arquitetura',\n  ],\n  'Risks identified': ['risks identified', 'risks', 'riscos identificados', 'riscos'],\n  'Required before merge': [\n    'required before merge',\n    'blockers',\n    'must fix before merge',\n    'itens obrigatorios antes do merge',\n  ],\n  'Final recommendation': [\n    'final recommendation',\n    'recommendation',\n    'verdict',\n    'recomendacao final',\n    'recomendacao',\n  ],\n};\n\n/** lowercase, unaccented, without list numbering or trailing punctuation. */\nfunction normalizeHeading(heading: string): string {\n  return heading\n    .normalize('NFD')\n    .replace(/[\\u0300-\\u036f]/g, '')\n    .toLowerCase()\n    .replace(/^\\d+[.)]\\s*/, '')\n    .replace(/[*_`#]/g, '')\n    .replace(/[.:;!?]+$/, '')\n    .replace(/\\s+/g, ' ')\n    .trim();\n}\n\nfunction matchSection(heading: string): ReportSection | null {\n  const normalized = normalizeHeading(heading);\n  for (const section of REPORT_SECTIONS) {\n    if (SECTION_ALIASES[section].includes(normalized)) return section;\n  }\n  return null;\n}\n\ninterface SplitBody {\n  sections: Map<ReportSection, string>;\n  /** Preamble and unrecognized headings, preserved verbatim. */\n  extra: string;\n}\n\n/**\n * Split the agent's Markdown by heading. Content that matches no canonical\n * section is kept rather than discarded: the report is the record of the\n * review, so nothing the agent wrote may be lost in the rewrite.\n */\nfunction splitBody(body: string): SplitBody {\n  const sections = new Map<ReportSection, string>();\n  const extra: string[] = [];\n  let current: ReportSection | null = null;\n  let buffer: string[] = [];\n\n  const flush = () => {\n    const content = buffer.join('\\n').trim();\n    buffer = [];\n    if (content === '') return;\n    if (current === null) {\n      extra.push(content);\n      return;\n    }\n    const previous = sections.get(current);\n    sections.set(current, previous === undefined ? content : `${previous}\\n\\n${content}`);\n  };\n\n  for (const line of body.split('\\n')) {\n    const heading = line.match(/^#{1,6}\\s+(.*)$/);\n    if (heading?.[1] === undefined) {\n      buffer.push(line);\n      continue;\n    }\n    flush();\n    const section = matchSection(heading[1]);\n    current = section;\n    if (section === null) {\n      buffer.push(line);\n    }\n  }\n  flush();\n\n  return { sections, extra: extra.join('\\n\\n').trim() };\n}\n\nconst FINDING_LINE = /^[-*]\\s*\\[(\\w+)\\]\\s+(.+)$/;\nconst FINDING_LOCATION = /^(\\S+?)(?::(\\d+))?\\s+[—–-]\\s+(.+)$/;\n\nconst SEVERITY_ALIASES: Record<string, FindingSeverity> = {\n  blocker: 'blocker',\n  blocking: 'blocker',\n  critical: 'blocker',\n  high: 'high',\n  major: 'high',\n  medium: 'medium',\n  moderate: 'medium',\n  low: 'low',\n  minor: 'low',\n  nit: 'low',\n};\n\n/**\n * Structured findings out of the report body, from list items written as\n * `- [severity] path/to/file.ts:12 — Title` under \"Issues found\" and\n * \"Required before merge\" (the format the prompt asks for). Items in any other\n * shape stay in the Markdown only: the index is a convenience for automations,\n * never the authoritative record.\n */\nexport function parseFindings(body: string): PrReviewFinding[] {\n  const { sections } = splitBody(body);\n  const scopes = [sections.get('Issues found'), sections.get('Required before merge')];\n  const findings: PrReviewFinding[] = [];\n\n  for (const scope of scopes) {\n    if (scope === undefined) continue;\n    for (const line of scope.split('\\n')) {\n      const item = line.trim().match(FINDING_LINE);\n      if (item?.[1] === undefined || item[2] === undefined) continue;\n\n      const severity = SEVERITY_ALIASES[item[1].toLowerCase()];\n      // Unknown markers stay in the Markdown only — inventing `medium` would\n      // mislead any automation that keys off index.json severities.\n      if (severity === undefined) continue;\n\n      const rest = item[2].trim();\n      const location = rest.match(FINDING_LOCATION);\n      if (location?.[1] === undefined || location[3] === undefined) {\n        findings.push({ severity, file: null, line: null, title: rest });\n        continue;\n      }\n      findings.push({\n        severity,\n        file: location[1],\n        line: location[2] === undefined ? null : Number(location[2]),\n        title: location[3].trim(),\n      });\n    }\n  }\n\n  return dedupeFindings(findings);\n}\n\n/** A finding listed both as an issue and as a merge blocker is still one finding. */\nfunction dedupeFindings(findings: PrReviewFinding[]): PrReviewFinding[] {\n  const seen = new Set<string>();\n  return findings.filter((finding) => {\n    const key = `${finding.file ?? ''}:${finding.line ?? ''}:${finding.title}`;\n    if (seen.has(key)) return false;\n    seen.add(key);\n    return true;\n  });\n}\n\nexport interface BuildReportInput {\n  pullRequest: PrReviewPullRequest;\n  round: number;\n  at: string;\n  headSha?: string | null;\n  /** null when parsing failed. */\n  recommendation: PrReviewRecommendation | null;\n  /** Raw headless output. */\n  body: string;\n  /** Set when `parsePrReviewResult()` failed, so the raw output is kept. */\n  parseError?: string | null;\n}\n\n/**\n * Assemble the Markdown report: a metadata header, the canonical sections in a\n * fixed order and — when parsing failed — the raw output verbatim, so a\n * malformed run is still auditable instead of being reduced to an exit code.\n */\nexport function buildReportMarkdown(input: BuildReportInput): string {\n  const pr = input.pullRequest;\n  const parts: string[] = [`# Pull Request Review — #${pr.number} (round ${input.round})`, ''];\n\n  const heading = pr.url === null ? `#${pr.number}` : `[#${pr.number}](${pr.url})`;\n  parts.push(`- **Pull Request:** ${heading}${pr.title === null ? '' : ` — ${pr.title}`}`);\n  if (pr.headBranch !== null) parts.push(`- **Head branch:** ${pr.headBranch}`);\n  if (input.headSha != null) parts.push(`- **Head SHA:** ${input.headSha}`);\n  parts.push(`- **Round:** ${input.round}`);\n  parts.push(`- **Reviewed at:** ${input.at}`);\n  parts.push(`- **Recommendation:** ${input.recommendation ?? 'UNPARSED'}`);\n  parts.push('');\n\n  if (input.parseError != null && input.parseError !== '') {\n    parts.push(`> Verdict could not be parsed: ${input.parseError}`, '');\n  }\n\n  const { sections, extra } = splitBody(input.body);\n  for (const section of REPORT_SECTIONS) {\n    parts.push(`## ${section}`, '', sections.get(section) ?? '_Not reported._', '');\n  }\n\n  if (input.parseError != null && input.parseError !== '') {\n    parts.push('## Raw agent output', '', '```text', input.body.trim(), '```', '');\n  } else if (extra !== '') {\n    parts.push('## Additional notes', '', extra, '');\n  }\n\n  return `${parts.join('\\n').trimEnd()}\\n`;\n}\n\n/**\n * The global `issues/<N>/pr-review/`, or `issues/pr-<N>/pr-review/` with no\n * issue.\n *\n * A Pull Request with no associated Issue still needs somewhere to keep its\n * rounds, so it gets the synthetic `pr-<N>` identifier — `getIssuePaths()`\n * accepts non-numeric identifiers, so it is a first-class issue directory as\n * far as the storage layer is concerned.\n */\nexport async function prReviewDir(opts: { issue?: string; pullRequest: number }): Promise<string> {\n  const slug =\n    opts.issue === undefined || opts.issue === ''\n      ? `pr-${opts.pullRequest}`\n      : opts.issue.replace(/^#/, '');\n  return (await resolveIssuePaths(slug)).prReviewDir;\n}\n\nexport function reportFileName(pullRequest: number, round: number): string {\n  return `pr-${pullRequest}-round-${round}.md`;\n}\n\nconst REPORT_FILE = /^pr-(\\d+)-round-(\\d+)\\.md$/;\n\n/**\n * Read `index.json`. Never throws: a missing or corrupt index means \"no rounds\n * recorded yet\", which the round resolution below cross-checks against the\n * report files actually on disk.\n */\nexport async function readPrReviewIndex(dir: string): Promise<PrReviewIndex | null> {\n  try {\n    const parsed: unknown = JSON.parse(await readFile(join(dir, 'index.json'), 'utf-8'));\n    if (typeof parsed !== 'object' || parsed === null) return null;\n    const index = parsed as Partial<PrReviewIndex>;\n    if (!Array.isArray(index.rounds) || typeof index.pullRequest !== 'object') return null;\n    return {\n      schemaVersion: 1,\n      pullRequest: index.pullRequest as PrReviewPullRequest,\n      rounds: index.rounds,\n    };\n  } catch {\n    return null;\n  }\n}\n\n/** Rounds already written for this Pull Request, from the report file names. */\nasync function roundsOnDisk(dir: string, pullRequest: number): Promise<number[]> {\n  try {\n    return (await readdir(dir))\n      .map((name) => name.match(REPORT_FILE))\n      .filter((match): match is RegExpMatchArray => match !== null)\n      .filter((match) => Number(match[1]) === pullRequest)\n      .map((match) => Number(match[2]));\n  } catch {\n    return [];\n  }\n}\n\n/**\n * Which round to write: the explicit `--round <n>`, which rewrites that round,\n * or one past the highest round seen. Both the index and the files on disk are\n * consulted so a corrupt index can never overwrite an existing report.\n */\nexport async function resolveRound(\n  dir: string,\n  pullRequest: number,\n  explicit?: number,\n): Promise<number> {\n  if (explicit !== undefined) return explicit;\n\n  const index = await readPrReviewIndex(dir);\n  const known = [\n    ...(index?.rounds ?? []).map((entry) => entry.round),\n    ...(await roundsOnDisk(dir, pullRequest)),\n  ];\n  return known.length === 0 ? 1 : Math.max(...known) + 1;\n}\n\n/**\n * Add or replace a round. Additive by construction: writing round N+1 keeps\n * every earlier entry, and `--round n` replaces exactly one.\n */\nexport function upsertRound(index: PrReviewIndex, entry: PrReviewRoundEntry): PrReviewIndex {\n  const rounds = index.rounds.filter((existing) => existing.round !== entry.round);\n  rounds.push(entry);\n  rounds.sort((a, b) => a.round - b.round);\n  return { ...index, rounds };\n}\n"],"mappings":"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","names":["join","join","join","join"]}