diff --git a/packages/opencode/src/altimate/review/compiled.ts b/packages/opencode/src/altimate/review/compiled.ts
index 05fe1a7ce..d6ce7ca6a 100644
--- a/packages/opencode/src/altimate/review/compiled.ts
+++ b/packages/opencode/src/altimate/review/compiled.ts
@@ -36,12 +36,20 @@ export async function dbtProjectName(cwd: string): Promise<string | undefined> {
 }
 
 export interface CompiledResolverOptions {
+  /** dbt project root (the dir containing `dbt_project.yml`). */
   cwd: string
   projectName?: string
   /** Directory holding HEAD-side compiled SQL (relative to cwd). */
   headDir?: string
   /** Directory holding BASE-side compiled SQL (relative to cwd). */
   baseDir?: string
+  /** Prefix within the repo-relative file path that maps to `cwd`.
+   *  For a monorepo where the dbt project lives at `packages/dbt/`, callers
+   *  pass `pathPrefix: "packages/dbt"` so a repo-relative path like
+   *  `packages/dbt/models/foo.sql` resolves inside the dbt project root as
+   *  `models/foo.sql` before joining with `target/compiled/<project>/`.
+   *  Omit when `cwd` IS the repo root. */
+  pathPrefix?: string
 }
 
 /**
@@ -52,13 +60,35 @@ export function makeCompiledResolver(opts: CompiledResolverOptions) {
   const project = opts.projectName
   const headDir = opts.headDir ?? "target/compiled"
   const baseDir = opts.baseDir ?? "target-base/compiled"
+  // Normalise the prefix so both "" and "." mean "no prefix". Match against
+  // git-style forward slashes because `git diff --name-status` always emits
+  // POSIX separators regardless of platform. `path.relative()` on Windows
+  // returns backslashes, so callers passing that verbatim would produce a
+  // prefix that never matches — normalise here (codex R20 review HIGH).
+  const prefix =
+    opts.pathPrefix && opts.pathPrefix !== "."
+      ? opts.pathPrefix.replace(/\\/g, "/").replace(/\/+$/, "")
+      : ""
 
   return async (file: string, side: "old" | "new"): Promise<string | undefined> => {
     if (!project) return undefined
+    // When the dbt project sits inside a subdir of the repo, `file` (from
+    // `git diff --name-status`) is repo-root relative and always uses
+    // POSIX separators. Strip the mapped prefix so it becomes dbt-root
+    // relative before joining with `cwd` (which IS the dbt root). Without
+    // this the compiled resolver silently misses in monorepo layouts.
+    const rel = prefix && (file === prefix || file.startsWith(prefix + "/")) ? file.slice(prefix.length + 1) : file
     const root = side === "new" ? headDir : baseDir
-    const full = path.join(opts.cwd, root, project, file)
+    const compiledRoot = path.join(opts.cwd, root, project)
+    // Containment check via realpath — matches makeContentResolver's
+    // symlink-safe read (coderabbit + cubic security review). A symlinked
+    // compiled artifact pointing outside `compiledRoot` is not read.
     try {
-      return await fs.readFile(full, "utf8")
+      const rootReal = await fs.realpath(compiledRoot)
+      const targetReal = await fs.realpath(path.join(compiledRoot, rel))
+      const sep = path.sep
+      if (targetReal !== rootReal && !targetReal.startsWith(rootReal + sep)) return undefined
+      return await fs.readFile(targetReal, "utf8")
     } catch {
       return undefined
     }
diff --git a/packages/opencode/src/altimate/review/dbt-patterns.ts b/packages/opencode/src/altimate/review/dbt-patterns.ts
index 85b475aba..1af4fd588 100644
--- a/packages/opencode/src/altimate/review/dbt-patterns.ts
+++ b/packages/opencode/src/altimate/review/dbt-patterns.ts
@@ -1,4 +1,6 @@
 import path from "node:path"
+import YAML from "yaml"
+import { Log } from "@/altimate/util/log"
 import { type Finding, type Severity, type ReviewCategory, makeFinding } from "./finding"
 import { type ChangedFile, classifyDbtFile } from "./diff-filter"
 import { type Rubric, clampSeverity, exclusionReason } from "./rubric"
@@ -790,33 +792,433 @@ export function detectModelPatterns(file: ChangedFile, newSql: string | undefine
  * Detect removal of `unique` / `not_null` / `relationships` tests in a schema.yml
  * diff — the guardrail that catches fan-out/dupes is the thing being deleted.
  */
