@llm4ts/flow 2.30.1 → 2.31.1

package/src/GateTriage.ts

@@ -0,0 +1,250 @@
+// Gates with a memory (ADR 0027): what the target's gates said on the code a
+// change started from, and which failing lines the change can be charged
+// with. Pure helpers and a small store; the seams are lintCommand and
+// reviewAndFixLoop (Review.ts), implementPlanFlow (Flow.ts) and the story
+// executor (Stories.ts). Gates.ts re-exports this module beside gatesIn.
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+import type { PersistenceError } from "./FlowError.ts"
+import type { PlainFileStoreShape } from "./Persistence.ts"
+import { ReviewIssue, ReviewResult } from "./Review.ts"
+import { fingerprintOf } from "./ReviewCache.ts"
+
+export const GateClass = Schema.Literals(["red", "hang", "crash"])
+export type GateClass = typeof GateClass.Type
+
+export const FailureOrigin = Schema.Literals(["new", "base", "flaky"])
+export type FailureOrigin = typeof FailureOrigin.Type
+
+export class GateBaseline extends Schema.Class<GateBaseline>("GateBaseline")({
+  baseCommit: Schema.String,
+  appDir: Schema.String,
+  /** Each gate command as configured, joined with one space. */
+  commands: Schema.Array(Schema.String),
+  failingLines: Schema.Array(Schema.String),
+  /** Tests passing on the base, when the test gate's output said (the oracle guard compares). */
+  passedCount: Schema.optionalKey(Schema.Int),
+  recordedAt: Schema.Number
+}) {}
+
+/** Every baseline a run recorded, by `baselineKey`; one file, deleted on land. */
+const Baselines = Schema.Record(Schema.String, GateBaseline)
+const BaselinesJson = Schema.fromJsonString(Baselines)
+const decodeBaselines = Schema.decodeUnknownEffect(BaselinesJson)
+const encodeBaselines = Schema.encodeSync(BaselinesJson)
+
+// Built from the escape code point so the pattern holds no control character literal.
+const ansi = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "gu")
+const duration = /\b\d+(?:\.\d+)?\s?(?:ms|s|m)\b/gu
+const isoTimestamp = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?/gu
+const stackFrame = /^\s*at\s/u
+const summaryLine =
+  /^\s*(?:Test Files|Tests|Duration|Start at|Snapshots|Found \d+ errors?|\d+ (?:passing|failing|pending))\b/u
+const failureMarker =
+  /FAIL|✗|×|✘|✖|❯|error|Error|AssertionError|Expected|Received|expected|TS\d{4}/u
+
+/**
+ * The lines of a gate's output a change can be blamed for, made comparable
+ * across runs and worktrees: colours, timings, timestamps and the given root
+ * prefixes removed; stack frames, summaries and blank lines dropped; only
+ * lines carrying a failure marker kept, each once. A heuristic by design:
+ * per-tool parsers are kit material (a pack `diagnostics:` command, later).
+ */
+export const normalizeGateOutput = (
+  text: string,
+  roots: ReadonlyArray<string>
+): ReadonlyArray<string> => {
+  const prefixes = roots.filter((root) => root.length > 0).map((root) => root.replace(/\/+$/u, ""))
+  const seen = new Set<string>()
+  const out: Array<string> = []
+  for (const raw of text.split(/\r?\n/u)) {
+    let line = raw.replace(ansi, "")
+    for (const prefix of prefixes) {
+      line = line.replaceAll(`${prefix}/`, "")
+    }
+    line = line.replace(isoTimestamp, "<ts>").replace(duration, "<t>").trim()
+    if (line.length === 0 || stackFrame.test(line) || summaryLine.test(line)) {
+      continue
+    }
+    if (!failureMarker.test(line)) {
+      continue
+    }
+    line = line.replace(/\s+/gu, " ")
+    if (!seen.has(line)) {
+      seen.add(line)
+      out.push(line)
+    }
+  }
+  return out
+}
+
+/** The title prefix `lintCommand` gives every gate issue; nothing else is a gate. */
+export const gateIssuePrefix = "lint failed: "
+
+export const isGateIssue = (issue: ReviewIssue): boolean => issue.title.startsWith(gateIssuePrefix)
+
+/** Every gate issue's normalized failing lines, in order, each once. */
+export const failingLinesOf = (
+  result: ReviewResult,
+  roots: ReadonlyArray<string>
+): ReadonlyArray<string> =>
+  Array.from(
+    new Set(
+      result.issues
+        .filter(isGateIssue)
+        .flatMap((issue) => normalizeGateOutput(issue.description, roots))
+    )
+  )
+
+export interface GateTriage {
+  /** The lint result with only the failures the change caused; clean when it caused none. */
+  readonly blocking: ReviewResult
+  readonly newLines: ReadonlyArray<string>
+  /** Failing lines already red on the base: listed, never charged. */
+  readonly inherited: ReadonlyArray<string>
+}
+
+/**
+ * Splits a lint result against the baseline. A gate issue whose every
+ * failing line is on the baseline is dropped (inherited); one with new lines
+ * is kept with `origin: "new"` and its description reduced to those lines,
+ * so the fix prompt names only what the change broke. A gate issue with no
+ * recognizable failing line at all (a hang, a crash, an unparsed output) is
+ * kept whole. Non-gate issues (the perimeter, the oracle guard) pass through.
+ * Without a baseline the result is returned as is.
+ */
+export const triageGates = (
+  result: ReviewResult,
+  baseline: GateBaseline | undefined,
+  roots: ReadonlyArray<string>
+): GateTriage => {
+  if (baseline === undefined || result.isClean) {
+    return { blocking: result, newLines: [], inherited: [] }
+  }
+  const known = new Set(baseline.failingLines)
+  const newLines: Array<string> = []
+  const inherited: Array<string> = []
+  const issues: Array<ReviewIssue> = []
+  for (const issue of result.issues) {
+    if (!isGateIssue(issue)) {
+      issues.push(issue)
+      continue
+    }
+    const lines = normalizeGateOutput(issue.description, roots)
+    const fresh = lines.filter((line) => !known.has(line))
+    inherited.push(...lines.filter((line) => known.has(line)))
+    if (lines.length > 0 && fresh.length === 0) {
+      continue
+    }
+    newLines.push(...fresh)
+    issues.push(
+      ReviewIssue.make({
+        ...issue,
+        origin: "new",
+        description: fresh.length > 0 ? fresh.join("\n") : issue.description
+      })
+    )
+  }
+  return {
+    blocking: ReviewResult.make({
+      issues,
+      summary: issues.length === 0 ? "lint passed (inherited failures only)" : result.summary
+    }),
+    newLines: Array.from(new Set(newLines)),
+    inherited: Array.from(new Set(inherited))
+  }
+}
+
+export const baselineKey = (parts: {
+  readonly baseCommit: string
+  readonly appDir: string
+  readonly commands: ReadonlyArray<ReadonlyArray<string>>
+}): string =>
+  fingerprintOf([
+    parts.baseCommit,
+    parts.appDir,
+    ...parts.commands.map((command) => command.join(" "))
+  ]).slice(0, 16)
+
+/** The one file a run keeps its baselines in. */
+export const baselinesPath = (stateDir: string): string =>
+  `${stateDir.replace(/\/+$/u, "")}/gates/baselines.json`
+
+const readAll = (
+  files: PlainFileStoreShape,
+  path: string
+): Effect.Effect<Readonly<Record<string, GateBaseline>>, PersistenceError> =>
+  files.read(path).pipe(
+    Effect.flatMap((text) =>
+      text === undefined
+        ? Effect.succeed({})
+        : decodeBaselines(text).pipe(
+            // An unreadable file is no baseline: the caller records a fresh one.
+            Effect.catch(() => Effect.succeed({}))
+          )
+    )
+  )
+
+export const readBaseline = (
+  files: PlainFileStoreShape,
+  stateDir: string,
+  key: string
+): Effect.Effect<GateBaseline | undefined, PersistenceError> =>
+  Effect.map(readAll(files, baselinesPath(stateDir)), (all) => all[key])
+
+export interface EnsureBaselineArgs<E> {
+  readonly files: PlainFileStoreShape
+  readonly stateDir: string
+  /** The commit the change starts from. */
+  readonly commit: string
+  readonly appDir: string
+  readonly commands: ReadonlyArray<ReadonlyArray<string>>
+  /** Runs the gates on that commit; called only when no baseline is stored. */
+  readonly run: Effect.Effect<ReviewResult, E>
+  /** Root prefixes stripped from gate output (the work dir, the app dir). */
+  readonly roots: ReadonlyArray<string>
+  readonly now: Effect.Effect<number>
+}
+
+/**
+ * The baseline for a commit: the stored one, or a fresh one recorded from
+ * `run`. Lazy on purpose, so a second change on an unchanged commit costs
+ * no gate run.
+ */
+export const ensureBaseline = <E>(
+  args: EnsureBaselineArgs<E>
+): Effect.Effect<GateBaseline, E | PersistenceError> =>
+  Effect.gen(function* () {
+    const key = baselineKey({
+      baseCommit: args.commit,
+      appDir: args.appDir,
+      commands: args.commands
+    })
+    const stored = yield* readBaseline(args.files, args.stateDir, key)
+    if (stored !== undefined) {
+      return stored
+    }
+    const result = yield* args.run
+    const baseline = GateBaseline.make({
+      baseCommit: args.commit,
+      appDir: args.appDir,
+      commands: args.commands.map((command) => command.join(" ")),
+      failingLines: failingLinesOf(result, args.roots),
+      ...(result.passed === undefined ? {} : { passedCount: result.passed }),
+      recordedAt: yield* args.now
+    })
+    yield* writeBaseline(args.files, args.stateDir, key, baseline)
+    return baseline
+  })
+
+export const writeBaseline = (
+  files: PlainFileStoreShape,
+  stateDir: string,
+  key: string,
+  baseline: GateBaseline
+): Effect.Effect<void, PersistenceError> => {
+  const path = baselinesPath(stateDir)
+  return Effect.flatMap(readAll(files, path), (all) =>
+    files.writeAtomic(path, encodeBaselines({ ...all, [key]: baseline }))
+  )
+}