-export function detectSchemaYmlPatterns(file: ChangedFile, rubric: Rubric): Finding[] {
+/**
+ * Structural extraction of `(model, column?, test)` tuples from a parsed
+ * schema.yml document. Handles:
+ *  - Column-level tests under `models[*].columns[*].tests` / `.data_tests`
+ *  - Model-level tests directly under `models[*].tests` / `.data_tests`
+ *    (surrogate-key `unique`, etc. — no column)
+ *  - Sources (`sources[*].tables[*].(columns[*].)tests`) since dbt supports
+ *    the same test grammar there
+ *  - Snapshots (`snapshots[*].(columns[*].)tests`)
+ *  - Both bare (`- unique`) and block-form (`- relationships: {...}`)
+ *  - Both `tests` and `data_tests` (dbt 1.8+ alias)
+ *
+ * Returns a Set of canonical `${modelOrSource}\x00${column}\x00${test}` keys
+ * (column is empty string for model-level tests). Yields nothing when the
+ * document isn't shaped like a schema.yml.
+ */
+function extractTestOccurrences(doc: unknown): Set<string> {
+  const out = new Set<string>()
+  if (!doc || typeof doc !== "object") return out
+  const d = doc as Record<string, unknown>
+
+  const emitTests = (entity: string, column: string, tests: unknown): void => {
+    if (!Array.isArray(tests)) return
+    for (const t of tests) {
+      const name =
+        typeof t === "string"
+          ? t
+          : t && typeof t === "object"
+            ? Object.keys(t as Record<string, unknown>)[0]
+            : undefined
+      if (!name) continue
+      const n = name.toLowerCase()
+      // Restrict to the guardrail tests the detector cares about; a bespoke
+      // custom test being removed is not a signal at this level.
+      if (n === "unique" || n === "not_null" || n === "relationships") {
+        // PR #1027 consensus MINOR #4 — a column can carry MULTIPLE
+        // `relationships` tests pointing at different parents (e.g. one to
+        // dim_customers, one to legacy.dim_customers during a migration).
+        // Keying on `(entity, column, test)` alone collapses them into a
+        // single set entry, so dropping one silently doesn't surface.
+        // `unique` / `not_null` are single-instance semantically (a repeat is
+        // a no-op), so this discriminator only affects `relationships`.
+        // Block-form: `- relationships: {to: ..., field: ...}` → append the
+        // (to, field) tuple to the key. Bare string form: no discriminator
+        // (the block-form is the shape dbt requires for `relationships`
+        // anyway; a bare `- relationships` isn't a legal declaration).
+        let discriminator = ""
+        if (n === "relationships" && t && typeof t === "object") {
+          const args = (t as Record<string, unknown>)[name]
+          // dbt 1.10.5+ nests test args under `arguments:`; earlier versions
+          // put them at the top level of the test's value map (cubic-review P3).
+          const argsObj =
+            args && typeof args === "object" ? (args as Record<string, unknown>) : undefined
+          const nested =
+            argsObj?.arguments && typeof argsObj.arguments === "object"
+              ? (argsObj.arguments as Record<string, unknown>)
+              : undefined
+          const to = String((nested ?? argsObj)?.to ?? "")
+          const field = String((nested ?? argsObj)?.field ?? "")
+          if (to || field) discriminator = `\x01${to}\x02${field}`
+        }
+        out.add(`${entity}\x00${column}\x00${n}${discriminator}`)
+      }
+    }
+  }
+
+  const walkEntityWithColumns = (entityName: string | undefined, node: unknown): void => {
+    if (!entityName || !node || typeof node !== "object") return
+    const n = node as Record<string, unknown>
+    // Model/source/snapshot-level tests: `tests:` or `data_tests:` right under the entity.
+    emitTests(entityName, "", n.tests)
+    emitTests(entityName, "", n.data_tests)
+    if (Array.isArray(n.columns)) {
+      for (const col of n.columns) {
+        if (!col || typeof col !== "object") continue
+        const c = col as Record<string, unknown>
+        const cname = typeof c.name === "string" ? c.name : undefined
+        if (!cname) continue
+        emitTests(entityName, cname, c.tests)
+        emitTests(entityName, cname, c.data_tests)
+      }
+    }
+  }
+
+  // `models:` — array of `{ name, columns?, tests? }`
+  if (Array.isArray(d.models)) {
+    for (const m of d.models) {
+      if (!m || typeof m !== "object") continue
+      const mm = m as Record<string, unknown>
+      const mname = typeof mm.name === "string" ? mm.name : undefined
+      walkEntityWithColumns(mname, mm)
+    }
+  }
+  // `snapshots:` — same shape as models
+  if (Array.isArray(d.snapshots)) {
+    for (const s of d.snapshots) {
+      if (!s || typeof s !== "object") continue
+      const ss = s as Record<string, unknown>
+      const sname = typeof ss.name === "string" ? ss.name : undefined
+      walkEntityWithColumns(sname, ss)
+    }
+  }
+  // `sources:` — `[{ name, tables: [{ name, columns?, tests? }] }]`
+  if (Array.isArray(d.sources)) {
+    for (const src of d.sources) {
+      if (!src || typeof src !== "object") continue
+      const srcObj = src as Record<string, unknown>
+      const srcName = typeof srcObj.name === "string" ? srcObj.name : undefined
+      if (!Array.isArray(srcObj.tables)) continue
+      for (const t of srcObj.tables) {
+        if (!t || typeof t !== "object") continue
+        const tt = t as Record<string, unknown>
+        const tname = typeof tt.name === "string" ? tt.name : undefined
+        const qualified = srcName && tname ? `${srcName}.${tname}` : tname || undefined
+        walkEntityWithColumns(qualified, tt)
+      }
+    }
+  }
+  // `seeds:` — leaf entity, same test grammar
+  if (Array.isArray(d.seeds)) {
+    for (const s of d.seeds) {
+      if (!s || typeof s !== "object") continue
+      const ss = s as Record<string, unknown>
+      const sname = typeof ss.name === "string" ? ss.name : undefined
+      walkEntityWithColumns(sname, ss)
+    }
+  }
+  return out
+}
+
+/**
+ * Fallback removed-test detector for callers that supply only the diff
+ * (no old/new content). Kept intentionally conservative: matches removed
+ * lines that look like `- unique | not_null | relationships`, subtracts any
+ * added line with the same trimmed text. Cannot distinguish "moved to
+ * another column" from "removed from this column" — that requires content.
+ * The old-string dedup false-negative on sibling columns is inherent to
+ * diff-only input; when structural content is available we use the
+ * structural path (`extractTestOccurrences` diff of old vs new).
+ */
+function fallbackRemovedTestLines(diff: string | undefined): string[] {
+  if (!diff) return []
+  const added: string[] = []
+  const removed: string[] = []
+  for (const raw of diff.split("\n")) {
+    if (raw.startsWith("+") && !raw.startsWith("+++")) added.push(raw.slice(1))
+    else if (raw.startsWith("-") && !raw.startsWith("---")) removed.push(raw.slice(1))
+  }
+  const testLine = /^\s*-\s*(unique|not_null|relationships)\b/i
+  const removedTests = removed.filter((l) => testLine.test(l))
+  const addedTrim = new Set(added.map((l) => l.trim()))
+  return removedTests.filter((l) => !addedTrim.has(l.trim()))
+}
+
+export interface SchemaYmlDetectContent {
+  oldContent?: string
+  newContent?: string
+}
+
+/**
+ * Detect removed data tests in a schema.yml diff.
+ *
+ * PREFERRED path (production, via orchestrator): pass full old/new content in
+ * `opts` — the detector parses both YAML documents, diffs by
+ * `(entity, column, test)` tuples, and emits one finding per genuine removal.
+ * This captures model-level tests (no column), sibling-column edge cases
+ * (unique removed from column X while column Y still declares it), quoted /
+ * commented YAML names, and any layout / indent style the parser accepts.
+ *
+ * FALLBACK path (callers that only have the raw diff, e.g. unit tests or
+ * pre-collected CI diffs without a content resolver): use the string-based
+ * removed-line detection preserved from the pre-R18 detector. It cannot
+ * tell "removed" from "moved to another column" for the same test type on
+ * a sibling column — that limitation is inherent to diff-only input.
+ */
+export function detectSchemaYmlPatterns(
+  file: ChangedFile,
+  rubric: Rubric,
+  opts: SchemaYmlDetectContent = {},
+): Finding[] {
   const kind = classifyDbtFile(file.path)
-  if (kind !== "schema_yml" || file.status === "deleted") return []
-  const { added, removed } = splitDiff(file.diff)
-  const removedTests = removed.filter((l) => /^\s*-\s*(unique|not_null|relationships)\b/i.test(l))
-  // A test still present (just moved) shouldn't fire.
-  const addedTests = new Set(added.map((l) => l.trim()))
-  const genuinelyRemoved = removedTests.filter((l) => !addedTests.has(l.trim()))
-  if (!genuinelyRemoved.length) return []
-  const removedUnique = genuinelyRemoved.some((l) => /\bunique\b/i.test(l))
-  const f = makeFinding({
-    severity: removedUnique ? "warning" : "suggestion",
-    category: "test_coverage",
-    title: `${file.path.split("/").pop()}: removed ${genuinelyRemoved.length} data test(s)`,
-    body:
-      "This change deletes `unique`/`not_null`/`relationships` test(s) — the guardrails that catch fan-out, duplicate, " +
-      "and broken-FK regressions. Removing a `unique` test on a grain key is how silent duplicate bugs ship. " +
-      "Confirm the test is genuinely obsolete, not removed to make CI green.",
-    file: file.path,
-    confidence: "high",
-    evidence: {
-      tool: "dbt-patterns",
-      result: { rule: "removed_tests", removed: genuinelyRemoved.map((l) => l.trim()) },
-    },
-    ruleKey: "test_coverage:removed-tests",
-  })
-  return [{ ...f, severity: clampSeverity(f.category, f.severity, f.confidence) }].filter(
-    (x) => !exclusionReason(x, rubric),
-  )
+  if (kind !== "schema_yml") return []
+
+  const removals: Array<{
+    model: string
+    column: string
+    test: string
+    /** Extra discriminator (e.g. `to:field` for a `relationships` test) so
+     *  multiple same-named tests on one column don't collapse via ruleKey.
+     *  Empty for `unique` / `not_null` and for fallback (diff-only) findings. */
+    testTag?: string
+  }> = []
+  let usedStructural = false
+
+  // Deleting a whole schema.yml removes every test declared in it — arguably
+  // a bigger removal than dropping a single test. Treat the new side as empty
+  // and diff the old document against `{}` so every prior test surfaces as a
+  // removal (cubic-review P2). Requires `oldContent` from the caller.
+  const isDeletedFile = file.status === "deleted"
+
+  // PREFERRED: structural YAML diff when we have both sides' content.
+  //
+  // "Added" file case (no `oldContent` supplied AND status marks the file as
+  // newly-added upstream) — the old side is empty, so there's nothing to
+  // remove; using the structural path with an empty old set is correct.
+  //
+  // "Deleted" file case — the new side is empty; use the structural path
+  // with an empty new set so every old test surfaces as a removal.
+  //
+  // "Modified but resolver returned undefined" case (`oldContent === undefined`
+  // for a file whose status is `modified` or `renamed`) — the resolver couldn't
+  // read the old side. Do NOT treat this as an added file (would silently drop
+  // real removals). Fall through to the diff-only fallback below.
+  const isAddedFile = file.status === "added"
+  const canUseStructural =
+    (isDeletedFile
+      ? opts.oldContent !== undefined
+      : opts.newContent !== undefined &&
+        // For a real modification/rename we require both sides; without oldContent
+        // fall back to diff parsing so removals in the diff still surface.
+        (isAddedFile || opts.oldContent !== undefined))
+
+  if (canUseStructural) {
+    let oldDoc: unknown = undefined
+    let newDoc: unknown = undefined
+    if (opts.newContent !== undefined) {
+      try {
+        newDoc = YAML.parse(opts.newContent)
+      } catch (err) {
+        // Debug telemetry: YAML parsers can trip on Jinja injected into a
+        // schema.yml or on non-ASCII quirks; log so failures are diagnosable
+        // rather than silently demoting to the fallback path.
+        Log.create({ service: "review", tag: "detectSchemaYmlPatterns" }).warn(
+          `YAML.parse failed on new content of ${file.path}; falling back to diff-only detection`,
+          err instanceof Error ? { error: err.message } : undefined,
+        )
+        newDoc = undefined
+      }
+    }
+    if (opts.oldContent !== undefined) {
+      try {
+        oldDoc = YAML.parse(opts.oldContent)
+      } catch (err) {
+        Log.create({ service: "review", tag: "detectSchemaYmlPatterns" }).warn(
+          `YAML.parse failed on old content of ${file.path}; falling back to diff-only detection`,
+          err instanceof Error ? { error: err.message } : undefined,
+        )
+        oldDoc = undefined
+      }
+    }
+    // Only commit to the structural path when the appropriate sides parsed:
+    //  - deleted → old must parse; new is treated as `{}`
+    //  - added   → new must parse; old is treated as `{}`
+    //  - modified/renamed → both must parse
+    // This preserves "unparseable YAML" → fallback rather than
+    // "structural with empty side = every test looks removed/added".
+    const canCommit = isDeletedFile
+      ? oldDoc !== undefined
+      : newDoc !== undefined && (isAddedFile || oldDoc !== undefined)
+    if (canCommit) {
+      const oldSet = extractTestOccurrences(oldDoc ?? {})
+      const newSet = extractTestOccurrences(isDeletedFile ? {} : newDoc)
+      for (const key of oldSet) {
+        if (newSet.has(key)) continue
+        const [model, column, testField] = key.split("\x00")
+        // `testField` may carry a `\x01<to>\x02<field>` discriminator for
+        // `relationships` tests so multiple relationships on the same column
+        // don't collapse to one removal (MINOR #4). Strip it for display;
+        // retain the internal `\x02` separator in `testTag` for the ruleKey
+        // — a colon-joined form would collide when either arg contains `:`
+        // (e.g. `to='a:b'` vs `field='b:c'`, codex R20 review minor).
+        // ruleKey is hashed for fingerprinting; control chars survive.
+        const [test, tagPayload] = testField.split("\x01")
+        const testTag = tagPayload ?? ""
+        removals.push({ model, column, test, testTag })
+      }
+      usedStructural = true
+    }
+  }
+
+  // FALLBACK: line-based detection for diff-only callers (unit tests, offline
+  // CI diffs) OR when the structural path couldn't parse both sides.
+  //
+  // No local deduplication: each entry in `removedLines` is already one match
+  // per raw removed line, and model/column are always empty on this path — a
+  // (model, column, test) dedup key would collapse to just `test` and silently
+  // merge distinct removals of the same test type on different columns.
+  //
+  // Downstream, `runReview` runs a global `dedupe` step that fingerprints
+  // findings by (category, file, model, column, ruleKey). Two fallback
+  // findings that share `file`, empty `model`, empty `column`, and a
+  // test-name-only `ruleKey` would still collapse there. We tag each fallback
+  // finding with a stable occurrence-index discriminator (`#0`, `#1`, …) so
+  // distinct removals in the same diff survive the global dedupe. The index
+  // is per-diff, not per-file-history — sufficient for one review pass and
+  // stable across dry-repeats of the same diff.
+  const fallbackDiscriminators: string[] = []
+  if (!usedStructural) {
+    const removedLines = fallbackRemovedTestLines(file.diff)
+    let idx = 0
+    for (const l of removedLines) {
+      const m = /^\s*-\s*(unique|not_null|relationships)\b/i.exec(l)
+      if (!m) continue
+      removals.push({ model: "", column: "", test: m[1].toLowerCase() })
+      fallbackDiscriminators.push(`#${idx++}`)
+    }
+  }
+
+  if (!removals.length) return []
+
+  const findings: Finding[] = []
+  const isMartLayer = /(^|\/)(marts?|reporting)\//.test(file.path)
+  const layerLabel = isMartLayer ? "mart-layer" : "declared"
+  // Emit the "N removals across models A/B/C" summary line ONCE per file
+  // (on the first finding), not once per distinct model — otherwise a diff
+  // that removes tests from three models produces three copies of the same
+  // global summary. A single boolean guard is enough.
+  let summaryEmitted = false
+
+  // Consumed in lock-step with the removals loop below (fallback path only).
+  // Using an index avoids `shift()`, which would be O(N) per call on the
+  // discriminator array — negligible on 2-3 removals but O(N²) on a large
+  // schema.yml PR that drops many tests.
+  let fallbackIdx = 0
+  for (const r of removals) {
+    const isUniquenessSignal = r.test === "unique"
+    const notNullOnLikelyPK =
+      r.test === "not_null" && !!r.column && /(_id$|^id$|_key$)/i.test(r.column)
+    // Uniqueness OR not_null on an id/key column = warning (silent-dup / null-PK
+    // risk); other not_null / relationships removals = suggestion.
+    const sev: Severity = isUniquenessSignal || notNullOnLikelyPK ? "warning" : "suggestion"
+
+    // Title / body vary based on whether structural attribution is available.
+    const attributed = !!r.model && !!r.column
+    const modelLevel = !!r.model && !r.column
+    const filename = file.path.split("/").pop()
+    const locKey = attributed ? `${r.model}.${r.column}` : modelLevel ? `${r.model} (model-level)` : "(unknown location)"
+    const title = attributed
+      ? `${filename}: ${r.test} test removed from ${locKey}`
+      : modelLevel
+        ? `${filename}: model-level ${r.test} test removed from \`${r.model}\``
+        : `${filename}: ${r.test} data test removed`
+
+    let bodyLead: string
+    if (attributed) {
+      bodyLead = `The \`${r.test}\` data test was removed from column \`${r.column}\` on model \`${r.model}\`. `
+    } else if (modelLevel) {
+      bodyLead = `A model-level \`${r.test}\` test was removed from \`${r.model}\`. `
+    } else {
+      bodyLead = `A \`${r.test}\` data test was removed from this schema file. `
+    }
+    let bodyRationale: string
+    if (isUniquenessSignal) {
+      bodyRationale =
+        `Removing a \`unique\` test on a ${layerLabel} key is how silent duplicate rows ship — ` +
+        `downstream joins fan out, aggregates double-count, and no test catches it. Restore ` +
+        `the test, or explicitly document why the grain no longer needs to be unique on this column.`
+    } else if (notNullOnLikelyPK) {
+      bodyRationale =
+        `Removing \`not_null\` on what looks like an identifier column (\`${r.column}\`) means nulls ` +
+        `will slip through into downstream joins and aggregates. Restore the test unless the column ` +
+        `is genuinely nullable now.`
+    } else {
+      bodyRationale =
+        `Removing an existing data test is a silent-regression risk. Confirm the test is genuinely ` +
+        `obsolete, not dropped to make CI green.`
+    }
+    // Emit the aggregate summary once per file, on the first finding, and
+    // only when there are multiple removals to summarise. Uses the file-scoped
+    // `summaryEmitted` flag rather than a per-model guard so a diff touching
+    // three models emits ONE summary, not three. Distinct-models computation
+    // is gated inside the branch so we don't pay for the Set/spread/map on
+    // every loop iteration when the summary won't be attached.
+    const shouldEmitSummary = !summaryEmitted && removals.length > 1
+    let bodyTail = ""
+    if (shouldEmitSummary) {
+      summaryEmitted = true
+      const distinctModels = [...new Set(removals.map((x) => x.model).filter(Boolean))]
+      const modelClause = distinctModels.length
+        ? ` on model(s) ${distinctModels.map((m) => `\`${m}\``).join(", ")}`
+        : ""
+      // Scoped to THIS schema file — the removals loop counts the current
+      // file's removals only, not the PR's aggregate. Wording was previously
+      // "This PR removes N data tests in total" which misled reviewers on
+      // multi-file diffs (per PR #1027 consensus MINOR #3). A global-PR
+      // summary would need to move to orchestrate.ts.
+      bodyTail = `\n\n_This schema file drops ${removals.length} data tests${modelClause}._`
+    }
+
+    // ruleKey feeds the finding fingerprint (finding.ts:107). For attributed
+    // (structural) findings, `(model.column.test)` is unique per removal in
+    // the file. For unattributed fallback findings, `(?.?.test)` collapses
+    // distinct removals of the same test type — we append the fallback
+    // discriminator so each removed line becomes a distinct finding
+    // downstream of the global dedupe.
+    const discriminator = attributed || modelLevel ? "" : `.${fallbackDiscriminators[fallbackIdx++] ?? "#?"}`
+    findings.push(
+      makeFinding({
+        severity: clampSeverity("test_coverage", sev, "high"),
+        category: "test_coverage",
+        title,
+        body: bodyLead + bodyRationale + bodyTail,
+        file: file.path,
+        // Surface the extracted attribution on the top-level Finding so
+        // downstream consumers (dedupe, formatting, telemetry) see it —
+        // not just inside `evidence.result` (cubic-review P3).
+        model: r.model || undefined,
+        column: r.column || undefined,
+        confidence: "high",
+        evidence: {
+          tool: "dbt-patterns",
+          result: {
+            rule: "removed_tests",
+            model: r.model || undefined,
+            column: r.column || undefined,
+            test: r.test,
+            attribution: attributed ? "column" : modelLevel ? "model-level" : "diff-only",
+          },
+        },
+        // testTag suffix (`:to:field` for `relationships`) survives the global
+        // finding fingerprint dedupe so multiple relationships on the same
+        // column emit distinct findings (MINOR #4).
+        ruleKey: `test_coverage:removed-tests:${r.model || "?"}.${r.column || "?"}.${r.test}${
+          r.testTag ? `.${r.testTag}` : ""
+        }${discriminator}`,
+      }),
+    )
+  }
+  return findings.filter((x) => !exclusionReason(x, rubric))
 }
diff --git a/packages/opencode/src/altimate/review/diff-filter.ts b/packages/opencode/src/altimate/review/diff-filter.ts
index 234c04c29..4079fb640 100644
--- a/packages/opencode/src/altimate/review/diff-filter.ts
+++ b/packages/opencode/src/altimate/review/diff-filter.ts
@@ -61,7 +61,11 @@ export function classifyDbtFile(path: string): DbtFileKind {
   const isYaml = p.endsWith(".yml") || p.endsWith(".yaml")
   if (/(^|\/)(dbt_project|profiles|packages|dependencies)\.ya?ml$/.test(p)) return "project_config"
   if (/(^|\/)macros\//.test(p)) return "macro"
-  if (/(^|\/)snapshots\//.test(p)) return "snapshot"
+  // Snapshots split by extension: `.sql` files are snapshot definitions
+  // (tier-forcing, catalog-scoped), YAML property files under `snapshots/`
+  // are schema files (declared tests + column metadata) and should route to
+  // `schema_yml` so the test-removal detector runs on them.
+  if (/(^|\/)snapshots\//.test(p) && p.endsWith(".sql")) return "snapshot"
   if (/(^|\/)seeds\//.test(p) && p.endsWith(".csv")) return "seed"
   if (/(^|\/)tests\//.test(p) && p.endsWith(".sql")) return "test"
   if (/(^|\/)analyses\//.test(p)) return "analysis"
diff --git a/packages/opencode/src/altimate/review/format.ts b/packages/opencode/src/altimate/review/format.ts
index c6bebbc4e..0befe5883 100644
--- a/packages/opencode/src/altimate/review/format.ts
+++ b/packages/opencode/src/altimate/review/format.ts
@@ -28,7 +28,12 @@ export function verdictHeadline(env: VerdictEnvelope): string {
     [critical && `${critical} critical`, warning && `${warning} warning`, suggestion && `${suggestion} suggestion`]
       .filter(Boolean)
       .join(", ") || "no findings"
-  return `${VERDICT_LABEL[env.verdict]} — ${counts} (${env.tier} tier)`
+  // tierClassified is optional in the schema — guard against externally-built
+  // envelopes that mark tierForced without threading the original classification.
+  const tierLabel = env.tierForced
+    ? `${env.tier} tier — forced (was ${env.tierClassified ?? "unknown"})`
+    : `${env.tier} tier`
+  return `${VERDICT_LABEL[env.verdict]} — ${counts} (${tierLabel})`
 }
 
 /** Full PR/MR summary comment body (markdown), prefixed with the dedup marker. */
@@ -43,6 +48,37 @@ export function renderSummary(env: VerdictEnvelope): string {
     )
   }
 
+  // G1 (Round 18) — surface classifier reasons when --explain-tier populated
+  // them, so a customer can see why the review ran at this tier. Also surfaces
+  // when --force-tier bypassed the classifier (tierReasons is auto-populated).
+  // Truncate the rendered summary on very large diffs: classifyPR appends one
+  // reason per file forcing FULL tier (e.g. every touched schema.yml or every
+  // PII column), which bloats the comment on wide PRs. The full list stays in
+  // the signed envelope's tierReasons[]; the summary shows the first 8.
+  if (env.tierReasons && env.tierReasons.length) {
+    const RENDER_CAP = 8
+    // Pick an inline-code-span fence longer than any backtick run inside `r`
+    // so a path like `packages/…/foo`bar`.sql` cannot terminate the span
+    // (cubic-review P3).
+    const shown = env.tierReasons
+      .slice(0, RENDER_CAP)
+      .map((r) => {
+        const runs = r.match(/`+/g)
+        const maxRun = runs ? Math.max(...runs.map((run) => run.length)) : 0
+        const fence = "`".repeat(maxRun + 1)
+        // If the reason itself starts/ends with a backtick, pad with a space so
+        // the leading/trailing backtick isn't glued to the fence.
+        const pad = /^`|`$/.test(r) ? " " : ""
+        return `${fence}${pad}${r}${pad}${fence}`
+      })
+      .join(", ")
+    const overflow =
+      env.tierReasons.length > RENDER_CAP
+        ? ` (+${env.tierReasons.length - RENDER_CAP} more in verdict envelope)`
+        : ""
+    lines.push(`> 🧭 **Tier: ${env.tier}** — ${shown}${overflow}`, "")
+  }
+
   if (!env.findings.length) {
     lines.push("No issues found in the changed dbt models. 🎉", "")
   } else {
diff --git a/packages/opencode/src/altimate/review/git.ts b/packages/opencode/src/altimate/review/git.ts
index 595c61f43..447822a31 100644
--- a/packages/opencode/src/altimate/review/git.ts
+++ b/packages/opencode/src/altimate/review/git.ts
@@ -62,10 +62,36 @@ export async function collectChangedFiles(opts: CollectOptions): Promise<Changed
   )
 }
 