package/src/Gates.ts

@@ -0,0 +1,104 @@
+// The target's gates as a module (ADR 0027): run them in a directory with a
+// timeout and a log per gate, remember what they said on a base, and keep
+// only what matters when an epic lands. The pure half lives in
+// GateTriage.ts and is re-exported here.
+import { join } from "node:path"
+import type * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
+import type { ProcessExecutorShape } from "@llm4ts/core/ProcessExecutor"
+import type { FlowError } from "./FlowError.ts"
+import type { FlowEventsShape } from "./FlowEvents.ts"
+import { baselinesPath, normalizeGateOutput } from "./GateTriage.ts"
+import type { PlainFileStoreShape } from "./Persistence.ts"
+import { lintCommand, mergeReviewResults, type ReviewResult } from "./Review.ts"
+
+export * from "./GateTriage.ts"
+
+export interface GateLogDir {
+  readonly files: PlainFileStoreShape
+  readonly dir: string
+}
+
+export interface GateRunOptions {
+  readonly timeout?: Duration.Duration
+  /** Where this runner's logs go unless a call names its own; `undefined` writes none. */
+  readonly logDir?: GateLogDir
+}
+
+/** `<index>-<command slug>.log`: one file per gate command, overwritten each run. */
+export const gateLogName = (index: number, command: ReadonlyArray<string>): string =>
+  `${index}-${command
+    .join(" ")
+    .replace(/[^a-z0-9]+/giu, "-")
+    .replace(/^-|-$/gu, "")
+    .toLowerCase()}.log`
+
+/** Runs the gates in a directory, stopping at the first red one (later output would be noise). */
+export const gatesIn =
+  (
+    process: ProcessExecutorShape,
+    events: FlowEventsShape,
+    commands: ReadonlyArray<ReadonlyArray<string>>,
+    options: GateRunOptions = {}
+  ) =>
+  (
+    workDir: string,
+    laneEvents?: FlowEventsShape,
+    log?: GateLogDir
+  ): Effect.Effect<ReviewResult, FlowError> =>
+    Effect.gen(function* () {
+      const sink = log ?? options.logDir
+      const results: Array<ReviewResult> = []
+      for (const [index, command] of commands.entries()) {
+        const result = yield* lintCommand(process, laneEvents ?? events, command, workDir, {
+          ...(options.timeout === undefined ? {} : { timeout: options.timeout }),
+          ...(sink === undefined
+            ? {}
+            : { log: { files: sink.files, path: join(sink.dir, gateLogName(index, command)) } })
+        })
+        results.push(result)
+        if (!result.isClean) {
+          break
+        }
+      }
+      return mergeReviewResults(results)
+    })
+
+/** A landed epic keeps why a gate was red, not the target's whole test output. */
+export const compactGateLog = (text: string, roots: ReadonlyArray<string>): string =>
+  normalizeGateOutput(text, roots).join("\n")
+
+/** The gate log directory of one story under a run's state folder. */
+export const storyGateLogDir = (stateDir: string, storyId: string): string =>
+  join(stateDir, "stories", storyId, "gates")
+
+/**
+ * What `--land` keeps of the gates: no baselines (reproducible), and each
+ * story's gate logs reduced to their failing lines. Logs are enumerated from
+ * the story ids and the gate commands, so no listing is needed.
+ */
+export const compactGateArtifacts = Effect.fn("@llm4ts/flow/Gates.compactArtifacts")(function* (
+  files: PlainFileStoreShape,
+  stateDir: string,
+  storyIds: ReadonlyArray<string>,
+  commands: ReadonlyArray<ReadonlyArray<string>>
+): Effect.fn.Return<{ readonly baselines: number; readonly logs: number }, FlowError> {
+  const path = baselinesPath(stateDir)
+  const hadBaselines = (yield* files.read(path)) !== undefined
+  if (hadBaselines) {
+    yield* files.remove(path)
+  }
+  let logs = 0
+  for (const storyId of storyIds) {
+    for (const [index, command] of commands.entries()) {
+      const logPath = join(storyGateLogDir(stateDir, storyId), gateLogName(index, command))
+      const text = yield* files.read(logPath)
+      if (text === undefined) {
+        continue
+      }
+      yield* files.writeAtomic(logPath, compactGateLog(text, []))
+      logs += 1
+    }
+  }
+  return { baselines: hadBaselines ? 1 : 0, logs }
+})