+/** Read the given file only when its realpath sits inside the resolved root.
+ *  Blocks the "tracked symlink escapes the repo" class of attack — e.g. a
+ *  `models/evil.sql → /etc/passwd` symlink that would otherwise leak external
+ *  files into the review pipeline (coderabbit + cubic security review).
+ *  Returns undefined when the target escapes, is missing, or realpath fails. */
+async function safeReadInside(root: string, rel: string): Promise<string | undefined> {
+  try {
+    // Realpath both sides so a symlink IN the repo, or a repo checked out
+    // under a symlinked path (`/var` → `/private/var` on macOS), still
+    // compares apples to apples. Missing realpath calls on the target fail
+    // fast into the catch (no read attempted).
+    const rootReal = await fs.realpath(root)
+    const targetReal = await fs.realpath(path.join(root, rel))
+    // Ensure `targetReal` is inside `rootReal` using a separator-aware
+    // startsWith check so `/repo-backup` doesn't count as inside `/repo`.
+    const sep = path.sep
+    if (targetReal !== rootReal && !targetReal.startsWith(rootReal + sep)) return undefined
+    return await fs.readFile(targetReal, "utf8")
+  } catch {
+    return undefined
+  }
+}
+
 /** Build a getContent(path, side) resolver over git refs / the working tree.
  *  `renames` maps a new path → its old path so the "old" side of a renamed file
- *  resolves from where it actually lived at `base` (not the post-rename path). */
-export function makeContentResolver(opts: CollectOptions & { renames?: Map<string, string> }) {
+ *  resolves from where it actually lived at `base` (not the post-rename path).
+ *  `gitRoot` is the repository top-level (from `git rev-parse --show-toplevel`).
+ *  When omitted, working-tree reads fall back to `opts.cwd`, which is only
+ *  correct when the CLI is invoked from the repo root. */
+export function makeContentResolver(opts: CollectOptions & { renames?: Map<string, string>; gitRoot?: string }) {
   return async (file: string, side: "old" | "new"): Promise<string | undefined> => {
     try {
       if (side === "old") {
@@ -75,13 +101,38 @@ export function makeContentResolver(opts: CollectOptions & { renames?: Map<strin
       if (opts.head) {
         return await git(["show", `${opts.head}:${file}`], opts.cwd)
       }
-      return await fs.readFile(path.join(opts.cwd, file), "utf8")
+      // File paths from `git diff --name-status` are repo-root relative,
+      // NOT `opts.cwd` relative. When the CLI is invoked from a subdirectory
+      // the naive `path.join(opts.cwd, file)` double-joins and fails ENOENT,
+      // returning undefined and silently demoting downstream detectors to
+      // the diff-only fallback. Root at the resolved git top-level when
+      // supplied by the caller; fall back to `opts.cwd` when we couldn't
+      // resolve it (non-git or bare-repo contexts). Reads are containment-
+      // checked (symlink-safe) — see safeReadInside.
+      const root = opts.gitRoot ?? opts.cwd
+      return await safeReadInside(root, file)
     } catch {
       return undefined
     }
   }
 }
 
+/** Resolve the repository top-level (`git rev-parse --show-toplevel`).
+ *  Used to root working-tree FS reads and existence checks at the repo root
+ *  regardless of the caller's cwd. Returns undefined outside a git repo.
+ *  Strips only the git-emitted terminator (`\r\n` or `\n`) rather than
+ *  `trim()` — a path with legitimate leading/trailing whitespace stays
+ *  intact (cubic-review P3). */
+export async function gitRepoRoot(cwd: string): Promise<string | undefined> {
+  try {
+    const out = await git(["rev-parse", "--show-toplevel"], cwd)
+    const root = out.replace(/[\r\n]+$/, "")
+    return root || undefined
+  } catch {
+    return undefined
+  }
+}
+
 /** Resolve a sensible default base ref (merge-base with origin/main/master). */
 export async function defaultBaseRef(cwd: string): Promise<string> {
   for (const candidate of ["origin/main", "origin/master", "main", "master"]) {
diff --git a/packages/opencode/src/altimate/review/orchestrate.ts b/packages/opencode/src/altimate/review/orchestrate.ts
index 68cefafde..07c60565b 100644
--- a/packages/opencode/src/altimate/review/orchestrate.ts
+++ b/packages/opencode/src/altimate/review/orchestrate.ts
@@ -190,6 +190,10 @@ export interface OrchestrateInput {
   /** PR metadata passed to the AI reviewer for intent checking. */
   prTitle?: string
   prBody?: string
+  /** G1 — attach the classifier's reason list to the envelope. */
+  explainTier?: boolean
+  /** G2 — override the classifier's tier decision. Envelope carries tierForced:true. */
+  forceTier?: "trivial" | "lite" | "full"
 }
 
 /** Derive the dbt model name from a model file path. */
@@ -1088,14 +1092,31 @@ export async function runReview(input: OrchestrateInput): Promise<VerdictEnvelop
   // A run is degraded when model files exist but none resolved against a manifest.
   const runDegraded = modelFiles.length > 0 ? !anyManifest : reviewable.length === 0
 
-  const tier = classifyPR(reviewable, {
+  const tierResult = classifyPR(reviewable, {
     blastRadiusOf: (p) => {
       const c = ctxByPath.get(p)
       return c ? c.impact.directCount + c.impact.transitiveCount : 0
     },
     touchesPiiOf: (f) => (ctxByPath.get(f.path)?.pii.length ?? 0) > 0,
     isComplexOf: (f) => ctxByPath.get(f.path)?.complex ?? false,
-  }).tier
+  })
+  const classifiedTier = tierResult.tier
+  // G2 — --force-tier overrides the classifier. Envelope records both the
+  // forced tier and the original classification whenever the flag is passed
+  // (regardless of whether the forced value happens to match the classifier),
+  // so audits can see the bypass every time the flag was used. The reasons
+  // list gets a leading "forced" marker so downstream doesn't confuse the
+  // forced tier for a natural one. Codex-R18-review fix — the earlier
+  // `!== classifiedTier` gate silently hid the bypass when the forced tier
+  // matched the classifier's result.
+  const tier = input.forceTier ?? classifiedTier
+  const tierForced = input.forceTier !== undefined
+  const tierReasons = tierForced
+    ? [
+        `forced via --force-tier=${input.forceTier} (classifier said ${classifiedTier})`,
+        ...tierResult.reasons,
+      ]
+    : tierResult.reasons
 
   const lanes = new Set(input.config.reviewers.length ? input.config.reviewers : TIER_LANES[tier])
 
@@ -1196,8 +1217,38 @@ export async function runReview(input: OrchestrateInput): Promise<VerdictEnvelop
 
   // schema.yml-level detectors (test removal) — run on changed YAML files
   // regardless of tier, since deleting a guardrail test is always worth flagging.
-  for (const file of reviewable) {
-    if (file.kind === "schema_yml") all.push(detectSchemaYmlPatterns(file, input.rubric))
+  // Pass old + new content when available so the detector diffs structural YAML
+  // (per-(entity, column, test) tuples) instead of walking the unified diff
+  // (which loses context when the model header is outside the -U3 window and
+  // silently drops sibling-column edge cases). Falls back to diff-only line
+  // detection when a content resolver isn't wired (e.g. unit-test callers).
+  //
+  // `oldContent` is fetched for anything that has an old side — MODIFIED,
+  // RENAMED, and DELETED. A schema.yml being renamed (e.g. moved to a new
+  // subdir) that also drops a `unique`/`not_null` guardrail must still surface
+  // as a finding; the earlier `status === "modified"` gate silently skipped
+  // renames. A whole schema.yml being DELETED removes every test declared in
+  // it — an even bigger removal — so the detector runs against `oldContent`
+  // vs an empty new document (cubic-review P2).
+  //
+  // `newContent` fetch is skipped for deleted files (nothing at HEAD to read;
+  // git-show would fail).
+  //
+  // Fetches run in parallel across schema files (a schema-heavy PR could touch
+  // dozens of yml files; serial `git show` per file adds up).
+  const schemaFiles = reviewable.filter((f) => f.kind === "schema_yml")
+  if (schemaFiles.length) {
+    const schemaFindingSets = await Promise.all(
+      schemaFiles.map(async (file) => {
+        const oldRef = file.oldPath ?? file.path
+        const [oldContent, newContent] = await Promise.all([
+          file.status !== "added" ? getContent?.(oldRef, "old") : Promise.resolve(undefined),
+          file.status !== "deleted" ? getContent?.(file.path, "new") : Promise.resolve(undefined),
+        ])
+        return detectSchemaYmlPatterns(file, input.rubric, { oldContent, newContent })
+      }),
+    )
+    for (const findings of schemaFindingSets) all.push(findings)
   }
 
   // Architectural dedup: the regex `dbt-patterns`/`rule-catalog` layer is a
@@ -1349,6 +1400,9 @@ export async function runReview(input: OrchestrateInput): Promise<VerdictEnvelop
     manifestHash: input.manifestHash,
     generatedAt: input.generatedAt,
     degraded,
+    tierReasons: input.explainTier || tierForced ? tierReasons : undefined,
+    tierForced: tierForced ? true : undefined,
+    tierClassified: tierForced ? classifiedTier : undefined,
   })
   return signEnvelope(envelope)
 }
diff --git a/packages/opencode/src/altimate/review/run.ts b/packages/opencode/src/altimate/review/run.ts
index 95b5c1589..4f4ef2882 100644
--- a/packages/opencode/src/altimate/review/run.ts
+++ b/packages/opencode/src/altimate/review/run.ts
@@ -1,8 +1,8 @@
 import path from "node:path"
-import { readFile } from "node:fs/promises"
+import { readFile, realpath, stat, access } from "node:fs/promises"
 import { loadReviewConfig, resolveRubric } from "./config"
 import type { Severity } from "./finding"
-import { collectChangedFiles, makeContentResolver, defaultBaseRef, manifestHash } from "./git"
+import { collectChangedFiles, makeContentResolver, defaultBaseRef, gitRepoRoot, manifestHash } from "./git"
 import { makeCompiledResolver, dbtProjectName } from "./compiled"
 import { buildCatalogSchemaContext } from "./schema-context"
 import { createDispatcherRunner } from "./runner"
@@ -42,6 +42,11 @@ export interface ReviewPullRequestOptions {
   /** PR metadata for the AI reviewer's intent check. */
   prTitle?: string
   prBody?: string
+  /** G1 — surface the tier classifier's reasons on the verdict envelope. */
+  explainTier?: boolean
+  /** G2 — [EXPERIMENTAL] bypass the tier classifier with the supplied tier.
+   *  Envelope carries `tierForced: true` when used. Debug / bench only. */
+  forceTier?: "trivial" | "lite" | "full"
 }
 
 /** dbt adapter_type → core SQL dialect. Mostly identity; a few aliases. */
@@ -73,6 +78,88 @@ async function detectDialect(manifestAbs: string): Promise<string | undefined> {
   }
 }
 
+/**
+ * G3 (Round 18) — walk upward from `cwd` looking for the nearest
+ * `dbt_project.yml`; if found, return the adjacent `target/manifest.json`
+ * (when it exists). Anchored on `dbt_project.yml` so we never pick up a
+ * `target/` from an unrelated tool (e.g. an Airflow project) that happens
+ * to live above us on the filesystem.
+ *
+ * We DO NOT re-run `dbt compile` here — that could touch a real warehouse or
+ * consume credentials. The customer is still responsible for compiling; we
+ * just find the existing artifact when they didn't pass `--manifest`.
+ *
+ * Returns undefined when no dbt project is found upward, or when the found
+ * project has no compiled manifest.
+ */
+async function autoDiscoverManifest(cwd: string): Promise<{ path: string; projectRoot: string } | undefined> {
+  // Walk up looking for dbt_project.yml so the manifest we auto-discover is
+  // demonstrably tied to a dbt project (never `target/manifest.json` from an
+  // unrelated cwd, e.g. Airflow's `target/`). `path.dirname(root) === root`
+  // on every platform, so once we reach the filesystem root the next step
+  // is a fixed point — exit at that point (NIT #6 tidy from consensus review).
+  for (let dir = path.resolve(cwd); ; dir = path.dirname(dir)) {
+    for (const fn of ["dbt_project.yml", "dbt_project.yaml"]) {
+      try {
+        await access(path.join(dir, fn))
+        const candidate = path.join(dir, "target", "manifest.json")
+        try {
+          await access(candidate)
+          return { path: candidate, projectRoot: dir }
+        } catch {
+          return undefined // dbt project found but not compiled — respect that
+        }
+      } catch {
+        /* keep walking */
+      }
+    }
+    if (path.dirname(dir) === dir) return undefined
+  }
+}
+
+/** Warn to stderr when the manifest looks stale relative to changed files.
+ *  Only considers dbt-relevant files (SQL, YAML, Python models, seed CSV,
+ *  docs markdown) — changes to `README.md` at repo root, `.github/`,
+ *  `package.json`, etc. don't affect whether the compiled manifest is still
+ *  valid, so their mtimes shouldn't trigger a stale warning. */
+/** Exported for tests — see review-run-stale.test.ts. */
+export function isManifestAffecting(rel: string): boolean {
+  // dbt source directories — code (sql/py), schema (yml), seeds (csv), and
+  // docs blocks (md files under models/ / snapshots/ / analyses/ / etc.).
+  if (/(^|\/)(models|seeds|snapshots|macros|tests|analyses)\/.*\.(sql|py|yml|yaml|csv|md)$/i.test(rel)) return true
+  // Top-level dbt project config files.
+  if (/(^|\/)(dbt_project|packages|profiles|dependencies)\.ya?ml$/i.test(rel)) return true
+  return false
+}
+
+async function warnIfStale(manifestAbs: string, changedPaths: string[], fsRoot: string): Promise<void> {
+  try {
+    const manifestMtime = (await stat(manifestAbs)).mtimeMs
+    for (const rel of changedPaths) {
+      if (!isManifestAffecting(rel)) continue
+      // `changedPaths` are repo-root relative (from `git diff --name-status`),
+      // so root at the git top-level rather than the caller's cwd. When the
+      // CLI is invoked from a subdir the naive path.join(cwd, rel) points at
+      // a non-existent path and the stale check silently no-ops.
+      const abs = path.isAbsolute(rel) ? rel : path.join(fsRoot, rel)
+      try {
+        const changedMtime = (await stat(abs)).mtimeMs
+        if (changedMtime > manifestMtime) {
+          process.stderr.write(
+            `⚠️  manifest ${manifestAbs} appears stale — ${rel} was modified after the manifest was written. ` +
+              `Re-run \`dbt compile\` (or \`dbt build\`) to refresh before reviewing.\n`,
+          )
+          return
+        }
+      } catch {
+        /* file not on disk (e.g. removed by the change) — skip */
+      }
+    }
+  } catch {
+    /* manifest unreadable → detectDialect will have already returned undefined */
+  }
+}
+
 export async function reviewPullRequest(opts: ReviewPullRequestOptions): Promise<VerdictEnvelope> {
   const config = await loadReviewConfig(opts.cwd)
   if (opts.manifestPath) config.manifestPath = opts.manifestPath
@@ -87,19 +174,61 @@ export async function reviewPullRequest(opts: ReviewPullRequestOptions): Promise
   const needGit = !opts.changedFiles || !opts.getContent
   const base = opts.base ?? (needGit ? await defaultBaseRef(opts.cwd) : "")
   const changedFiles = opts.changedFiles ?? (await collectChangedFiles({ base, head: opts.head, cwd: opts.cwd }))
+  // Resolve the repo top-level once; used to root working-tree FS reads, the
+  // stale-manifest existence check, and the compiled-SQL resolver's path
+  // mapping. Falls back to opts.cwd when we couldn't resolve it (non-git or
+  // bare-repo contexts) — safe for the repo-root-invoked case but not helpful
+  // in the subdir-invocation case that this addresses.
+  const gitRoot = (await gitRepoRoot(opts.cwd)) ?? opts.cwd
   // Map renamed files → their old path so getContent resolves the "old" side
   // from where the file lived at `base`.
   const renames = new Map(
     changedFiles.filter((f) => f.status === "renamed" && f.oldPath).map((f) => [f.path, f.oldPath as string]),
   )
-  const getContent = opts.getContent ?? makeContentResolver({ base, head: opts.head, cwd: opts.cwd, renames })
+  const getContent =
+    opts.getContent ?? makeContentResolver({ base, head: opts.head, cwd: opts.cwd, renames, gitRoot })
 
   // Resolve the manifest against the PROJECT being reviewed (cwd), not the
   // binary's process.cwd() — otherwise a relative path silently misses when the
   // CLI is invoked from elsewhere, degrading every review to lint-only.
-  const manifestAbs = path.isAbsolute(config.manifestPath)
+  let manifestAbs = path.isAbsolute(config.manifestPath)
     ? config.manifestPath
     : path.join(opts.cwd, config.manifestPath)
+  // The "effective dbt project root" for downstream lookups (dbtProjectName,
+  // compiled-SQL resolver). Starts as opts.cwd — G3 auto-discovery updates it
+  // when it finds a dbt_project.yml in an ancestor directory, so the compiled
+  // resolver and project-name lookups target the discovered project rather
+  // than the CLI's working directory (which may be a subdir).
+  let dbtRoot = opts.cwd
+  // G3 (Round 18) — auto-discovery when the caller didn't pass `--manifest` and
+  // the config-relative resolve above doesn't point at an existing file. Walk
+  // upward for the dbt project root and use its `target/manifest.json`. Explicit
+  // `--manifest` always wins (see run.ts opts.manifestPath override at the top).
+  if (!opts.manifestPath) {
+    let manifestExists = false
+    try {
+      await access(manifestAbs)
+      manifestExists = true
+    } catch {
+      /* fall through to auto-discovery */
+    }
+    if (!manifestExists) {
+      const discovered = await autoDiscoverManifest(opts.cwd)
+      if (discovered) {
+        manifestAbs = discovered.path
+        dbtRoot = discovered.projectRoot
+        process.stderr.write(
+          `ℹ️  auto-discovered dbt manifest at ${discovered.path} ` +
+            `(dbt project root: ${discovered.projectRoot}). Pass --manifest to override.\n`,
+        )
+      }
+    }
+  }
+  // Freshness check: warn (don't fail) when the manifest predates changed files.
+  // Skip when we're diffing against the working tree (mtime signal is noisy
+  // during active edits) — only warn when the caller explicitly pinned a head
+  // ref, which is the CI / bench shape where a stale manifest is a real risk.
+  if (opts.head) await warnIfStale(manifestAbs, changedFiles.map((f) => f.path), gitRoot)
 
   // Resolve the SQL dialect: explicit config wins; otherwise auto-detect from
   // the dbt manifest's `adapter_type` (so a BigQuery/Redshift project isn't
@@ -117,8 +246,36 @@ export async function reviewPullRequest(opts: ReviewPullRequestOptions): Promise
 
   // Prefer dbt's COMPILED SQL (target/compiled) for the engine lanes — the clean
   // approach (Datafold/Recce/Fusion all render-then-analyze rather than parse Jinja).
-  const projectName = await dbtProjectName(opts.cwd)
-  const getCompiled = opts.getContent ? undefined : makeCompiledResolver({ cwd: opts.cwd, projectName })
+  // Use `dbtRoot` (the discovered project root when G3 auto-discovery fired,
+  // else opts.cwd) so a subdir invocation still finds `target/compiled/…`
+  // next to the discovered manifest instead of falling back to raw Jinja.
+  const projectName = await dbtProjectName(dbtRoot)
+  // Repo-relative file paths need the git-root → dbt-root prefix stripped
+  // so `packages/dbt/models/foo.sql` resolves to `models/foo.sql` inside the
+  // dbt project. `path.relative` returns "" when dbtRoot === gitRoot (the
+  // repo-root-invoked case) — makeCompiledResolver's `pathPrefix` treats
+  // that as a no-op.
+  //
+  // Canonicalise both roots via `fs.realpath` before computing the relative
+  // path. `gitRoot` from `git rev-parse --show-toplevel` is already
+  // symlink-resolved; `dbtRoot` is not, so on macOS (`/var` → `/private/var`)
+  // or any other symlinked-parent layout the `path.relative` result was a
+  // meaningless climb path (`../../var/...`) that never matched incoming
+  // repo-relative paths, and compiled SQL was silently missed
+  // (cubic-review P2 + kilo suggestion). Falls back gracefully when the
+  // realpath call fails (e.g. path deleted mid-run).
+  let gitRootReal = gitRoot
+  let dbtRootReal = dbtRoot
+  try {
+    gitRootReal = await realpath(gitRoot)
+    dbtRootReal = await realpath(dbtRoot)
+  } catch {
+    /* keep original values on realpath failure */
+  }
+  const pathPrefix = path.relative(gitRootReal, dbtRootReal)
+  const getCompiled = opts.getContent
+    ? undefined
+    : makeCompiledResolver({ cwd: dbtRootReal, projectName, pathPrefix })
 
   return runReview({
     changedFiles,
@@ -135,5 +292,7 @@ export async function reviewPullRequest(opts: ReviewPullRequestOptions): Promise
     aiReview: opts.noAi || config.ai === false ? undefined : runAiReview,
     prTitle: opts.prTitle,
     prBody: opts.prBody,
+    explainTier: opts.explainTier,
+    forceTier: opts.forceTier,
   })
 }
diff --git a/packages/opencode/src/altimate/review/verdict.ts b/packages/opencode/src/altimate/review/verdict.ts
index d499695d9..ef876688f 100644
--- a/packages/opencode/src/altimate/review/verdict.ts
+++ b/packages/opencode/src/altimate/review/verdict.ts
@@ -92,6 +92,13 @@ export const VerdictEnvelope = z.object({
   idealVerdict: Verdict,
   mode: ReviewMode,
   tier: RiskTier,
+  /** G1 — reasons the classifier assigned this tier (only when --explain-tier). */
+  tierReasons: z.array(z.string()).optional(),
+  /** G2 — true when --force-tier bypassed the classifier. Included in signature so
+   *  a tampered envelope claiming natural tier can't fake a forced run. */
+  tierForced: z.boolean().optional(),
+  /** The classifier's original tier before --force-tier overrode it (G2). */
+  tierClassified: RiskTier.optional(),
   findings: z.array(Finding),
   summary: z.object({
     critical: z.number().int().nonnegative(),
@@ -115,6 +122,32 @@ export const VerdictEnvelope = z.object({
     .optional(),
   /** HMAC-SHA256 over the canonical body (added by signEnvelope). */
   signature: z.string().optional(),
+}).superRefine((env, ctx) => {
+  // G2 audit invariant — enforced at the envelope boundary so a hand-built
+  // envelope (bypassing runReview) can't sign inconsistent forced-tier
+  // metadata. When --force-tier is used, BOTH tierForced=true AND
+  // tierClassified must be present (per PR #1027 consensus MINOR #2).
+  const hasForced = env.tierForced === true
+  const hasClassified = env.tierClassified !== undefined
+  if (hasForced !== hasClassified) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message:
+        "tierForced and tierClassified must both be present or both absent: " +
+        `tierForced=${env.tierForced}, tierClassified=${env.tierClassified ?? "undefined"}`,
+      path: ["tierForced"],
+    })
+  }
+  // tierForced: false is not a legitimate state — the flag records
+  // "was --force-tier used?" as a positive marker; false is indistinguishable
+  // from a natural (unforced) run and only adds noise to the canonical body.
+  if (env.tierForced === false) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "tierForced must be true or undefined, not false",
+      path: ["tierForced"],
+    })
+  }
 })
 export type VerdictEnvelope = z.infer<typeof VerdictEnvelope>
 
@@ -127,6 +160,12 @@ export interface BuildEnvelopeInput {
   manifestHash?: string
   generatedAt?: string
   degraded?: boolean
+  /** G1 — classifier reasons for the tier (only surfaced when explainTier=true). */
+  tierReasons?: string[]
+  /** G2 — set when --force-tier was applied. */
+  tierForced?: boolean
+  /** G2 — classifier's original tier before the force override. */
+  tierClassified?: RiskTier
 }
 
 function summarize(findings: Finding[], degraded: boolean): VerdictEnvelope["summary"] {
@@ -147,6 +186,9 @@ export function buildEnvelope(input: BuildEnvelopeInput): VerdictEnvelope {
     idealVerdict: ideal,
     mode: input.mode,
     tier: input.tier,
+    tierReasons: input.tierReasons,
+    tierForced: input.tierForced,
+    tierClassified: input.tierClassified,
     findings: input.findings,
     summary: summarize(input.findings, degraded),
     engine: EngineVersions.parse(input.engine ?? {}),
diff --git a/packages/opencode/src/cli/cmd/review.ts b/packages/opencode/src/cli/cmd/review.ts
index c271dbe5f..2a2f9c07f 100644
--- a/packages/opencode/src/cli/cmd/review.ts
+++ b/packages/opencode/src/cli/cmd/review.ts
@@ -22,9 +22,15 @@ export const ReviewCommand = cmd({
   describe: "review dbt/SQL changes and emit a signed verdict (APPROVE/COMMENT/REQUEST_CHANGES)",
   builder: (yargs) =>
     yargs
+      // Disable yargs' `--no-<option>` auto-negation for this command. Without this,
+      // yargs interprets bare `--no-ai` as "set option `ai` to false" — which is
+      // NOT a declared option, so the command silently falls into the help path
+      // (exit 0, no review runs). With `boolean-negation: false`, `--no-ai` binds
+      // to the declared `noAi` boolean flag as authored. B1 fix, Round 18.
+      .parserConfiguration({ "boolean-negation": false })
       .option("base", { type: "string", describe: "base git ref (default: merge-base with origin/main)" })
       .option("head", { type: "string", describe: "head git ref (default: working tree)" })
-      .option("manifest", { type: "string", describe: "path to dbt manifest.json" })
+      .option("manifest", { type: "string", describe: "path to dbt manifest.json (auto-discovered under target/ when omitted)" })
       .option("mode", {
         type: "string",
         choices: ["comment", "gate"] as const,
@@ -47,9 +53,25 @@ export const ReviewCommand = cmd({
         default: false,
         describe: "disable the advisory LLM reviewer lane (no model calls / cost)",
       })
+      .option("explain-tier", {
+        type: "boolean",
+        default: false,
+        describe: "emit tierReasons[] in the verdict envelope explaining the tier classification",
+      })
+      .option("force-tier", {
+        type: "string",
+        choices: ["trivial", "lite", "full"] as const,
+        describe: "[EXPERIMENTAL / bench debug] override the tier classifier — verdict envelope carries tierForced: true",
+      })
       .option("cwd", { type: "string", describe: "project directory (default: current dir)" }),
   async handler(args) {
     const cwd = (args.cwd as string) || process.cwd()
+    if (args.forceTier) {
+      process.stderr.write(
+        `⚠️  --force-tier=${args.forceTier} is EXPERIMENTAL (bench / debug only). ` +
+          `Classifier bypassed; verdict envelope will carry tierForced: true.\n`,
+      )
+    }
     await bootstrap(cwd, async () => {
       const env = await reviewPullRequest({
         cwd,
@@ -58,11 +80,11 @@ export const ReviewCommand = cmd({
         manifestPath: args.manifest as string | undefined,
         mode: args.mode as ReviewMode | undefined,
         severityThreshold: args.severity as Severity | undefined,
-        // The flag is registered as `--no-ai`, so yargs sets `args.noAi`. No `ai`
-        // option is declared, so `--ai=false` is NOT a supported CLI flag; the
-        // `args.ai === false` check only covers programmatic callers that pass
-        // `ai: false` directly.
+        // With `boolean-negation: false` above, `--no-ai` binds to `noAi` and
+        // the historical `--ai=false` programmatic path stays supported.
         noAi: args.noAi === true || args.ai === false,
+        explainTier: args.explainTier === true,
+        forceTier: args.forceTier as "trivial" | "lite" | "full" | undefined,
       })
 
       if (args.output) await fs.writeFile(args.output as string, JSON.stringify(env, null, 2))
diff --git a/packages/opencode/test/altimate/review-ci.test.ts b/packages/opencode/test/altimate/review-ci.test.ts
index f14705030..7f82d9caf 100644
--- a/packages/opencode/test/altimate/review-ci.test.ts
+++ b/packages/opencode/test/altimate/review-ci.test.ts
@@ -19,6 +19,43 @@ describe("review CLI command", () => {
     expect(ReviewCommand.command).toBe("review")
     expect(typeof ReviewCommand.handler).toBe("function")
   })
+
+  test("boolean-negation:false does not break other declared boolean flags (PR #1027 consensus MINOR #5)", async () => {
+    // The B1 fix disables yargs' `--no-<option>` auto-negation on the review
+    // command via `parserConfiguration({ "boolean-negation": false })`, so
+    // `--no-ai` binds to the declared `noAi` boolean. That setting is
+    // command-global — if a future boolean flag is added, its `--no-<flag>`
+    // form silently changes shape. This regression asserts every currently
+    // declared boolean parses to the expected type + default.
+    const yargsMod = await import("yargs")
+    // Build the command's yargs builder in isolation (no execution) and
+    // check the parsed argv shape for each boolean flag's on/off/default
+    // forms. Uses parseAsync so the whole builder chain runs.
+    const buildBase = () => (ReviewCommand.builder as any)(yargsMod.default([]).exitProcess(false).help(false))
+    const parse = async (args: string[]) => {
+      const parsed = await buildBase().parseAsync(args)
+      return parsed
+    }
+
+    const flags: Array<{ name: string; long: string; camel: string; default?: boolean }> = [
+      { name: "json", long: "--json", camel: "json", default: false },
+      { name: "post", long: "--post", camel: "post", default: false },
+      { name: "no-ai", long: "--no-ai", camel: "noAi", default: false },
+      { name: "explain-tier", long: "--explain-tier", camel: "explainTier", default: false },
+    ]
+
+    for (const f of flags) {
+      // Default (flag absent).
+      const defaultParsed = await parse([])
+      expect((defaultParsed as any)[f.camel]).toBe(f.default ?? false)
+      // Bare form flips to true (the whole point of B1).
+      const bareParsed = await parse([f.long])
+      expect((bareParsed as any)[f.camel]).toBe(true)
+      // Explicit `=false` still works.
+      const explicitFalse = await parse([`${f.long}=false`])
+      expect((explicitFalse as any)[f.camel]).toBe(false)
+    }
+  })
 })
 
 describe("resolveGitHubTarget", () => {
diff --git a/packages/opencode/test/altimate/review-dbt-patterns.test.ts b/packages/opencode/test/altimate/review-dbt-patterns.test.ts
index 9fbbae2b9..509586309 100644
--- a/packages/opencode/test/altimate/review-dbt-patterns.test.ts
+++ b/packages/opencode/test/altimate/review-dbt-patterns.test.ts
@@ -5,6 +5,7 @@ import {
   DEFAULT_RUBRIC,
   type ChangedFile,
 } from "../../src/altimate/review"
+import { dedupe } from "../../src/altimate/review/finding"
 
 // Build a modified-model ChangedFile from a new-SQL body + a synthetic diff
 // where the given lines are "added" (prefixed with +).
@@ -158,6 +159,630 @@ describe("dbt-patterns detectors", () => {
     expect(f.length).toBe(0)
   })
 
+  // ------------------------------------------------------------------------
+  // Post-R18 review follow-ups: structural YAML path + sibling-column edge case
+  // + model-level tests + fallback shape. The rewritten detector prefers full
+  // old/new file content; these tests validate both paths.
+  // ------------------------------------------------------------------------
+
+  test("schema.yml (structural): unique removed from one column while sibling keeps it → 1 finding on the affected column", () => {
+    const oldContent = `version: 2
+models:
+  - name: customers
+    columns:
+      - name: customer_id
+        tests: [unique, not_null]
+      - name: email
+        tests: [not_null]
+  - name: orders
+    columns:
+      - name: order_id
+        tests: [unique, not_null]
+`
+    const newContent = `version: 2
+models:
+  - name: customers
+    columns:
+      - name: customer_id
+        tests: []
+      - name: email
+        tests: [not_null]
+  - name: orders
+    columns:
+      - name: order_id
+        tests: [unique, not_null]
+`
+    const f = detectSchemaYmlPatterns(
+      { path: "models/marts/_models.yml", status: "modified", diff: undefined },
+      DEFAULT_RUBRIC,
+      { oldContent, newContent },
+    )
+    // 2 removals on customers.customer_id (unique + not_null), 0 on orders/email
+    expect(f.length).toBe(2)
+    expect(has(f, "test_coverage", "warning")).toBe(true)
+    // At least one finding names customers.customer_id specifically
+    expect(f.some((x) => (x.title || "").includes("customers.customer_id"))).toBe(true)
+    // No finding attributed to orders.order_id (sibling still has `unique`)
+    expect(f.some((x) => (x.title || "").includes("orders.order_id"))).toBe(false)
+  })
+
+  test("schema.yml (structural): model-level unique test removed → 1 finding with model-level attribution", () => {
+    const oldContent = `version: 2
+models:
+  - name: customers
+    tests:
+      - unique
+    columns:
+      - name: customer_id
+`
+    const newContent = `version: 2
+models:
+  - name: customers
+    columns:
+      - name: customer_id
+`
+    const f = detectSchemaYmlPatterns(
+      { path: "models/marts/_models.yml", status: "modified", diff: undefined },
+      DEFAULT_RUBRIC,
+      { oldContent, newContent },
+    )
+    expect(f.length).toBe(1)
+    expect(f[0].category).toBe("test_coverage")
+    expect(f[0].severity).toBe("warning")
+    expect((f[0].title || "").includes("model-level")).toBe(true)
+    // Attribution flag in evidence lets downstream see it wasn't column-scoped
+    const evResult = (f[0].evidence?.result || {}) as Record<string, unknown>
+    expect(evResult.attribution).toBe("model-level")
+  })
+
+  test("schema.yml (structural): dropping BOTH of two relationships on one column emits TWO findings (PR #1027 consensus MINOR #4)", () => {
+    // Regression: with `(entity, column, test)` keying alone, two
+    // `relationships` tests on the same column collapsed to a single set
+    // entry — dropping both produced ONE finding, and dropping either one
+    // in isolation produced ZERO (because the surviving one still matched
+    // the collapsed key). The extractor now discriminates by (to, field)
+    // so distinct relationships on one column stay distinct.
+    const oldContent = `version: 2
+models:
+  - name: orders
+    columns:
+      - name: customer_id
+        tests:
+          - relationships:
+              to: ref('customers')
+              field: customer_id
+          - relationships:
+              to: ref('legacy_customers')
+              field: id
+`
+    const newContent = `version: 2
+models:
+  - name: orders
+    columns:
+      - name: customer_id
+        tests: []
+`
+    const f = detectSchemaYmlPatterns(
+      { path: "models/schema.yml", status: "modified", diff: undefined },
+      DEFAULT_RUBRIC,
+      { oldContent, newContent },
+    )
+    // Both relationships removals surface separately.
+    expect(f.length).toBe(2)
+    // Distinct fingerprint ids so the global dedupe keeps them.
+    expect(new Set(f.map((x) => x.id)).size).toBe(2)
+    // Display copy stays clean — no raw discriminator control chars leak.
+    for (const finding of f) {
+      expect(finding.title).toContain("relationships")
+      expect(finding.title).not.toContain("\x01")
+      expect(finding.title).not.toContain("\x02")
+      expect(finding.body).not.toContain("\x01")
+      expect(finding.body).not.toContain("\x02")
+    }
+  })
+
+  test("schema.yml (structural): relationships discriminator survives colons in `to`/`field` args (codex round-5 minor)", () => {
+    // Codex flagged that a `:`-joined discriminator would collide when
+    // either arg contains `:` (e.g. `to='a:b', field='c'` vs `to='a',
+    // field='b:c'`). Discriminator now retains the internal `\x02`
+    // separator inside ruleKey (hashed, not displayed) so distinct
+    // (to, field) tuples never share a fingerprint.
+    const oldContent = `version: 2
+models:
+  - name: orders
+    columns:
+      - name: customer_id
+        tests:
+          - relationships:
+              to: "ref('a:b')"
+              field: c
+          - relationships:
+              to: ref('a')
+              field: "b:c"
+`
+    const newContent = `version: 2
+models:
+  - name: orders
+    columns:
+      - name: customer_id
+        tests: []
+`
+    const f = detectSchemaYmlPatterns(
+      { path: "models/schema.yml", status: "modified", diff: undefined },
+      DEFAULT_RUBRIC,
+      { oldContent, newContent },
+    )
+    // Two distinct removals, distinct fingerprints (would collide on a
+    // colon-joined tag).
+    expect(f.length).toBe(2)
+    expect(new Set(f.map((x) => x.id)).size).toBe(2)
+    // Display copy still stripped of raw control chars.
+    for (const finding of f) {
+      expect(finding.title).not.toContain("\x01")
+      expect(finding.body).not.toContain("\x02")
+    }
+  })
+
+  test("schema.yml (structural): dropping ONE of TWO relationships on one column surfaces (PR #1027 consensus MINOR #4 companion)", () => {
+    // Companion regression: with pre-fix keying, dropping one relationship
+    // while keeping the other left the collapsed key still in newSet, so
+    // no removal was reported. Now the (to, field) discriminator makes the
+    // dropped one distinct — a finding surfaces.
+    const oldContent = `version: 2
+models:
+  - name: orders
+    columns:
+      - name: customer_id
+        tests:
+          - relationships:
+              to: ref('customers')
+              field: customer_id
+          - relationships:
+              to: ref('legacy_customers')
+              field: id
+`
+    const newContent = `version: 2
+models:
+  - name: orders
+    columns:
+      - name: customer_id
+        tests:
+          - relationships:
+              to: ref('customers')
+              field: customer_id
+`
+    const f = detectSchemaYmlPatterns(
+      { path: "models/schema.yml", status: "modified", diff: undefined },
+      DEFAULT_RUBRIC,
+      { oldContent, newContent },
+    )
+    expect(f.length).toBe(1)
+    expect(f[0].title).toContain("relationships")
+    expect(f[0].title).not.toContain("\x01")
+    expect(f[0].body).not.toContain("\x01")
+  })
+
+  test("schema.yml (structural): block-form relationships removal is detected", () => {
+    const oldContent = `version: 2
+models:
+  - name: orders
+    columns:
+      - name: customer_id
+        tests:
+          - relationships:
+              to: ref('customers')
+              field: customer_id
+`
+    const newContent = `version: 2
+models:
+  - name: orders
+    columns:
+      - name: customer_id
+        tests: []
+`
+    const f = detectSchemaYmlPatterns(
+      { path: "models/schema.yml", status: "modified", diff: undefined },
+      DEFAULT_RUBRIC,
+      { oldContent, newContent },
+    )
+    expect(f.length).toBe(1)
+    expect((f[0].title || "").includes("relationships")).toBe(true)
+  })
+
+  test("schema.yml (structural): data_tests (dbt 1.8+ alias) is recognized", () => {
+    const oldContent = `version: 2
+models:
+  - name: customers
+    columns:
+      - name: customer_id
+        data_tests: [unique, not_null]
+`
+    const newContent = `version: 2
+models:
+  - name: customers
+    columns:
+      - name: customer_id
+        data_tests: []
+`
+    const f = detectSchemaYmlPatterns(
+      { path: "models/schema.yml", status: "modified", diff: undefined },
+      DEFAULT_RUBRIC,
+      { oldContent, newContent },
+    )
+    expect(f.length).toBe(2)
+  })
+
+  test("schema.yml (structural): source column test removal is detected", () => {
+    const oldContent = `version: 2
+sources:
+  - name: raw
+    tables:
+      - name: users
+        columns:
+          - name: id
+            tests: [unique, not_null]
+`
+    const newContent = `version: 2
+sources:
+  - name: raw
+    tables:
+      - name: users
+        columns:
+          - name: id
+            tests: []
+`
+    const f = detectSchemaYmlPatterns(
+      { path: "models/sources.yml", status: "modified", diff: undefined },
+      DEFAULT_RUBRIC,
+      { oldContent, newContent },
+    )
+    expect(f.length).toBe(2)
+    // Source table gets qualified as `source.table` in the model field
+    expect(f.some((x) => (x.title || "").includes("raw.users.id"))).toBe(true)
+  })
+
+  test("schema.yml (structural): added file (status=added, no oldContent) surfaces no removal findings", () => {
+    const newContent = `version: 2
+models:
+  - name: customers
+    columns:
+      - name: customer_id
+        tests: [unique, not_null]
+`
+    const f = detectSchemaYmlPatterns(
+      { path: "models/schema.yml", status: "added", diff: undefined },
+      DEFAULT_RUBRIC,
+      { oldContent: undefined, newContent },
+    )
+    expect(f.length).toBe(0)
+  })
+
+  test("schema.yml (structural): renamed file with removed test still surfaces finding", () => {
+    // Regression guard: earlier code only fetched oldContent when
+    // status === "modified", so a rename that also dropped a guardrail test
+    // silently bypassed the detector.
+    const oldContent = `version: 2
+models:
+  - name: customers
+    columns:
+      - name: customer_id
+        tests: [unique, not_null]
+`
+    const newContent = `version: 2
+models:
+  - name: customers
+    columns:
+      - name: customer_id
+        tests: []
+`
+    const f = detectSchemaYmlPatterns(
+      {
+        path: "models/marts/_models.yml",
+        status: "renamed",
+        oldPath: "models/_models.yml",
+        diff: undefined,
+      },
+      DEFAULT_RUBRIC,
+      { oldContent, newContent },
+    )
+    expect(f.length).toBe(2)
+    expect(has(f, "test_coverage", "warning")).toBe(true)
+  })
+
+  test("schema.yml (structural): modified file with oldContent=undefined falls back to diff detection", () => {
+    // When the content resolver couldn't read the old side (e.g. transient
+    // git failure) on a MODIFIED file, we must NOT treat the situation as
+    // "added file, nothing removed" — the diff still contains real removed
+    // lines. Fall back to line-based detection instead of silently dropping.
+    const f = detectSchemaYmlPatterns(
+      {
+        path: "models/marts/_models.yml",
+        status: "modified",
+        diff: "-          - unique\n-          - not_null",
+      },
+      DEFAULT_RUBRIC,
+      { oldContent: undefined, newContent: "version: 2\nmodels: []\n" },
+    )
+    expect(has(f, "test_coverage")).toBe(true)
+  })
+
+  test("schema.yml (fallback): diff-only path still surfaces removal (existing test's shape)", () => {
+    // Exercises the fallback line-based detection when the orchestrator can't
+    // supply file content (e.g. offline CI diffs).
+    const f = detectSchemaYmlPatterns(
+      {
+        path: "models/marts/_models.yml",
+        status: "modified",
+        diff: "-          - unique\n-          - not_null",
+      },
+      DEFAULT_RUBRIC,
+    )
+    // At least one test_coverage finding surfaces so a customer isn't blind to
+    // removed guardrails just because the content resolver wasn't wired.
+    expect(has(f, "test_coverage")).toBe(true)
+  })
+
+  test("schema.yml (fallback): distinct removals of same test type on different columns each surface", () => {
+    // Regression guard for the earlier dedup bug: (model="", column="", test)
+    // key reduced to just `test` and silently collapsed distinct removals of
+    // the same test type on different columns. The fallback path now emits
+    // one finding per removed test-line.
+    const f = detectSchemaYmlPatterns(
+      {
+        path: "models/marts/_models.yml",
+        status: "modified",
+        // Two `- unique` removed lines representing two different columns
+        // losing the `unique` test in the same PR.
+        diff: "-          - unique\n-          - not_null\n-          - unique\n-          - not_null",
+      },
+      DEFAULT_RUBRIC,
+    )
+    // 4 removed test-lines → 4 findings (fallback preserves per-line detail).
+    expect(f.length).toBe(4)
+    expect(has(f, "test_coverage", "warning")).toBe(true)
+  })
+
+  test("schema.yml (fallback): distinct removals survive the global fingerprint dedupe", () => {
+    // Integration-shape guard: the detector-level test above returns 4
+    // findings, but `runReview` runs a global `dedupe(findings)` step that
+    // fingerprints by (category, file, model, column, ruleKey). If ruleKey
+    // only varies by test-name for the fallback path, two `- unique`
+    // removals share a fingerprint and get merged post-detector. This test
+    // pipes the detector's output through `dedupe` to prove distinct
+    // removals actually reach the user.
+    const f = detectSchemaYmlPatterns(
+      {
+        path: "models/marts/_models.yml",
+        status: "modified",
+        diff: "-          - unique\n-          - not_null\n-          - unique\n-          - not_null",
+      },
+      DEFAULT_RUBRIC,
+    )
+    const deduped = dedupe(f)
+    expect(deduped.length).toBe(4)
+    // All 4 must be test_coverage findings; `unique` removals are `warning`,
+    // and fallback `not_null` (no column attribution) is `suggestion` because
+    // we can't tell if it was on an id/key column.
+    expect(deduped.every((x) => x.category === "test_coverage")).toBe(true)
+    // The 4 fingerprints must be distinct (was the exact regression: without
+    // an occurrence-index discriminator in ruleKey, the two `- unique` and
+    // two `- not_null` removals collapse to 2 findings after dedupe).
+    expect(new Set(deduped.map((x) => x.id)).size).toBe(4)
+    // 2 `- unique` (warning) + 2 `- not_null` (suggestion) — the exact split.
+    expect(deduped.filter((x) => x.severity === "warning").length).toBe(2)
+    expect(deduped.filter((x) => x.severity === "suggestion").length).toBe(2)
+  })
+
+  test("schema.yml (structural): distinct column removals also survive global dedupe", () => {
+    // Structural attribution provides (model.column.test) uniqueness natively,
+    // but the guard is worth codifying so future rule-key changes don't
+    // silently regress into the fingerprint-collision failure mode.
+    const oldContent = `version: 2
+models:
+  - name: customers
+    columns:
+      - name: customer_id
+        tests: [unique]
+      - name: email
+        tests: [unique]
+`
+    const newContent = `version: 2
+models:
+  - name: customers
+    columns:
+      - name: customer_id
+        tests: []
+      - name: email
+        tests: []
+`
+    const f = detectSchemaYmlPatterns(
+      { path: "models/marts/_models.yml", status: "modified", diff: undefined },
+      DEFAULT_RUBRIC,
+      { oldContent, newContent },
+    )
+    const deduped = dedupe(f)
+    expect(deduped.length).toBe(2)
+    expect(new Set(deduped.map((x) => x.id)).size).toBe(2)
+  })
+
+  test("snapshot yml property file (structural): removed test surfaces finding", () => {
+    // Regression: snapshot YAML property files were previously classified as
+    // `snapshot` kind (blocking the `schema_yml` gate in the orchestrator).
+    // Now `.yml` files under snapshots/ classify as `schema_yml` while `.sql`
+    // snapshots stay `snapshot` (tier-forcing catalog rules unchanged).
+    const oldContent = `version: 2
+snapshots:
+  - name: orders_snapshot
+    columns:
+      - name: order_id
+        tests: [unique, not_null]
+`
+    const newContent = `version: 2
+snapshots:
+  - name: orders_snapshot
+    columns:
+      - name: order_id
+        tests: []
+`
+    const f = detectSchemaYmlPatterns(
+      { path: "snapshots/orders_snapshot.yml", status: "modified", diff: undefined },
+      DEFAULT_RUBRIC,
+      { oldContent, newContent },
+    )
+    expect(f.length).toBe(2)
+    expect(has(f, "test_coverage", "warning")).toBe(true)
+  })
+
+  test("schema.yml summary: multi-model removals emit ONE aggregate summary line", () => {
+    // Regression guard: the aggregate "This PR removes N tests total on
+    // model(s) X, Y" summary was previously appended once per model, so a
+    // diff touching two models produced two copies of the same summary in
+    // separate findings. Now emitted once per FILE on the first finding.
+    const oldContent = `version: 2
+models:
+  - name: customers
+    columns:
+      - name: customer_id
+        tests: [unique]
+  - name: orders
+    columns:
+      - name: order_id
+        tests: [unique]
+`
+    const newContent = `version: 2
+models:
+  - name: customers
+    columns:
+      - name: customer_id
+        tests: []
+  - name: orders
+    columns:
+      - name: order_id
+        tests: []
+`
+    const f = detectSchemaYmlPatterns(
+      { path: "models/schema.yml", status: "modified", diff: undefined },
+      DEFAULT_RUBRIC,
+      { oldContent, newContent },
+    )
+    expect(f.length).toBe(2)
+    // Only ONE finding body should contain the aggregate "N data tests"
+    // summary line; the other should be plain. Wording is per-schema-file
+    // scoped (PR #1027 consensus MINOR #3): "This schema file drops N data
+    // tests" so reviewers don't misread it as a PR-wide total on multi-file
+    // diffs.
+    const summaryCount = f.filter((x) => (x.body || "").includes("This schema file drops")).length
+    expect(summaryCount).toBe(1)
+    const withSummary = f.find((x) => (x.body || "").includes("This schema file drops"))!
+    // Explicitly reject the old ambiguous PR-wide wording.
+    expect(withSummary.body).not.toContain("This PR removes")
+    expect(withSummary.body).not.toContain("in total")
+    // And the mentioned model list should include BOTH models it touched.
+    expect(withSummary.body).toContain("`customers`")
+    expect(withSummary.body).toContain("`orders`")
+  })
+
+  test("deleted schema.yml: every prior test surfaces as a removal finding (cubic-review P2)", () => {
+    // Regression: deleting a whole schema.yml removes every test declared in
+    // it — arguably a bigger removal than dropping a single test. Previously
+    // the detector early-returned `[]` for `status === "deleted"`, so the
+    // deletion went unnoticed. Now the detector diffs the old document against
+    // an empty new document.
+    const oldContent = `version: 2
+models:
+  - name: customers
+    columns:
+      - name: customer_id
+        tests: [unique, not_null]
+      - name: email
+        tests: [not_null]
+  - name: orders
+    columns:
+      - name: order_id
+        tests: [unique]
+`
+    const f = detectSchemaYmlPatterns(
+      { path: "models/marts/_models.yml", status: "deleted", diff: undefined },
+      DEFAULT_RUBRIC,
+      // Only oldContent is available for a deleted file; newContent is undefined
+      // because git-show at HEAD would fail.
+      { oldContent, newContent: undefined },
+    )
+    // 4 removals: customers.customer_id.unique, customers.customer_id.not_null,
+    // customers.email.not_null, orders.order_id.unique
+    expect(f.length).toBe(4)
+    expect(has(f, "test_coverage", "warning")).toBe(true)
+    // Structured attribution surfaces on the top-level Finding, not just in
+    // evidence.result (cubic-review P3).
+    const byModel = f.filter((x) => x.model === "customers")
+    expect(byModel.length).toBe(3)
+    const byColumn = f.filter((x) => x.column === "email")
+    expect(byColumn.length).toBe(1)
+  })
+
+  test("deleted schema.yml without oldContent: no findings (safe degrade)", () => {
+    // Without the old side, we can't know what tests to flag as removed.
+    // The detector should degrade to `[]` rather than fabricating findings.
+    const f = detectSchemaYmlPatterns(
+      { path: "models/marts/_models.yml", status: "deleted", diff: undefined },
+      DEFAULT_RUBRIC,
+      { oldContent: undefined, newContent: undefined },
+    )
+    expect(f.length).toBe(0)
+  })
+
+  test("deleted schema.yml with unparsable oldContent + deletion diff → fallback surfaces removals", () => {
+    // Structural path can't commit (old YAML fails to parse), so the diff-only
+    // fallback runs. Confirms: unparsable-old → fallback, not silent drop.
+    const oldContent = `version: 2
+models:
+  - name: customers
+    columns:
+      - name: customer_id
+        tests:
+          - not_null   # <-- unterminated block below causes parse failure
+    tests: [
+`
+    // Diff uses the block-list shape the fallback regex targets
+    // (`-      - unique` / `-      - not_null`).
+    const diff = `--- a/models/marts/_models.yml
++++ /dev/null
+@@ -1,8 +0,0 @@
+-version: 2
+-models:
+-  - name: customers
+-    columns:
+-      - name: customer_id
+-        tests:
+-          - unique
+-          - not_null
+`
+    const f = detectSchemaYmlPatterns(
+      { path: "models/marts/_models.yml", status: "deleted", diff },
+      DEFAULT_RUBRIC,
+      { oldContent, newContent: undefined },
+    )
+    // Diff-only fallback picks up the removed `- unique` and `- not_null`
+    // lines, so we still emit at least one removal finding rather than silently
+    // dropping when the structural path couldn't commit.
+    expect(f.length).toBeGreaterThan(0)
+    expect(has(f, "test_coverage", "warning")).toBe(true)
+  })
+
+  test("deleted empty schema.yml: no fabricated findings (locks in precision)", () => {
+    // Old side parses cleanly but declares no tests. Ensures the structural
+    // loop doesn't fabricate findings when oldSet is empty.
+    const oldContent = `version: 2
+models: []
+`
+    const f = detectSchemaYmlPatterns(
+      { path: "models/marts/_models.yml", status: "deleted", diff: undefined },
+      DEFAULT_RUBRIC,
+      { oldContent, newContent: undefined },
+    )
+    expect(f.length).toBe(0)
+  })
+
   test("benign additive column produces NO dbt-pattern finding (precision)", () => {
     const sql = `select id, upper(status) as status_upper from {{ ref('x') }}`
     const f = detectModelPatterns(
diff --git a/packages/opencode/test/altimate/review-run-stale.test.ts b/packages/opencode/test/altimate/review-run-stale.test.ts
new file mode 100644
index 000000000..2e097df94
--- /dev/null
+++ b/packages/opencode/test/altimate/review-run-stale.test.ts
@@ -0,0 +1,51 @@
+import { describe, test, expect } from "bun:test"
+import { isManifestAffecting } from "../../src/altimate/review/run"
+
+/**
+ * Guards on `warnIfStale`'s changed-file filter. The stale warning gates on a
+ * changed file having an mtime newer than the manifest; iterating every path
+ * in the diff (including README.md, package.json, .github/*) triggered
+ * false-positive warnings on unrelated repo activity. The filter admits only
+ * dbt-relevant paths.
+ */
+describe("isManifestAffecting", () => {
+  // ADMITTED — these should trigger a stale-manifest warning when newer than
+  // the compiled manifest.
+  test.each([
+    "models/marts/customers.sql",
+    "models/staging/stg_orders.sql",
+    "models/schema.yml",
+    "models/marts/_models.yml",
+    "models/customers.md", // dbt docs block
+    "seeds/lookup.csv",
+    "snapshots/orders_snapshot.sql",
+    "snapshots/orders_snapshot.yml",
+    "macros/generate_schema_name.sql",
+    "tests/singular/no_orphan_orders.sql",
+    "analyses/gross_margin.sql",
+    "dbt_project.yml",
+    "packages.yml",
+    "profiles.yml",
+    "dependencies.yml",
+  ])("admits: %s", (rel) => {
+    expect(isManifestAffecting(rel)).toBe(true)
+  })
+
+  // REJECTED — these should NOT trigger a stale-manifest warning because
+  // touching them doesn't invalidate the compiled dbt manifest.
+  test.each([
+    "README.md",
+    "CHANGELOG.md",
+    "package.json",
+    ".github/workflows/ci.yml",
+    ".gitignore",
+    "docs/README.md",
+    "Dockerfile",
+    "scripts/deploy.sh",
+    "target/manifest.json", // the manifest itself
+    "target/compiled/foo.sql", // compiled artifacts
+    "tests/e2e/setup.ts",
+  ])("rejects: %s", (rel) => {
+    expect(isManifestAffecting(rel)).toBe(false)
+  })
+})
diff --git a/packages/opencode/test/altimate/review-subdir-invocation.test.ts b/packages/opencode/test/altimate/review-subdir-invocation.test.ts
new file mode 100644
index 000000000..14fe9543b
--- /dev/null
+++ b/packages/opencode/test/altimate/review-subdir-invocation.test.ts
@@ -0,0 +1,235 @@
+import { describe, test, expect } from "bun:test"
+import { promises as fs } from "node:fs"
+import path from "node:path"
+import { tmpdir } from "node:os"
+import { execFile } from "node:child_process"
+import { promisify } from "node:util"
+import { gitRepoRoot, makeContentResolver } from "../../src/altimate/review/git"
+import { makeCompiledResolver } from "../../src/altimate/review/compiled"
+
+const exec = promisify(execFile)
+
+/**
+ * Regression coverage for the subdir-invocation content-resolution MAJOR
+ * (PR #1027 consensus review, finding 1). The three affected code paths —
+ * `makeContentResolver` working-tree read, `warnIfStale` file existence check,
+ * and `makeCompiledResolver` compiled-SQL lookup — all previously joined
+ * repo-relative paths (from `git diff --name-status`) with the caller's
+ * `opts.cwd`, silently ENOENT-ing when the CLI was invoked from a subdir.
+ *
+ * These tests build a small git repo in a temp dir, invoke resolvers from a
+ * subdir, and assert content is still found via the resolved git top-level.
+ */
+
+async function mkTempRepo(): Promise<{ root: string; sub: string }> {
+  const root = await fs.mkdtemp(path.join(tmpdir(), "review-subdir-invocation-"))
+  const sub = path.join(root, "packages", "dbt")
+  await fs.mkdir(sub, { recursive: true })
+  await fs.mkdir(path.join(sub, "models", "marts"), { recursive: true })
+  await fs.writeFile(path.join(sub, "models", "marts", "customers.sql"), "-- customers content\n")
+  await exec("git", ["init", "-q"], { cwd: root })
+  await exec("git", ["config", "user.email", "t@test"], { cwd: root })
+  await exec("git", ["config", "user.name", "t"], { cwd: root })
+  await exec("git", ["add", "."], { cwd: root })
+  await exec("git", ["commit", "-qm", "seed"], { cwd: root })
+  return { root, sub }
+}
+
+describe("R20: subdir-invocation content resolution (PR #1027 consensus MAJOR)", () => {
+  test("gitRepoRoot resolves the same top-level from repo root and from a subdir", async () => {
+    const { root, sub } = await mkTempRepo()
+    const fromRoot = await gitRepoRoot(root)
+    const fromSub = await gitRepoRoot(sub)
+    // `git rev-parse --show-toplevel` may emit a path with a `/private` prefix
+    // on macOS (symlink resolution); compare via realpath so the test is
+    // portable across platforms.
+    expect(await fs.realpath(fromRoot!)).toBe(await fs.realpath(root))
+    expect(await fs.realpath(fromSub!)).toBe(await fs.realpath(root))
+  })
+
+  test("gitRepoRoot returns undefined outside a git repo", async () => {
+    const dir = await fs.mkdtemp(path.join(tmpdir(), "not-a-repo-"))
+    const r = await gitRepoRoot(dir)
+    expect(r).toBeUndefined()
+  })
+
+  test("makeContentResolver working-tree branch reads via gitRoot when invoked from subdir", async () => {
+    const { root, sub } = await mkTempRepo()
+    // Simulating the CI-side path where a caller invokes the review from a
+    // subdir (`sub`). The gitRoot option lets working-tree reads use the
+    // resolved top-level.
+    const resolver = makeContentResolver({ base: "HEAD", cwd: sub, gitRoot: root })
+    const content = await resolver("packages/dbt/models/marts/customers.sql", "new")
+    expect(content).toBe("-- customers content\n")
+  })
+
+  test("makeContentResolver without gitRoot falls back to opts.cwd (legacy behavior)", async () => {
+    // When gitRoot is omitted, working-tree reads join with opts.cwd. When
+    // the CLI is invoked from the repo root this is correct; from a subdir
+    // it silently ENOENTs. Regression guard: the fallback path is
+    // exercised (returns undefined without throwing) so the legacy call
+    // sites still work.
+    const { root, sub } = await mkTempRepo()
+    const resolver = makeContentResolver({ base: "HEAD", cwd: sub })
+    // Subdir cwd + repo-relative file = path-doubling → ENOENT → undefined.
+    const missing = await resolver("packages/dbt/models/marts/customers.sql", "new")
+    expect(missing).toBeUndefined()
+    // From the repo root the same file is found (baseline check).
+    const found = await makeContentResolver({ base: "HEAD", cwd: root })(
+      "packages/dbt/models/marts/customers.sql",
+      "new",
+    )
+    expect(found).toBe("-- customers content\n")
+  })
+
+  test("makeCompiledResolver strips the git-root → dbt-root pathPrefix", async () => {
+    // Simulate a monorepo where dbt lives at packages/dbt/ and compiled SQL
+    // is written by `dbt compile` to packages/dbt/target/compiled/<project>/.
+    // File paths from `git diff --name-status` are repo-root relative
+    // (packages/dbt/models/marts/foo.sql). Without prefix-stripping the
+    // resolver looks for target/compiled/<project>/packages/dbt/models/…
+    // (wrong: nested duplication) and misses the compiled artifact.
+    const { root } = await mkTempRepo()
+    const dbtRoot = path.join(root, "packages", "dbt")
+    const project = "acme"
+    const compiledPath = path.join(dbtRoot, "target", "compiled", project, "models", "marts", "customers.sql")
+    await fs.mkdir(path.dirname(compiledPath), { recursive: true })
+    await fs.writeFile(compiledPath, "-- compiled customers\n")
+
+    const resolver = makeCompiledResolver({
+      cwd: dbtRoot,
+      projectName: project,
+      pathPrefix: "packages/dbt",
+    })
+    const content = await resolver("packages/dbt/models/marts/customers.sql", "new")
+    expect(content).toBe("-- compiled customers\n")
+  })
+
+  test("makeCompiledResolver pathPrefix is a no-op when unset (repo-root-invoked case)", async () => {
+    const { root } = await mkTempRepo()
+    const project = "acme"
+    const compiledPath = path.join(root, "target", "compiled", project, "models", "marts", "customers.sql")
+    await fs.mkdir(path.dirname(compiledPath), { recursive: true })
+    await fs.writeFile(compiledPath, "-- compiled at root\n")
+
+    const resolver = makeCompiledResolver({ cwd: root, projectName: project })
+    const content = await resolver("models/marts/customers.sql", "new")
+    expect(content).toBe("-- compiled at root\n")
+  })
+
+  test("makeCompiledResolver pathPrefix does NOT strip when path doesn't start with prefix", async () => {
+    // Precision guard: a file outside the prefixed subtree must remain
+    // untouched. Repo-relative `docs/foo.md` with prefix `packages/dbt`
+    // → still `docs/foo.md` (no lookup match, returns undefined).
+    const { root } = await mkTempRepo()
+    const resolver = makeCompiledResolver({
+      cwd: path.join(root, "packages", "dbt"),
+      projectName: "acme",
+      pathPrefix: "packages/dbt",
+    })
+    const content = await resolver("docs/foo.md", "new")
+    expect(content).toBeUndefined()
+  })
+
+  test("makeCompiledResolver pathPrefix normalises Windows backslashes to forward slashes (codex round-5 HIGH)", async () => {
+    // `path.relative()` on Windows returns `packages\dbt` while git diff paths
+    // are always POSIX-separated. If the resolver didn't normalise the prefix,
+    // no repo-relative file path would match it and compiled SQL would be
+    // silently missed on Windows monorepos.
+    const { root } = await mkTempRepo()
+    const dbtRoot = path.join(root, "packages", "dbt")
+    const project = "acme"
+    const compiledPath = path.join(dbtRoot, "target", "compiled", project, "models", "customers.sql")
+    await fs.mkdir(path.dirname(compiledPath), { recursive: true })
+    await fs.writeFile(compiledPath, "-- compiled via backslash prefix\n")
+
+    // Simulate the Windows caller: pathPrefix contains `\` separators; the
+    // repo-relative file path from `git diff` still uses `/`.
+    const resolver = makeCompiledResolver({
+      cwd: dbtRoot,
+      projectName: project,
+      pathPrefix: "packages\\dbt",
+    })
+    const content = await resolver("packages/dbt/models/customers.sql", "new")
+    expect(content).toBe("-- compiled via backslash prefix\n")
+  })
+
+  test("makeContentResolver refuses to read a repo file whose realpath escapes the git root (bot-review security)", async () => {
+    // coderabbit + cubic P2 — a tracked symlink that points outside the
+    // repo (e.g. `models/evil.sql → /etc/passwd`) would otherwise be
+    // followed and leak external content into the review pipeline. The
+    // containment check via realpath rejects any target whose resolved
+    // path is not inside the resolved repo root.
+    const { root } = await mkTempRepo()
+    // Create a target outside the repo, then a symlink inside the repo
+    // pointing to it.
+    const outside = await fs.mkdtemp(path.join(tmpdir(), "outside-repo-"))
+    const secret = path.join(outside, "secret.sql")
+    await fs.writeFile(secret, "SECRET CONTENT\n")
+    const evilPath = path.join(root, "packages", "dbt", "models", "marts", "evil.sql")
+    await fs.symlink(secret, evilPath)
+
+    const resolver = makeContentResolver({ base: "HEAD", cwd: root, gitRoot: root })
+    // Reading the symlink target must be refused (returns undefined) —
+    // it must NOT leak the secret file contents.
+    const content = await resolver("packages/dbt/models/marts/evil.sql", "new")
+    expect(content).toBeUndefined()
+
+    // Sanity: a regular tracked file inside the repo is still readable.
+    const good = await resolver("packages/dbt/models/marts/customers.sql", "new")
+    expect(good).toBe("-- customers content\n")
+  })
+
+  test("gitRepoRoot preserves legitimate leading/trailing spaces in the path (bot-review P3)", async () => {
+    // cubic P3 — `.trim()` on the git output stripped path characters
+    // (leading spaces are legitimate on macOS temp dirs like `/private/…`
+    // and on Windows). Now we strip only the git-emitted `\r?\n`
+    // terminator. Simulate a git output with only a newline terminator and
+    // no path whitespace — the result must equal the pre-terminator body.
+    // (Building an actual repo at a whitespace path is filesystem-touchy
+    // across platforms; this test exercises the string handling
+    // behaviorally via the actual git output.)
+    const { root } = await mkTempRepo()
+    const r = await gitRepoRoot(root)
+    // Verify the returned value doesn't have trailing newline chars.
+    expect(r?.endsWith("\n")).toBe(false)
+    expect(r?.endsWith("\r")).toBe(false)
+    // And that r is still a valid path (matches real repo).
+    expect(await fs.realpath(r!)).toBe(await fs.realpath(root))
+  })
+
+  test("makeCompiledResolver refuses a compiled symlink escaping the compiled root (bot-review security)", async () => {
+    // Same containment check applied to compiled SQL lookup — a symlinked
+    // compiled artifact pointing outside `target/compiled/<project>/`
+    // must not be read.
+    const { root } = await mkTempRepo()
+    const dbtRoot = path.join(root, "packages", "dbt")
+    const project = "acme"
+    const compiledDir = path.join(dbtRoot, "target", "compiled", project, "models", "marts")
+    await fs.mkdir(compiledDir, { recursive: true })
+    const outside = await fs.mkdtemp(path.join(tmpdir(), "outside-compiled-"))
+    const secret = path.join(outside, "secret.sql")
+    await fs.writeFile(secret, "COMPILED SECRET\n")
+    await fs.symlink(secret, path.join(compiledDir, "evil.sql"))
+
+    const resolver = makeCompiledResolver({
+      cwd: dbtRoot,
+      projectName: project,
+      pathPrefix: "packages/dbt",
+    })
+    const content = await resolver("packages/dbt/models/marts/evil.sql", "new")
+    expect(content).toBeUndefined()
+  })
+
+  test("makeCompiledResolver pathPrefix accepts '.' as a no-op alias", async () => {
+    // `path.relative(root, root)` returns "" — treat "" and "." as
+    // equivalent to "no prefix" so callers don't need branching logic.
+    const { root } = await mkTempRepo()
+    const project = "acme"
+    const compiledPath = path.join(root, "target", "compiled", project, "models", "customers.sql")
+    await fs.mkdir(path.dirname(compiledPath), { recursive: true })
+    await fs.writeFile(compiledPath, "-- via dot prefix\n")
+    const resolver = makeCompiledResolver({ cwd: root, projectName: project, pathPrefix: "." })
+    expect(await resolver("models/customers.sql", "new")).toBe("-- via dot prefix\n")
+  })
+})
diff --git a/packages/opencode/test/altimate/review.test.ts b/packages/opencode/test/altimate/review.test.ts
index 0e94f0ff4..17e1ae978 100644
--- a/packages/opencode/test/altimate/review.test.ts
+++ b/packages/opencode/test/altimate/review.test.ts
@@ -265,6 +265,138 @@ describe("verdict", () => {
     expect(verifyEnvelope(tampered, "test-key")).toBe(false)
   })
 
+  test("--force-tier audit fields are set whenever the flag is passed (even when forced == classified)", () => {
+    // Simulates orchestrate.ts's audit-envelope construction for the two
+    // --force-tier cases. Ensures we never silently bypass the audit trail
+    // just because the forced value happens to match the classifier's tier.
+    // Regression guard for the post-R18 review finding.
+    const withForcedDifferent = buildEnvelope({
+      findings: [],
+      tier: "full",
+      mode: "comment",
+      tierForced: true,
+      tierClassified: "trivial",
+      tierReasons: ["forced via --force-tier=full (classifier said trivial)"],
+    })
+    expect(withForcedDifferent.tierForced).toBe(true)
+    expect(withForcedDifferent.tierClassified).toBe("trivial")
+
+    const withForcedSame = buildEnvelope({
+      findings: [],
+      tier: "full",
+      mode: "comment",
+      tierForced: true,
+      tierClassified: "full",
+      tierReasons: ["forced via --force-tier=full (classifier said full)"],
+    })
+    expect(withForcedSame.tierForced).toBe(true)
+    expect(withForcedSame.tierClassified).toBe("full")
+
+    const notForced = buildEnvelope({ findings: [], tier: "lite", mode: "comment" })
+    expect(notForced.tierForced).toBeUndefined()
+    expect(notForced.tierClassified).toBeUndefined()
+  })
+
+  test("envelope schema rejects inconsistent tierForced / tierClassified (PR #1027 consensus MINOR #2)", async () => {
+    // Direct-parse invariants at the envelope boundary. `runReview` never
+    // builds an inconsistent envelope, but a hand-built envelope with
+    // `tierForced: true` and no `tierClassified` (or vice versa) is a
+    // silent audit-metadata break — the signed body claims a bypass but
+    // records no origin tier, or vice versa. The zod `superRefine`
+    // makes both states unparseable and unsignable.
+    const { VerdictEnvelope: EnvelopeSchema } = await import("../../src/altimate/review/verdict")
+
+    const goodBothPresent = EnvelopeSchema.safeParse({
+      version: "1",
+      verdict: "APPROVE",
+      idealVerdict: "APPROVE",
+      mode: "comment",
+      tier: "full",
+      tierForced: true,
+      tierClassified: "trivial",
+      findings: [],
+      summary: { critical: 0, warning: 0, suggestion: 0, degraded: false },
+      engine: { reviewer: "test/1" },
+    })
+    expect(goodBothPresent.success).toBe(true)
+
+    const goodBothAbsent = EnvelopeSchema.safeParse({
+      version: "1",
+      verdict: "APPROVE",
+      idealVerdict: "APPROVE",
+      mode: "comment",
+      tier: "lite",
+      findings: [],
+      summary: { critical: 0, warning: 0, suggestion: 0, degraded: false },
+      engine: { reviewer: "test/1" },
+    })
+    expect(goodBothAbsent.success).toBe(true)
+
+    const badForcedOnly = EnvelopeSchema.safeParse({
+      version: "1",
+      verdict: "APPROVE",
+      idealVerdict: "APPROVE",
+      mode: "comment",
+      tier: "full",
+      tierForced: true,
+      // tierClassified missing — inconsistent audit metadata
+      findings: [],
+      summary: { critical: 0, warning: 0, suggestion: 0, degraded: false },
+      engine: { reviewer: "test/1" },
+    })
+    expect(badForcedOnly.success).toBe(false)
+
+    const badClassifiedOnly = EnvelopeSchema.safeParse({
+      version: "1",
+      verdict: "APPROVE",
+      idealVerdict: "APPROVE",
+      mode: "comment",
+      tier: "full",
+      // tierForced missing but tierClassified claims an origin
+      tierClassified: "trivial",
+      findings: [],
+      summary: { critical: 0, warning: 0, suggestion: 0, degraded: false },
+      engine: { reviewer: "test/1" },
+    })
+    expect(badClassifiedOnly.success).toBe(false)
+
+    const badForcedFalse = EnvelopeSchema.safeParse({
+      version: "1",
+      verdict: "APPROVE",
+      idealVerdict: "APPROVE",
+      mode: "comment",
+      tier: "lite",
+      // `tierForced: false` is not a legitimate state — the marker exists to
+      // record forced runs; unforced runs must omit it entirely.
+      tierForced: false,
+      findings: [],
+      summary: { critical: 0, warning: 0, suggestion: 0, degraded: false },
+      engine: { reviewer: "test/1" },
+    })
+    expect(badForcedFalse.success).toBe(false)
+  })
+
+  test("tierForced + tierClassified are covered by the signature (tampering detected)", () => {
+    // Confirms the audit fields live inside the signed canonical body — a
+    // tampered envelope claiming a natural tier when a bypass ran can't slip
+    // past verifyEnvelope.
+    const signed = signEnvelope(
+      buildEnvelope({
+        findings: [],
+        tier: "full",
+        mode: "comment",
+        tierForced: true,
+        tierClassified: "trivial",
+        tierReasons: ["forced via --force-tier=full (classifier said trivial)"],
+        generatedAt: "2026-05-29T00:00:00Z",
+      }),
+      "k",
+    )
+    expect(verifyEnvelope(signed, "k")).toBe(true)
+    const strippedForce = { ...signed, tierForced: undefined, tierClassified: undefined, tierReasons: undefined }
+    expect(verifyEnvelope(strippedForce, "k")).toBe(false)
+  })
+
   test("tampering a NESTED finding field is detected (signature covers findings)", () => {
     const f = makeFinding({
       severity: "warning",
@@ -313,6 +445,10 @@ describe("diff-filter", () => {
     expect(classifyDbtFile("models/marts/_marts.yml")).toBe("schema_yml")
     expect(classifyDbtFile("macros/x.sql")).toBe("macro")
     expect(classifyDbtFile("snapshots/s.sql")).toBe("snapshot")
+    // Snapshot YAML property files carry column/test declarations and route
+    // to the schema_yml detector, not the snapshot catalog rules.
+    expect(classifyDbtFile("snapshots/orders_snapshot.yml")).toBe("schema_yml")
+    expect(classifyDbtFile("snapshots/orders_snapshot.yaml")).toBe("schema_yml")
     expect(classifyDbtFile("seeds/c.csv")).toBe("seed")
     expect(classifyDbtFile("dbt_project.yml")).toBe("project_config")
     expect(classifyDbtFile("models/marts/m.py")).toBe("python_model")
@@ -1824,6 +1960,42 @@ describe("orchestrate", () => {
     expect(env.summary.degraded).toBe(true)
   })
 
+  test("renderSummary escapes backticks in tierReasons (cubic-review P3)", async () => {
+    // Regression: a fixed single-backtick fence around each tier reason meant a
+    // path like `weird`path`.sql` would terminate the code span mid-way and
+    // inject Markdown into the summary. Fence now sizes to max(backtick-run)+1
+    // and pads leading/trailing backticks with a space.
+    const env = buildEnvelope({
+      findings: [],
+      tier: "full",
+      mode: "comment",
+      generatedAt: "2026-05-29T00:00:00Z",
+      tierReasons: [
+        "models/x.sql", // plain path — one-backtick fence still fine
+        "path with `single` inside", // needs 2-backtick fence
+        "path with ``double`` inside", // needs 3-backtick fence
+        "`starts-with-backtick",
+        "ends-with-backtick`",
+        "`both-ends`", // both leading + trailing backticks — symmetric padding
+      ],
+    })
+    const summary = renderSummary(env)
+    // Sanity: the tier line exists
+    expect(summary).toContain("Tier: full")
+    // A path with `single` inside must be wrapped by a fence longer than the
+    // longest backtick run inside it. Two-backtick fence sees `single` as a
+    // single-backtick run inside the code span → renders correctly.
+    expect(summary).toContain("``path with `single` inside``")
+    // Three-backtick fence for two-backtick run inside.
+    expect(summary).toContain("```path with ``double`` inside```")
+    // Leading/trailing backticks get space padding so the fence doesn't fuse
+    // with the reason text.
+    expect(summary).toContain("`` `starts-with-backtick ``")
+    expect(summary).toContain("`` ends-with-backtick` ``")
+    // Both ends have backticks — same single pad wraps both sides symmetrically.
+    expect(summary).toContain("`` `both-ends` ``")
+  })
+
   test("renderSummary + inlineComments produce marker + structured output", async () => {
     const env = buildEnvelope({
       findings: [
diff --git a/packages/opencode/test/cli/tui/command.test.ts b/packages/opencode/test/cli/tui/command.test.ts
index 896a29ab1..7c8c68959 100644
--- a/packages/opencode/test/cli/tui/command.test.ts
+++ b/packages/opencode/test/cli/tui/command.test.ts
@@ -7,8 +7,11 @@ describe("tui command", () => {
   test("resolves network options through the config-aware resolver", async () => {
     const source = await tuiCommandSource()
 
-    expect(source).toContain('import { withNetworkOptions, resolveNetworkOptions } from "@/cli/network"')
-    expect(source).toContain('import { AppRuntime } from "@/effect/app-runtime"')
+    // Assertions use regex (not string literals) so Bun's transpiler doesn't
+    // statically resolve `@/cli/network` into `file:///…/network.ts` in the
+    // expected value — a CI-only cache quirk that inverts the comparison.
+    expect(source).toMatch(/import \{ withNetworkOptions, resolveNetworkOptions \} from "@\/cli\/network"/)
+    expect(source).toMatch(/import \{ AppRuntime \} from "@\/effect\/app-runtime"/)
     expect(source).toContain("await AppRuntime.runPromise(resolveNetworkOptions(args))")
     expect(source).not.toContain("resolveNetworkOptionsNoConfig(args)")
   })