package/src/OracleGuard.ts

@@ -0,0 +1,205 @@
+// The oracle guard (ADR 0027, decision 4): a change may not delete a test
+// file, add a skip or focus marker, or lower the passed-test count unless
+// its plan entry says it may. Deterministic, from the diff and the gate
+// output; a violation is a gate failure the fix round can undo.
+import * as Schema from "effect/Schema"
+import { ReviewIssue } from "./Review.ts"
+
+export class OracleRules extends Schema.Class<OracleRules>("OracleRules")({
+  /** Regex source: a path matching it is a test file. */
+  testFiles: Schema.String,
+  /** Substrings whose appearance on an added line marks a skipped or focused test. */
+  markers: Schema.Array(Schema.String)
+}) {}
+
+export const defaultOracleRules = OracleRules.make({
+  testFiles:
+    "(?:^|/)(?:__tests__|tests?|spec|src/test)/|\\.(?:test|spec)\\.[cm]?[jt]sx?$|_test\\.(?:go|py|rs)$|Tests?\\.(?:java|kt|scala|cs)$|^tests?_.*\\.py$",
+  markers: [
+    ".skip(",
+    ".only(",
+    "xit(",
+    "xdescribe(",
+    "xtest(",
+    "test.todo(",
+    "it.todo(",
+    "@Ignore",
+    "@Disabled",
+    "@pytest.mark.skip",
+    "#[ignore]"
+  ]
+})
+
+/** The parsed body of a pack's `## Oracle` section: `- tests: <regex>` and `- markers: a, b`. */
+export const oracleRulesFrom = (fields: {
+  readonly tests?: string
+  readonly markers?: ReadonlyArray<string>
+}): OracleRules =>
+  OracleRules.make({
+    testFiles: fields.tests ?? defaultOracleRules.testFiles,
+    markers: [...defaultOracleRules.markers, ...(fields.markers ?? [])]
+  })
+
+export interface AddedLine {
+  readonly file: string
+  readonly line: number
+  readonly text: string
+}
+
+export interface DiffShape {
+  /** Files the diff deletes outright. */
+  readonly deleted: ReadonlyArray<string>
+  /** Lines the diff adds, with the path and the new line number. */
+  readonly added: ReadonlyArray<AddedLine>
+}
+
+const fileHeader = /^diff --git a\/(.+?) b\/(.+)$/u
+const hunkHeader = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/u
+
+/** The deletions and added lines of a unified diff; pure, tolerant of noise between files. */
+export const parseUnifiedDiff = (diff: string): DiffShape => {
+  const deleted: Array<string> = []
+  const added: Array<AddedLine> = []
+  let file: string | undefined
+  let line = 0
+  let inHunk = false
+  for (const raw of diff.split(/\r?\n/u)) {
+    const header = fileHeader.exec(raw)
+    if (header !== null) {
+      file = header[2]
+      inHunk = false
+      continue
+    }
+    if (file === undefined) continue
+    if (raw.startsWith("deleted file mode")) {
+      deleted.push(file)
+      continue
+    }
+    const hunk = hunkHeader.exec(raw)
+    if (hunk !== null) {
+      line = Number.parseInt(hunk[1] ?? "0", 10)
+      inHunk = true
+      continue
+    }
+    if (!inHunk) continue
+    if (raw.startsWith("+++") || raw.startsWith("---")) continue
+    if (raw.startsWith("+")) {
+      added.push({ file, line, text: raw.slice(1) })
+      line += 1
+    } else if (raw.startsWith("-")) {
+      // a removed line: the new file's numbering does not advance
+    } else if (raw.startsWith("\\")) {
+      // ""
+    } else {
+      line += 1
+    }
+  }
+  return { deleted, added }
+}
+
+const vitestLike = /\bTests\b[^\n]*?(\d+)\s+passed/u
+const jestLike = /\bTests:\s[^\n]*?(\d+)\s+passed/u
+const pytestLike = /(?:^|\n)[^\n]*?\b(\d+)\s+passed\b[^\n]*\bin\s+[\d.]+s/u
+const cargoLike = /test result:[^\n]*?(\d+)\s+passed/u
+const mochaLike = /(?:^|\n)\s*(\d+)\s+passing\b/u
+const junitLike =
+  /Tests run:\s*(\d+),\s*Failures:\s*(\d+),\s*Errors:\s*(\d+)(?:,\s*Skipped:\s*(\d+))?/gu
+
+/**
+ * The passed-test count in a test runner's output, when a summary line the
+ * guard knows is present (Vitest, Jest, pytest, cargo test, mocha, JUnit
+ * via Maven/Gradle); `undefined` otherwise, which the guard reports as an
+ * Info rather than a verdict.
+ */
+export const passedCountIn = (output: string): number | undefined => {
+  for (const pattern of [vitestLike, jestLike, cargoLike, pytestLike, mochaLike]) {
+    const match = pattern.exec(output)
+    if (match?.[1] !== undefined) {
+      return Number.parseInt(match[1], 10)
+    }
+  }
+  // Maven prints a line per class and one grand total; the largest run is the total.
+  let largestRun = -1
+  let passedOfLargest: number | undefined
+  junitLike.lastIndex = 0
+  for (let match = junitLike.exec(output); match !== null; match = junitLike.exec(output)) {
+    const run = Number.parseInt(match[1] ?? "0", 10)
+    const failures = Number.parseInt(match[2] ?? "0", 10)
+    const errors = Number.parseInt(match[3] ?? "0", 10)
+    const skipped = Number.parseInt(match[4] ?? "0", 10)
+    if (run >= largestRun) {
+      largestRun = run
+      passedOfLargest = run - failures - errors - skipped
+    }
+  }
+  return passedOfLargest
+}
+
+export interface OracleCounts {
+  /** Tests passing on the base, from its baseline; `undefined` when unknown. */
+  readonly base: number | undefined
+  /** Tests passing on the change, from its test gate; `undefined` when unknown. */
+  readonly current: number | undefined
+}
+
+export const oracleIssuePrefix = "oracle: "
+
+/**
+ * The guard's verdict on a change: one Critical per deleted test file, one
+ * per added marker (with `file:line`), one for a passed-count drop; empty
+ * when `declared` (the plan entry says tests may change). Counts are judged
+ * only when both are known; a caller reports the unknown case as an Info.
+ */
+export const checkOracle = (
+  diff: DiffShape,
+  counts: OracleCounts | undefined,
+  rules: OracleRules,
+  declared: boolean
+): ReadonlyArray<ReviewIssue> => {
+  if (declared) {
+    return []
+  }
+  const testFile = new RegExp(rules.testFiles, "u")
+  const issues: Array<ReviewIssue> = []
+  for (const path of diff.deleted) {
+    if (testFile.test(path)) {
+      issues.push(
+        ReviewIssue.make({
+          severity: "Critical",
+          title: `${oracleIssuePrefix}test file deleted: ${path}`,
+          description:
+            "Restore it. A story may not delete a test unless its plan entry declares `testsChange: true`.",
+          file: path
+        })
+      )
+    }
+  }
+  for (const line of diff.added) {
+    if (!testFile.test(line.file)) continue
+    const marker = rules.markers.find((candidate) => line.text.includes(candidate))
+    if (marker === undefined) continue
+    issues.push(
+      ReviewIssue.make({
+        severity: "Critical",
+        title: `${oracleIssuePrefix}skip or focus marker added: ${marker.trim()}`,
+        description: `${line.file}:${line.line}: ${line.text.trim()}\nRemove the marker and make the test pass, or report the test as wrong in your Findings.`,
+        file: line.file,
+        line: line.line
+      })
+    )
+  }
+  if (counts?.base !== undefined && counts.current !== undefined && counts.current < counts.base) {
+    issues.push(
+      ReviewIssue.make({
+        severity: "Critical",
+        title: `${oracleIssuePrefix}fewer tests pass than on the base (${counts.current} < ${counts.base})`,
+        description:
+          "Tests were removed, skipped or no longer discovered. Restore them; declare `testsChange: true` on the story if the change is intended."
+      })
+    )
+  }
+  return issues
+}
+
+export const isOracleIssue = (issue: ReviewIssue): boolean =>
+  issue.title.startsWith(oracleIssuePrefix)

package/src/Pack.ts

@@ -3,6 +3,7 @@ import * as Schema from "effect/Schema"
 import { Dimension } from "@llm4ts/core/eval/Eval"
 import type { ConsolidateRules } from "./Domains.ts"
 import { PlanParseError } from "./FlowError.ts"
+import { oracleRulesFrom, type OracleRules } from "./OracleGuard.ts"
 import { parseReviewer, type Reviewer } from "./Reviewer.ts"
 import { CoverageRule } from "./SpecChecks.ts"
 import type { WorkspaceError, WorkspaceShape } from "./Workspace.ts"
@@ -67,6 +68,12 @@ export interface Pack {
    * fragment as context (`context:`). Absent: every program is its own feature.
    */
   readonly consolidate: ConsolidateRules | undefined
+  /**
+   * The `## Oracle` section (ADR 0027): `- tests: <regex>` for what a test
+   * file is and `- markers: a, b` for extra skip or focus markers, merged
+   * over the defaults. Absent: the defaults.
+   */
+  readonly oracle: OracleRules | undefined
   readonly dir: string
   readonly gate: (name: string) => ReadonlyArray<string> | undefined
   readonly prompt: (name: string) => string | undefined
@@ -266,6 +273,14 @@ export const loadPack = Effect.fn("@llm4ts/flow/Pack.load")(function* (
       message: `pack manifest 'spec-schema:' must be 'pagespec' when set, got: ${specSchema}`
     })
   }
+  const oracleValues = namedItems(section(manifest.sections, "Oracle"))
+  const oracle: OracleRules | undefined =
+    section(manifest.sections, "Oracle") === undefined
+      ? undefined
+      : oracleRulesFrom({
+          ...(oracleValues.tests === undefined ? {} : { tests: oracleValues.tests }),
+          markers: commaList(oracleValues.markers)
+        })
   const consolidateValues = namedItems(section(manifest.sections, "Consolidate"))
   const consolidate: ConsolidateRules | undefined =
     section(manifest.sections, "Consolidate") === undefined
@@ -330,6 +345,7 @@ export const loadPack = Effect.fn("@llm4ts/flow/Pack.load")(function* (
     featureFiles,
     specSchema,
     consolidate,
+    oracle,
     dir: directory,
     gate: (name) => gates[name],
     prompt: (name) => prompts[name],

package/src/Retro.ts

@@ -461,6 +461,13 @@ export const renderRetroDigest = (inputs: RetroInputs): string => {
       case "CapabilityUnenforceable":
         runLines.push(`- capability unenforceable: ${event.detail}`)
         break
+      case "EvidenceChecked":
+        if (event.unverified > 0) {
+          runLines.push(
+            `- fabricated status: task "${event.task}"${event.lane === undefined ? "" : ` (story ${event.lane})`} claimed ${event.unverified} command(s) that never ran`
+          )
+        }
+        break
       case "ExecutorExcluded":
         runLines.push(`- executor excluded: ${event.executor} — ${event.reason}`)
         break