From d4456f1ee9ddaee8f00a9cf601d5cb9368a217fc Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Thu, 5 Nov 2026 20:58:17 +0800
Subject: [PATCH 01/21] feat: an end-of-task column impact summary and an
 offline HTML report

A task that changes a dbt model ends with one band: each changed column's downstream reach, read from a manifest copied at the task's start. Open report or /lineage-report opens the report. Edits no longer toast.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YNQjkaiykbC1WtASw6Yegs
---
 plugins/altimate-code/CHANGELOG.md            |   8 +
 plugins/altimate-code/README.md               |   3 +-
 .../altimate-code/hooks/impact-report.test.ts | 194 +++++++
 plugins/altimate-code/hooks/impact-report.ts  | 518 ++++++++++++++++++
 plugins/altimate-code/hooks/integrations.tsx  |   9 +-
 plugins/altimate-code/hooks/lineage.test.tsx  |  74 ++-
 plugins/altimate-code/hooks/lineage.tsx       |  57 +-
 .../altimate-code/hooks/task-impact.test.tsx  | 261 +++++++++
 plugins/altimate-code/hooks/task-impact.tsx   | 343 ++++++++++++
 plugins/altimate-code/types/index.d.ts        |  32 +-
 10 files changed, 1411 insertions(+), 88 deletions(-)
 create mode 100644 plugins/altimate-code/hooks/impact-report.test.ts
 create mode 100644 plugins/altimate-code/hooks/impact-report.ts
 create mode 100644 plugins/altimate-code/hooks/task-impact.test.tsx
 create mode 100644 plugins/altimate-code/hooks/task-impact.tsx

diff --git a/plugins/altimate-code/CHANGELOG.md b/plugins/altimate-code/CHANGELOG.md
index 21403c3..87c0c7e 100644
--- a/plugins/altimate-code/CHANGELOG.md
+++ b/plugins/altimate-code/CHANGELOG.md
@@ -2,6 +2,14 @@
 
 All notable changes to this plugin will be documented in this file.
 
+## [Unreleased]
+
+### Added
+- End-of-task column impact: after a task that changed a dbt model, a band sums up each changed column's downstream reach from `impact_analysis`, and **Open report** or `/lineage-report` opens an offline HTML report with upstream and downstream lineage, two levels by default, and click-to-highlight paths. The task's start copies `target/manifest.json` aside, so the answer reflects the SQL before the task.
+
+### Changed
+- The per-edit impact note no longer shows as a toast and band; it still goes to Claude's context with the edit's result.
+
 ## [1.4.0] — 2026-10-28
 
 ### Added
diff --git a/plugins/altimate-code/README.md b/plugins/altimate-code/README.md
index 25365d6..27d1254 100644
--- a/plugins/altimate-code/README.md
+++ b/plugins/altimate-code/README.md
@@ -107,7 +107,8 @@ The plugin's lineage pane follows the dbt model Claude reads or edits (by Read,
 - **What the answer is about.** Once the session has seen a dbt project, after each answer the models Claude named are listed under the header (IN THE ANSWER), each a press away. When Claude answered without reading any model that turn (from what it read earlier), the pane follows the first model it named, so the lineage shown matches the answer.
 - **Columns.** Each output column with its source columns and how it is derived, from altimate-code's `dbt_lineage`, read from the compiled manifest (`dbt compile`). The plugin's calls are read-only, so altimate-code never starts the project's dbt adapter for them.
 - **Column reach.** `c` picks a column; the pane shows the downstream models whose SQL reads it and the dashboards on them, from `impact_analysis` (it traces each downstream model's compiled SQL, renames included). Models that name the column only in a filter or join, or that could not be traced (no compiled SQL), are listed apart, and the count is then a lower bound.
-- **Impact first.** Before an edit to a model's SQL lands, the plugin checks what reads the model and the reach of every column the edit touches (up to three, merged). It shows the result as a toast, adds it to Claude's context with the edit's result, and leaves a band above the prompt with the severity (impact_analysis' thresholds) and counts.
+- **Impact first.** Before an edit to a model's SQL lands, the plugin checks what reads the model and the reach of every column the edit touches (up to three, merged), and adds it to Claude's context with the edit's result. You see the summary at the end of the task, not a note per edit.
+- **End-of-task summary.** When a task (one prompt and Claude's work on it) changed a model, by an edit or a shell command git sees, a band above the prompt says what changed and how far it reaches: each changed column (up to three per model) with how it is derived, the columns, models and end columns downstream that carry its value, the models that may carry it and those cleared, next to the model-level count, and a line when some models could not be read. The trace reads a copy of `target/manifest.json` taken when the task started (`target/.altimate-lineage/manifest-before.json`), so a recompile mid-task does not change the answer. **Open report** (or `/lineage-report`) opens a full offline HTML report in the browser (`target/.altimate-lineage/report.html`): the change before and after, two levels upstream and downstream (more on request), and a click on any column lights up its path.
 - **Warehouse lineage.** When a connected MCP server offers Altimate's `table_lineage` (Snowflake) or `databricks_table_lineage`, the pane adds what the warehouse's query history shows for the model's table. The plugin calls a tool of that name on whichever connected server offers it, itself and without a permission prompt, and sends it the model's `database.schema.table`. It does so only when you ask for the model (`/lineage`, a press in the pane, or `r`), never when the pane follows one of Claude's reads.
 - **Claude's own lineage calls.** A `dbt_lineage` result is drawn as a list of edges colored by how each column is derived; ctrl+o keeps the original output under it.
 
diff --git a/plugins/altimate-code/hooks/impact-report.test.ts b/plugins/altimate-code/hooks/impact-report.test.ts
new file mode 100644
index 0000000..14855a9
--- /dev/null
+++ b/plugins/altimate-code/hooks/impact-report.test.ts
@@ -0,0 +1,194 @@
+import { describe, expect, test } from 'claude-code/testing'
+
+import {
+  answerOf,
+  changedColumns,
+  type ColumnAnswer,
+  type ColumnTrace,
+  DEFAULT_LEVELS,
+  type ModelChange,
+  openerFor,
+  reachOf,
+  reportData,
+  reportHtml,
+  sectionOf,
+  summaryLines,
+  summaryOf,
+} from './impact-report'
+
+// A synthetic project: orders → fct_orders.revenue → three hops of readers.
+export const DOWN: ColumnAnswer = {
+  version: 1,
+  focus: { model: 'model.shop.fct_orders', column: 'revenue' },
+  direction: 'downstream',
+  inputs: { manifest: { generated_at: '2026-01-01', older_than_sql: false }, sql: 'compiled_code', catalog: null, engine: 'core 1.0', workarounds: [] },
+  counts: { columns: 4, models: 3, hops: 3, contracts: 1, ends: 2, may_carry_models: 1, cleared_models: 2, model_level: 6 },
+  nodes: [
+    { id: 'model.shop.fct_orders', name: 'fct_orders', folder: 'marts', materialized: 'table', contract: false, tests: 1, exposures: [] },
+    { id: 'model.shop.fct_revenue_daily', name: 'fct_revenue_daily', folder: 'marts', materialized: 'table', contract: true, tests: 2, exposures: ['exec_revenue'] },
+    { id: 'model.shop.rpt_finance', name: 'rpt_finance', folder: 'reports', materialized: 'view', contract: false, tests: 0, exposures: [] },
+    { id: 'model.shop.rpt_board', name: 'rpt_board', folder: 'reports', materialized: 'view', contract: false, tests: 0, exposures: [] },
+    { id: 'model.shop.rpt_misc', name: 'rpt_misc', folder: 'reports', materialized: 'view', contract: false, tests: 0, exposures: [] },
+    { id: 'model.shop.rpt_broken', name: 'rpt_broken', folder: 'reports', materialized: 'view', contract: false, tests: 0, exposures: [] },
+  ],
+  columns: [
+    { model: 0, column: 'revenue', hop: 0 },
+    { model: 1, column: 'daily_revenue', hop: 1, type: 'number' },
+    { model: 1, column: 'revenue', hop: 1, end: true, how: '=', how_from: 'name' },
+    { model: 2, column: 'weekly_revenue', hop: 2 },
+    { model: 3, column: 'board_revenue', hop: 3, end: true },
+  ],
+  edges: [
+    [0, 1, 'Σ'],
+    [0, 2, '='],
+    [1, 3, 'ƒ'],
+    [3, 4, '~'],
+  ],
+  also_reads: [{ model: 4, columns: ['revenue'], downstream: 2 }],
+  unresolved: [{ model: 5, reason: 'parse error' }],
+  truncated: false,
+}
+
+export const UP: ColumnAnswer = {
+  version: 1,
+  focus: { model: 'model.shop.fct_orders', column: 'revenue' },
+  direction: 'upstream',
+  nodes: [
+    { id: 'model.shop.fct_orders', name: 'fct_orders' },
+    { id: 'model.shop.int_orders', name: 'int_orders' },
+    { id: 'source.shop.raw.orders', name: 'orders' },
+  ],
+  columns: [
+    { model: 0, column: 'revenue', hop: 0 },
+    { model: 1, column: 'amount', hop: 1 },
+    { model: 2, column: 'amount_cents', hop: 2, end: true },
+  ],
+  edges: [
+    [1, 0, 'Σ'],
+    [2, 1, 'ƒ'],
+  ],
+}
+
+export const CHANGE: ModelChange = {
+  model: 'fct_orders',
+  file: 'models/fct_orders.sql',
+  root: '/repo',
+  columns: [{ name: 'revenue', before: 'sum(amount) as revenue', after: 'sum(amount) - sum(refunds) as revenue' }],
+}
+const TRACE: ColumnTrace = { model: 'fct_orders', column: 'revenue', down: DOWN, up: UP, modelLevel: 6, failed: false }
+
+/** The data a report embeds, read back out of its page. */
+export function embedded(html: string): any {
+  const match = /<script type="application\/json" id="report-data">([\s\S]*?)<\/script>/.exec(html)
+  return match ? JSON.parse(match[1]!) : null
+}
+
+describe('changed columns', () => {
+  test('a rewritten select item is the changed column, with its expression before and after', () => {
+    const before = 'select\n  order_id,\n  sum(amount) as revenue\nfrom orders\ngroup by 1'
+    const after = 'select\n  order_id,\n  sum(amount) - sum(refunds) as revenue\nfrom orders\ngroup by 1'
+    expect(changedColumns(before, after)).toEqual([{ name: 'revenue', before: 'sum(amount) as revenue', after: 'sum(amount) - sum(refunds) as revenue' }])
+  })
+
+  test('a filter change touches no output column, and at most three columns are kept', () => {
+    expect(changedColumns('select a, b from t where x = 1', 'select a, b from t where x = 2')).toEqual([])
+    const wide = changedColumns('select 1 as a, 1 as b, 1 as c, 1 as d from t', 'select 2 as a, 2 as b, 2 as c, 2 as d from t')
+    expect(wide.length).toBe(3)
+  })
+
+  test('a removed column has no expression after', () => {
+    expect(changedColumns('select a, b from t', 'select a from t')).toEqual([{ name: 'b', before: 'b', after: null }])
+  })
+})
+
+describe('the answer', () => {
+  test('is read from metadata.column_answer; anything else is no answer', () => {
+    expect(answerOf({ column_answer: DOWN })).toBe(DOWN)
+    expect(answerOf({ severity: 'LOW', column_reach: {} })).toBeNull()
+    expect(answerOf(null)).toBeNull()
+  })
+
+  test('reach takes the contract counts, and counts for itself where they are absent', () => {
+    expect(reachOf(DOWN)).toEqual({ columns: 4, models: 3, ends: 2, hops: 3, mayCarry: 1, cleared: 2, unresolved: 1, modelLevel: 6, truncated: false })
+    const bare = { ...DOWN, counts: undefined }
+    expect(reachOf(bare)).toEqual({ columns: 4, models: 3, ends: 2, hops: 3, mayCarry: 1, cleared: null, unresolved: 1, modelLevel: null, truncated: false })
+  })
+})
+
+describe('the summary', () => {
+  test('names each changed column with its how and its reach, and says the reach is a lower bound', () => {
+    const lines = summaryLines(summaryOf([CHANGE], [TRACE], '/repo/target/.altimate-lineage/report.html'))
+    expect(lines).toEqual([
+      '◆ Lineage after this task · 1 model changed',
+      'fct_orders · 6 downstream models at model level',
+      '  revenue Σ  reaches 4 columns in 3 models (2 ends) · 1 may carry it · 2 cleared',
+      '⚠ Lower bound: 1 model could not be read',
+    ])
+  })
+
+  test('a model with no changed output column shows its model-level count alone', () => {
+    const change = { ...CHANGE, columns: [] }
+    const lines = summaryLines(summaryOf([change], [{ model: 'fct_orders', column: null, down: null, up: null, modelLevel: 6, failed: false }], null))
+    expect(lines).toEqual(['◆ Lineage after this task · 1 model changed', 'fct_orders · 6 downstream models at model level', '  no output column changed: the model-level count stands'])
+  })
+})
+
+describe('the report', () => {
+  test('groups downstream by hop then model, with the how per column, ends and contracts', () => {
+    const down = sectionOf(DOWN)
+    expect(down.hops.map(one => one.hop)).toEqual([1, 2, 3])
+    const daily = down.hops[0]!.models[0]!
+    expect(daily).toMatchObject({ name: 'fct_revenue_daily', contract: true, tests: 2, exposures: ['exec_revenue'] })
+    expect(daily.columns.map(one => [one.column, one.glyph, one.byName, one.end])).toEqual([
+      ['daily_revenue', 'Σ', false, false],
+      ['revenue', '=', true, true],
+    ])
+    // Upstream: how each column feeds the one below it.
+    expect(sectionOf(UP).hops.map(one => one.models[0]!.columns[0]!.glyph)).toEqual(['Σ', 'ƒ'])
+  })
+
+  test('embeds both directions with edges keyed by model and column, folds, and two levels by default', () => {
+    const html = reportHtml(reportData([CHANGE], [TRACE], '2026-01-01 00:00 UTC', 'the manifest as it was when the task started'))
+    expect(html).toContain('data-levels="2"')
+    const data = embedded(html)
+    expect(data.defaultLevels).toBe(DEFAULT_LEVELS)
+    expect(DEFAULT_LEVELS).toBe(2)
+    const focus = data.focuses[0]
+    expect(focus).toMatchObject({ model: 'fct_orders', column: 'revenue', key: 'model.shop.fct_orders|revenue', glyph: 'Σ', before: 'sum(amount) as revenue' })
+    expect(focus.up.hops.map((one: any) => one.hop)).toEqual([1, 2])
+    expect(focus.down.hops.map((one: any) => one.hop)).toEqual([1, 2, 3])
+    // The highlight walks these edges both ways from the clicked column.
+    expect(focus.edges).toContainEqual(['model.shop.int_orders|amount', 'model.shop.fct_orders|revenue', 'Σ'])
+    expect(focus.edges).toContainEqual(['model.shop.rpt_finance|weekly_revenue', 'model.shop.rpt_board|board_revenue', '~'])
+    expect(focus.alsoReads).toEqual([{ name: 'rpt_misc', columns: ['revenue'], downstream: 2 }])
+    expect(focus.unresolved).toEqual([{ name: 'rpt_broken', reason: 'parse error', downstream: null }])
+    expect(focus.cleared).toEqual({ names: [], count: 2 })
+    expect(data.changes[0].columns[0].after).toBe('sum(amount) - sum(refunds) as revenue')
+  })
+
+  test('is one offline file: no external resource, and project text cannot close its script', () => {
+    const hostile = { ...CHANGE, model: 'x</script><script>alert(1)</script>' }
+    const html = reportHtml(reportData([hostile], [{ ...TRACE, model: hostile.model }], 'now', 'm'))
+    expect(html).not.toMatch(/(src|href)="(https?:)?\/\//)
+    expect(html).not.toContain('<script>alert(1)')
+    expect(html.match(/<\/script>/g)!.length).toBe(2)
+    expect(embedded(html).changes[0].model).toBe(hostile.model)
+    expect(html).toContain('prefers-color-scheme:dark')
+  })
+})
+
+describe('the opener', () => {
+  test('per platform: open, xdg-open, wslview or explorer.exe on the Windows path, start', () => {
+    const path = '/repo/target/.altimate-lineage/report.html'
+    expect(openerFor('mac', path)).toEqual({ argv: ['open', path], okExits: [0] })
+    expect(openerFor('linux', path)).toEqual({ argv: ['xdg-open', path], okExits: [0] })
+    expect(openerFor('wsl', path, { wslview: true })).toEqual({ argv: ['wslview', path], okExits: [0] })
+    // explorer.exe exits 1 even when it opened the file.
+    expect(openerFor('wsl', path, { wslview: false, windowsPath: '\\\\wsl.localhost\\x\\report.html' })).toEqual({
+      argv: ['explorer.exe', '\\\\wsl.localhost\\x\\report.html'],
+      okExits: [0, 1],
+    })
+    expect(openerFor('wsl', path, { wslview: false, windowsPath: null })).toBeNull()
+    expect(openerFor('windows', path)).toEqual({ argv: ['cmd', '/c', 'start', '', path], okExits: [0] })
+  })
+})
diff --git a/plugins/altimate-code/hooks/impact-report.ts b/plugins/altimate-code/hooks/impact-report.ts
new file mode 100644
index 0000000..c8b713d
--- /dev/null
+++ b/plugins/altimate-code/hooks/impact-report.ts
@@ -0,0 +1,518 @@
+// The end-of-task column impact: altimate-code's column answers read into a short summary for the band
+// and a self-contained HTML report. Pure functions only; the hooks live in task-impact.tsx.
+
+import type { Reach, TaskSummaryView } from '../types'
+import { selectItems, touchedColumns } from './lineage-graph'
+
+export type { Reach, TaskSummaryView }
+
+/** One column answer from impact_analysis (`metadata.column_answer`, contract version 1). Any field may be absent. */
+export type ColumnAnswer = {
+  version?: number
+  focus?: { model?: string; column?: string }
+  direction?: string
+  inputs?: { manifest?: unknown; sql?: string; catalog?: unknown; engine?: string; workarounds?: string[] }
+  counts?: Record<string, unknown>
+  nodes: { id?: string; name?: string; folder?: string; materialized?: string; contract?: boolean; tests?: number; exposures?: string[] }[]
+  columns: { model: number; column: string; hop: number; end?: boolean; how?: string; how_from?: string; type?: string }[]
+  edges?: [number, number, string?][]
+  also_reads?: { model: number; columns?: string[]; downstream?: number }[]
+  unresolved?: { model: number; reason?: string; downstream?: number }[]
+  cleared?: (number | { model: number })[]
+  flags?: { model: number; flag: string }[]
+  truncated?: boolean
+  next?: unknown
+}
+
+/** A model file the task changed, with the columns it changed (at most three). */
+export type ModelChange = {
+  model: string
+  file: string
+  root: string
+  columns: { name: string; before: string | null; after: string | null }[]
+}
+
+export const MAX_TASK_COLUMNS = 3
+export const DEFAULT_LEVELS = 2
+export const GLYPHS = ['=', '~', 'ƒ', 'Σ', '?'] as const
+const RANK: Record<string, number> = { 'Σ': 4, 'ƒ': 3, '~': 2, '=': 1, '?': 0 }
+export const HOW_NAME: Record<string, string> = { '=': 'same value', '~': 'renamed', 'ƒ': 'calculated', 'Σ': 'aggregated', '?': 'unknown' }
+
+/** A select item's expression for the header: the last scope's (the model's own select) when several share the name. */
+const lastExpr = (items: Map<string, string>, name: string) => items.get(name)?.split('\u0000').pop()?.replace(/\s+/g, ' ').trim() ?? null
+
+/**
+ * The output columns one file's change touches, up to three, ranked as touchedColumns ranks them.
+ * Empty when no output column changed (a filter, a join): the model-level count stands in.
+ */
+export function changedColumns(original: string, current: string): ModelChange['columns'] {
+  const before = selectItems(original)
+  const after = selectItems(current)
+  // Only output columns whose select item was rewritten, added or removed: a column merely named on a
+  // changed line (a filter, a join) keeps its value.
+  const rewritten = [...new Set([...before.keys(), ...after.keys()])].filter(name => name !== '*' && before.get(name) !== after.get(name))
+  return touchedColumns([original], [current], rewritten)
+    .slice(0, MAX_TASK_COLUMNS)
+    .map(name => ({ name, before: lastExpr(before, name), after: lastExpr(after, name) }))
+}
+
+/** The column answer in an impact_analysis result's metadata, or null when it carries none. */
+export function answerOf(metadata: unknown): ColumnAnswer | null {
+  const m = metadata as any
+  const answer = m?.column_answer ?? (m?.version === 1 && m?.focus ? m : null)
+  if (!answer || typeof answer !== 'object' || !Array.isArray(answer.columns) || !Array.isArray(answer.nodes)) return null
+  return answer as ColumnAnswer
+}
+
+/** The model-level downstream count an impact_analysis result carries, with or without a column answer. */
+export function modelLevelOf(metadata: unknown): number | null {
+  const m = metadata as any
+  const fromAnswer = num(answerOf(m)?.counts?.model_level)
+  if (fromAnswer !== null) return fromAnswer
+  const direct = num(m?.direct_count)
+  const transitive = num(m?.transitive_count)
+  return direct === null && transitive === null ? null : (direct ?? 0) + (transitive ?? 0)
+}
+
+const num = (value: unknown) => (typeof value === 'number' && Number.isFinite(value) ? value : null)
+
+/** A how as the contract spells it: its glyph, and whether the link was matched by name rather than traced. */
+export function parseHow(how: unknown, howFrom?: unknown): { glyph: string; byName: boolean } {
+  const text = typeof how === 'string' ? how : ''
+  const glyph = GLYPHS.find(one => text.startsWith(one)) ?? '?'
+  return { glyph, byName: howFrom === 'name' || (text.length > 1 && text.endsWith('?')) }
+}
+
+/** The strongest derivation among several edges: aggregated, calculated, renamed, same, unknown. */
+function strongest(hows: string[]): string | null {
+  if (hows.length === 0) return null
+  return hows.reduce((best, one) => ((RANK[parseHow(one).glyph] ?? 0) > (RANK[parseHow(best).glyph] ?? 0) ? one : best))
+}
+
+/** How one column of an answer is derived: its own how, else the strongest edge into it (downstream) or out of it (upstream). */
+function howOf(answer: ColumnAnswer, index: number): string | null {
+  const own = answer.columns[index]?.how
+  if (typeof own === 'string' && own) return own
+  const upstream = answer.direction === 'upstream'
+  const edges = (answer.edges ?? []).filter(edge => Array.isArray(edge) && (upstream ? edge[0] === index : edge[1] === index))
+  return strongest(edges.map(edge => String(edge[2] ?? '?')))
+}
+
+/** The focus column's own derivation, from the upstream answer: how it is made from what it reads. */
+export function focusHow(upstream: ColumnAnswer | null): string | null {
+  if (!upstream) return null
+  const focus = upstream.columns.findIndex(one => one.hop === 0)
+  if (focus < 0) return null
+  const own = upstream.columns[focus]!.how
+  if (typeof own === 'string' && own) return own
+  return strongest((upstream.edges ?? []).filter(edge => edge[1] === focus).map(edge => String(edge[2] ?? '?')))
+}
+
+/** The downstream reach in counts, read from the answer's counts where it gives them, else counted. */
+export function reachOf(answer: ColumnAnswer): Reach {
+  const counts = answer.counts ?? {}
+  const beyond = answer.columns.filter(one => one.hop > 0)
+  const cleared = num(counts.cleared_models) ?? (Array.isArray(answer.cleared) ? answer.cleared.length : null)
+  return {
+    columns: num(counts.columns) ?? beyond.length,
+    models: num(counts.models) ?? new Set(beyond.map(one => one.model)).size,
+    ends: num(counts.ends) ?? beyond.filter(one => one.end).length,
+    hops: num(counts.hops) ?? Math.max(0, ...answer.columns.map(one => one.hop)),
+    mayCarry: num(counts.may_carry_models) ?? num(counts.also_reads_models) ?? answer.also_reads?.length ?? 0,
+    cleared,
+    unresolved: num(counts.unresolved_models) ?? answer.unresolved?.length ?? 0,
+    modelLevel: num(counts.model_level),
+    truncated: answer.truncated === true,
+  }
+}
+
+/** The traced answers for one changed column: downstream and upstream, each null when it failed. */
+export type ColumnTrace = { model: string; column: string | null; down: ColumnAnswer | null; up: ColumnAnswer | null; modelLevel: number | null; failed: boolean }
+
+/** The band's view of a finished task. */
+export function summaryOf(changes: ModelChange[], traces: ColumnTrace[], report: string | null): TaskSummaryView {
+  const unresolved = new Set<string>()
+  let truncated = false
+  const models = changes.map(change => {
+    const mine = traces.filter(one => one.model === change.model)
+    const modelLevel = mine.map(one => one.modelLevel ?? (one.down ? reachOf(one.down).modelLevel : null)).find(one => one !== null) ?? null
+    const columns = mine
+      .filter(one => one.column !== null)
+      .map(one => {
+        const reach = one.down ? reachOf(one.down) : null
+        for (const entry of one.down?.unresolved ?? []) unresolved.add(one.down!.nodes[entry.model]?.id ?? one.down!.nodes[entry.model]?.name ?? String(entry.model))
+        if (reach?.truncated) truncated = true
+        return { name: one.column!, how: focusHow(one.up), reach, failed: one.failed }
+      })
+    return { name: change.model, modelLevel, columns }
+  })
+  return { state: 'ready', models, unresolved: unresolved.size, truncated, report, openFailed: false }
+}
+
+/** The band's lines, as text: what the summary says, for the log and for tests. */
+export function summaryLines(view: TaskSummaryView): string[] {
+  const plural = (n: number, word: string) => `${n} ${word}${n === 1 ? '' : 's'}`
+  const lines = [`◆ Lineage after this task · ${plural(view.models.length, 'model')} changed`]
+  for (const model of view.models) {
+    lines.push(`${model.name}${model.modelLevel !== null ? ` · ${plural(model.modelLevel, 'downstream model')} at model level` : ''}`)
+    if (model.columns.length === 0) lines.push('  no output column changed: the model-level count stands')
+    for (const col of model.columns) {
+      const glyph = col.how ? parseHow(col.how).glyph : '·'
+      if (view.state === 'tracing' && !col.reach) lines.push(`  ${col.name} ${glyph}  tracing…`)
+      else if (!col.reach) lines.push(`  ${col.name} ${glyph}  ${col.failed ? 'could not be traced' : 'no column answer'}`)
+      else {
+        const r = col.reach
+        const parts = [`reaches ${plural(r.columns, 'column')} in ${plural(r.models, 'model')} (${plural(r.ends, 'end')})`]
+        parts.push(`${r.mayCarry} may carry it`)
+        if (r.cleared !== null) parts.push(`${r.cleared} cleared`)
+        lines.push(`  ${col.name} ${glyph}  ${parts.join(' · ')}`)
+      }
+    }
+  }
+  if (view.unresolved > 0 || view.truncated) {
+    const why = [view.unresolved ? `${plural(view.unresolved, 'model')} could not be read` : '', view.truncated ? 'the trace hit its limit' : ''].filter(Boolean).join('; ')
+    lines.push(`⚠ Lower bound: ${why}`)
+  } else if (view.state === 'ready' && view.models.some(one => one.columns.some(col => col.reach))) {
+    lines.push('✓ Every downstream model was read')
+  }
+  return lines
+}
+
+// ---------------------------------------------------------------------------------------------------
+// The report: data the page draws from, then the page.
+
+export type ReportColumn = { key: string; column: string; glyph: string; byName: boolean; end: boolean; type: string | null; hop: number }
+export type ReportModel = {
+  id: string
+  name: string
+  folder: string
+  materialized: string
+  contract: boolean
+  tests: number
+  exposures: string[]
+  columns: ReportColumn[]
+}
+export type ReportSection = { hops: { hop: number; models: ReportModel[] }[]; truncated: boolean; error: string | null }
+export type ReportFocus = {
+  model: string
+  column: string | null
+  key: string | null
+  glyph: string | null
+  byName: boolean
+  before: string | null
+  after: string | null
+  reach: Reach | null
+  modelLevel: number | null
+  up: ReportSection
+  down: ReportSection
+  edges: [string, string, string][]
+  alsoReads: { name: string; columns: string[]; downstream: number | null }[]
+  unresolved: { name: string; reason: string; downstream: number | null }[]
+  cleared: { names: string[]; count: number | null }
+  inputs: { engine: string | null; workarounds: string[]; catalog: boolean; olderThanSql: boolean }
+}
+export type ReportData = {
+  title: string
+  generatedAt: string
+  manifest: string
+  defaultLevels: number
+  changes: { model: string; file: string; columns: ModelChange['columns'] }[]
+  focuses: ReportFocus[]
+}
+
+const keyOf = (answer: ColumnAnswer, index: number) => {
+  const col = answer.columns[index]!
+  const node = answer.nodes[col.model]
+  return `${node?.id ?? node?.name ?? col.model}|${String(col.column).toLowerCase()}`
+}
+const nameOf = (answer: ColumnAnswer, index: number | undefined) => {
+  const node = index === undefined ? undefined : answer.nodes[index]
+  return String(node?.name ?? node?.id ?? index ?? '?')
+}
+
+/** One direction's columns beyond the focus, grouped by hop and then by model. */
+export function sectionOf(answer: ColumnAnswer | null, failed = false): ReportSection {
+  if (!answer) return { hops: [], truncated: false, error: failed ? 'This direction could not be traced.' : null }
+  const byHop = new Map<number, Map<number, ReportModel>>()
+  answer.columns.forEach((col, i) => {
+    if (!(col.hop > 0)) return
+    const node = answer.nodes[col.model] ?? {}
+    const hop = byHop.get(col.hop) ?? new Map<number, ReportModel>()
+    byHop.set(col.hop, hop)
+    const model = hop.get(col.model) ?? {
+      id: String(node.id ?? node.name ?? col.model),
+      name: String(node.name ?? node.id ?? col.model),
+      folder: String(node.folder ?? ''),
+      materialized: String(node.materialized ?? ''),
+      contract: node.contract === true,
+      tests: num(node.tests) ?? 0,
+      exposures: Array.isArray(node.exposures) ? node.exposures.map(String) : [],
+      columns: [],
+    }
+    hop.set(col.model, model)
+    const how = parseHow(howOf(answer, i), col.how_from)
+    model.columns.push({ key: keyOf(answer, i), column: String(col.column), glyph: how.glyph, byName: how.byName, end: col.end === true, type: col.type ?? null, hop: col.hop })
+  })
+  const hops = [...byHop.entries()]
+    .sort((a, b) => a[0] - b[0])
+    .map(([hop, models]) => ({ hop, models: [...models.values()].sort((a, b) => a.name.localeCompare(b.name)) }))
+  return { hops, truncated: answer.truncated === true, error: null }
+}
+
+/** The page's data for one changed column (or one model, when no column changed). */
+export function focusOf(change: ModelChange, column: ModelChange['columns'][number] | null, trace: ColumnTrace | undefined): ReportFocus {
+  const down = trace?.down ?? null
+  const up = trace?.up ?? null
+  const any = down ?? up
+  const focusIndex = any ? any.columns.findIndex(one => one.hop === 0) : -1
+  const how = parseHow(focusHow(up), up?.columns.find(one => one.hop === 0)?.how_from)
+  const edges: [string, string, string][] = []
+  for (const answer of [up, down]) {
+    if (!answer) continue
+    for (const edge of answer.edges ?? []) {
+      if (!Array.isArray(edge) || !answer.columns[edge[0]] || !answer.columns[edge[1]]) continue
+      edges.push([keyOf(answer, edge[0]), keyOf(answer, edge[1]), String(edge[2] ?? '?')])
+    }
+  }
+  const clearedNames = (down?.cleared ?? []).map(one => nameOf(down!, typeof one === 'number' ? one : one?.model))
+  const reach = down ? reachOf(down) : null
+  const manifestInput = (down?.inputs ?? up?.inputs)?.manifest as any
+  return {
+    model: change.model,
+    column: column?.name ?? null,
+    key: any && focusIndex >= 0 ? keyOf(any, focusIndex) : null,
+    glyph: up ? how.glyph : null,
+    byName: how.byName,
+    before: column?.before ?? null,
+    after: column?.after ?? null,
+    reach,
+    modelLevel: trace?.modelLevel ?? reach?.modelLevel ?? null,
+    up: sectionOf(up, !!trace?.failed && !up && !!column),
+    down: sectionOf(down, !!trace?.failed && !down && !!column),
+    edges,
+    alsoReads: (down?.also_reads ?? []).map(one => ({ name: nameOf(down!, one.model), columns: (one.columns ?? []).map(String), downstream: num(one.downstream) })),
+    unresolved: (down?.unresolved ?? []).map(one => ({ name: nameOf(down!, one.model), reason: String(one.reason ?? 'not read'), downstream: num(one.downstream) })),
+    cleared: { names: clearedNames, count: reach?.cleared ?? (clearedNames.length || null) },
+    inputs: {
+      engine: (down?.inputs ?? up?.inputs)?.engine ?? null,
+      workarounds: [...new Set([...(down?.inputs?.workarounds ?? []), ...(up?.inputs?.workarounds ?? [])])].map(String),
+      catalog: !!(down?.inputs ?? up?.inputs)?.catalog,
+      olderThanSql: manifestInput?.older_than_sql === true,
+    },
+  }
+}
+
+/** Everything the report draws, from the task's changes and their traces. */
+export function reportData(changes: ModelChange[], traces: ColumnTrace[], generatedAt: string, manifest: string): ReportData {
+  const focuses: ReportFocus[] = []
+  for (const change of changes) {
+    if (change.columns.length === 0) focuses.push(focusOf(change, null, traces.find(one => one.model === change.model && one.column === null)))
+    for (const col of change.columns) focuses.push(focusOf(change, col, traces.find(one => one.model === change.model && one.column === col.name)))
+  }
+  const names = changes.map(one => one.model)
+  return {
+    title: `Column impact · ${names.slice(0, 2).join(', ')}${names.length > 2 ? ` +${names.length - 2}` : ''}`,
+    generatedAt,
+    manifest,
+    defaultLevels: DEFAULT_LEVELS,
+    changes: changes.map(one => ({ model: one.model, file: one.file, columns: one.columns })),
+    focuses,
+  }
+}
+
+/** JSON safe to place inside a script element: no tag can close it early. */
+const scriptJson = (value: unknown) =>
+  JSON.stringify(value).replace(/</g, '\\u003c').replace(/>/g, '\\u003e').replace(/&/g, '\\u0026').replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029')
+const escapeHtml = (text: string) => text.replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]!)
+
+/** The report as one offline HTML file: inline CSS and JS, no external resources. */
+export function reportHtml(data: ReportData): string {
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="color-scheme" content="light dark">
+<link rel="icon" href="data:,">
+<title>${escapeHtml(data.title)}</title>
+<style>${REPORT_CSS}</style>
+</head>
+<body>
+<div id="app" data-levels="${data.defaultLevels}"></div>
+<noscript><p class="noscript">This report draws itself with JavaScript; turn it on to see the lineage.</p></noscript>
+<script type="application/json" id="report-data">${scriptJson(data)}</script>
+<script>${REPORT_JS}</script>
+</body>
+</html>
+`
+}
+
+const REPORT_CSS = `
+:root{
+  --bg:#f7f7f5;--panel:#ffffff;--ink:#1d1d1b;--muted:#6b6b66;--faint:#9a9a93;--line:#e4e3de;--line-strong:#cfcdc6;
+  --accent:#3b5bdb;--accent-soft:#e8edff;--focus:#fff4d6;--focus-line:#e6b84a;
+  --same:#2f7d4f;--same-bg:#e3f3e9;--ren:#2c62b8;--ren-bg:#e3ecfb;--calc:#a35c00;--calc-bg:#fbefdc;--agg:#7a3fb0;--agg-bg:#f0e6fa;--unk:#6b6b66;--unk-bg:#eeeeea;
+  --warn:#9a5b00;--warn-bg:#fff3dc;--del:#b42318;--del-bg:#fdecea;--add:#1f7a43;--add-bg:#e6f5ec;
+  --shadow:0 1px 2px rgba(0,0,0,.05),0 2px 8px rgba(0,0,0,.04);
+}
+@media (prefers-color-scheme:dark){:root{
+  --bg:#151515;--panel:#1e1e1d;--ink:#ecebe6;--muted:#a3a29b;--faint:#76756f;--line:#2f2f2d;--line-strong:#454540;
+  --accent:#8ea6ff;--accent-soft:#25293b;--focus:#3a3220;--focus-line:#b48a2c;
+  --same:#6fcf97;--same-bg:#1c3326;--ren:#8fb6ff;--ren-bg:#1d2a40;--calc:#f0b35c;--calc-bg:#3a2a12;--agg:#c79bf2;--agg-bg:#2f2240;--unk:#a3a29b;--unk-bg:#2a2a28;
+  --warn:#f0b35c;--warn-bg:#352a15;--del:#ff8a80;--del-bg:#3a1f1d;--add:#7ddc9f;--add-bg:#1b3325;
+  --shadow:none;
+}}
+*{box-sizing:border-box}
+html{-webkit-text-size-adjust:100%}
+body{margin:0;background:var(--bg);color:var(--ink);font:14px/1.45 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,sans-serif}
+code,.mono{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,"Liberation Mono",monospace;font-size:12.5px}
+.wrap{max-width:1040px;margin:0 auto;padding:20px 16px 64px}
+header.top{display:flex;flex-wrap:wrap;align-items:baseline;gap:6px 14px;margin-bottom:14px}
+header.top h1{font-size:20px;margin:0;font-weight:650;letter-spacing:-.01em}
+header.top .when{color:var(--muted);font-size:12.5px}
+.panel{background:var(--panel);border:1px solid var(--line);border-radius:10px;box-shadow:var(--shadow)}
+.changes{padding:14px 16px;margin-bottom:14px}
+.changes h2,.section h2{font-size:12px;text-transform:uppercase;letter-spacing:.06em;color:var(--muted);margin:0 0 8px;font-weight:600}
+.change-model{margin:8px 0 2px;font-weight:600;overflow-wrap:anywhere}
+.change-model .file{color:var(--faint);font-weight:400;margin-left:6px;font-size:12px}
+.diff{display:grid;grid-template-columns:auto 1fr;gap:3px 10px;margin:6px 0 10px;align-items:start}
+.diff .col-name{font-weight:600;grid-row:span 2;padding-top:2px}
+.diff .was,.diff .now{border-radius:6px;padding:3px 8px;overflow-wrap:anywhere;white-space:pre-wrap}
+.diff .was{background:var(--del-bg);color:var(--del)}
+.diff .now{background:var(--add-bg);color:var(--add)}
+.diff .none{opacity:.7;font-style:italic}
+.diff .same{grid-column:2;color:var(--muted);font-size:12.5px}
+.tabs{display:flex;flex-wrap:wrap;gap:6px;margin:0 0 12px}
+.tab{appearance:none;border:1px solid var(--line-strong);background:var(--panel);color:var(--ink);border-radius:999px;padding:5px 12px;font:inherit;cursor:pointer}
+.tab[aria-selected=true]{background:var(--accent);border-color:var(--accent);color:#fff}
+@media (prefers-color-scheme:dark){.tab[aria-selected=true]{color:#111}}
+.stats{display:flex;flex-wrap:wrap;gap:8px;margin:0 0 10px}
+.stat{background:var(--panel);border:1px solid var(--line);border-radius:8px;padding:6px 10px;min-width:92px}
+.stat b{display:block;font-size:18px;line-height:1.2}
+.stat span{color:var(--muted);font-size:12px}
+.stat.dim b{color:var(--muted)}
+.note{border-radius:8px;padding:8px 12px;margin:0 0 12px;font-size:13px}
+.note.warn{background:var(--warn-bg);color:var(--warn)}
+.note.ok{background:var(--same-bg);color:var(--same)}
+.inputs{color:var(--muted);font-size:12px;margin:-4px 0 14px}
+.legend{display:flex;flex-wrap:wrap;gap:4px 12px;color:var(--muted);font-size:12px;margin:0 0 14px}
+.legend .g{margin-right:4px}
+.section{margin:0 0 12px}
+.section-head{display:flex;align-items:center;flex-wrap:wrap;gap:8px;margin:18px 0 8px}
+.section-head h2{flex:1}
+.section-head h2{margin:0}
+.more{appearance:none;border:1px dashed var(--line-strong);background:transparent;color:var(--accent);border-radius:8px;padding:4px 10px;font:inherit;font-size:12.5px;cursor:pointer}
+.more:hover{background:var(--accent-soft)}
+.hop{margin:0 0 10px}
+.hop-label{font-size:12px;color:var(--muted);margin:0 0 6px;display:flex;align-items:center;gap:8px}
+.hop-label::after{content:"";flex:1;border-top:1px solid var(--line)}
+.models{display:grid;grid-template-columns:repeat(auto-fill,minmax(270px,1fr));gap:8px}
+.model{padding:9px 10px 6px;transition:opacity .15s}
+.model-head{display:flex;flex-wrap:wrap;align-items:center;gap:4px 6px;margin-bottom:4px}
+.model-name{font-weight:600;overflow-wrap:anywhere}
+.badge{font-size:11px;border-radius:4px;padding:0 5px;border:1px solid var(--line-strong);color:var(--muted);line-height:17px}
+.badge.c{border-color:var(--accent);color:var(--accent);font-weight:700}
+.badge.x{border-color:var(--agg);color:var(--agg)}
+.model-meta{color:var(--faint);font-size:11.5px;margin-bottom:4px}
+.col{display:flex;align-items:center;gap:7px;width:100%;appearance:none;border:0;background:transparent;color:inherit;font:inherit;text-align:left;padding:3px 4px;border-radius:6px;cursor:pointer}
+.col:hover{background:var(--accent-soft)}
+.col .name{overflow-wrap:anywhere;flex:1}
+.col .type{color:var(--faint);font-size:11.5px}
+.col .end{font-size:10.5px;color:var(--muted);border:1px solid var(--line-strong);border-radius:4px;padding:0 4px}
+.g{display:inline-flex;align-items:center;justify-content:center;min-width:20px;height:20px;border-radius:5px;font-weight:700;font-size:12.5px;flex:none}
+.g.same{color:var(--same);background:var(--same-bg)}
+.g.ren{color:var(--ren);background:var(--ren-bg)}
+.g.calc{color:var(--calc);background:var(--calc-bg)}
+.g.agg{color:var(--agg);background:var(--agg-bg)}
+.g.unk{color:var(--unk);background:var(--unk-bg)}
+.g.byname{outline:1.5px dashed currentColor;outline-offset:-1.5px;background:transparent}
+.focus{padding:12px 14px;border:1.5px solid var(--focus-line);background:var(--focus);margin:6px 0}
+.focus .label{font-size:11px;text-transform:uppercase;letter-spacing:.06em;color:var(--muted)}
+.focus .title{font-size:17px;font-weight:650;margin:2px 0;display:flex;align-items:center;gap:8px;flex-wrap:wrap}
+.focus .col{width:auto;padding:2px 6px;display:inline-flex}
+.empty{color:var(--muted);font-size:13px;padding:6px 2px}
+details.fold{margin:8px 0;padding:0 12px}
+details.fold summary{cursor:pointer;padding:10px 0;font-weight:600}
+details.fold summary span{color:var(--muted);font-weight:400}
+details.fold ul{margin:0 0 10px;padding-left:18px}
+details.fold li{margin:3px 0}
+details.fold .why{color:var(--muted)}
+.pathbar{position:sticky;top:0;z-index:5;display:none;align-items:center;gap:10px;flex-wrap:wrap;background:var(--accent);color:#fff;padding:8px 14px;border-radius:0 0 10px 10px;margin:-20px 0 12px;font-size:13px}
+@media (prefers-color-scheme:dark){.pathbar{color:#111}}
+.pathbar button{appearance:none;border:1px solid currentColor;background:transparent;color:inherit;border-radius:6px;padding:2px 8px;font:inherit;cursor:pointer}
+body.hl .pathbar{display:flex}
+body.hl .col:not(.on){opacity:.28}
+body.hl .model:not(.has-on){opacity:.45}
+body.hl .col.on{background:var(--accent-soft)}
+body.hl .col.sel{outline:2px solid var(--accent)}
+.noscript{padding:16px}
+@media (max-width:560px){
+  .wrap{padding:14px 12px 48px}
+  header.top h1{font-size:17px}
+  .models{grid-template-columns:1fr}
+  .stat{min-width:0;flex:1 1 40%}
+}
+`
+
+const REPORT_JS = `
+(function(){
+var DATA=JSON.parse(document.getElementById('report-data').textContent);
+var app=document.getElementById('app');
+var GLYPH={'=':'same','~':'ren','\\u0192':'calc','\\u03a3':'agg','?':'unk'};
+var HOW={'=':'same value','~':'renamed','\\u0192':'calculated','\\u03a3':'aggregated','?':'unknown'};
+var state={focus:0,levels:[],selected:null};
+DATA.focuses.forEach(function(){state.levels.push({up:DATA.defaultLevels,down:DATA.defaultLevels})});
+function el(tag,cls,text){var n=document.createElement(tag);if(cls)n.className=cls;if(text!=null)n.textContent=String(text);return n}
+function plural(n,w){return n+' '+w+(n===1?'':'s')}
+function glyph(g,byName){var s=el('span','g '+(GLYPH[g]||'unk')+(byName?' byname':''),g||'?');s.title=(HOW[g]||'unknown')+(byName?' (matched by name, not traced through SQL)':'');return s}
+function graphOf(f){var fwd={},back={};f.edges.forEach(function(e){(fwd[e[0]]=fwd[e[0]]||[]).push(e[1]);(back[e[1]]=back[e[1]]||[]).push(e[0])});return{fwd:fwd,back:back}}
+function walk(start,adj){var seen={},q=[start];seen[start]=1;while(q.length){var k=q.shift();(adj[k]||[]).forEach(function(n){if(!seen[n]){seen[n]=1;q.push(n)}})}return seen}
+function pathOf(f,key){var g=graphOf(f),up=walk(key,g.back),down=walk(key,g.fwd),all={};Object.keys(up).forEach(function(k){all[k]=1});Object.keys(down).forEach(function(k){all[k]=1});return{all:all,up:Object.keys(up).length-1,down:Object.keys(down).length-1}}
+function colButton(c){var b=el('button','col');b.type='button';b.dataset.key=c.key;b.appendChild(glyph(c.glyph,c.byName));b.appendChild(el('span','name mono',c.column));if(c.type)b.appendChild(el('span','type',c.type));if(c.end){var e=el('span','end','end');e.title='Nothing further downstream reads it';b.appendChild(e)}b.addEventListener('click',function(ev){ev.stopPropagation();select(c.key)});return b}
+function modelCard(m){var card=el('div','panel model');var head=el('div','model-head');head.appendChild(el('span','model-name mono',m.name));if(m.contract){var c=el('span','badge c','C');c.title='Contract enforced: a change to this column can fail its build';head.appendChild(c)}if(m.tests){head.appendChild(el('span','badge',plural(m.tests,'test')))}m.exposures.forEach(function(x){var b=el('span','badge x','\\u25a3 '+x);b.title='Exposure (dashboard or app) on this model';head.appendChild(b)});card.appendChild(head);var meta=[m.folder,m.materialized].filter(Boolean).join(' \\u00b7 ');if(meta)card.appendChild(el('div','model-meta',meta));m.columns.forEach(function(c){card.appendChild(colButton(c))});return card}
+function hopBlock(h,dir){var d=el('div','hop');var cols=h.models.reduce(function(n,m){return n+m.columns.length},0);d.appendChild(el('div','hop-label',(dir==='up'?'Reads from \\u00b7 ':'')+plural(h.hop,'hop')+' '+(dir==='up'?'up':'down')+' \\u00b7 '+plural(h.models.length,'model')+' \\u00b7 '+plural(cols,'column')));var grid=el('div','models');h.models.forEach(function(m){grid.appendChild(modelCard(m))});d.appendChild(grid);return d}
+function section(f,i,dir){var sec=f[dir],lv=state.levels[i][dir],s=el('section','section');var head=el('div','section-head');head.appendChild(el('h2',null,dir==='up'?'Upstream: where it comes from':'Downstream: where it goes'));var total=sec.hops.length,hidden=sec.hops.filter(function(h){return h.hop>lv}).length;if(hidden>0){var more=el('button','more',hidden===1?'Show 1 more level':'Show more levels ('+hidden+' hidden)');more.type='button';more.addEventListener('click',function(){state.levels[i][dir]=lv+1;render()});head.appendChild(more);if(hidden>1){var all=el('button','more','Show all');all.type='button';all.addEventListener('click',function(){state.levels[i][dir]=Infinity;render()});head.appendChild(all)}}else if(total>DATA.defaultLevels&&lv>DATA.defaultLevels){var less=el('button','more','Back to '+DATA.defaultLevels+' levels');less.type='button';less.addEventListener('click',function(){state.levels[i][dir]=DATA.defaultLevels;render()});head.appendChild(less)}s.appendChild(head);if(sec.error){s.appendChild(el('div','empty',sec.error));return s}var shown=sec.hops.filter(function(h){return h.hop<=lv});if(!shown.length)s.appendChild(el('div','empty',dir==='up'?'Nothing upstream was traced for this column.':'No downstream model carries this column\\u2019s value.'));if(dir==='up')shown=shown.slice().reverse();shown.forEach(function(h){s.appendChild(hopBlock(h,dir))});if(sec.truncated)s.appendChild(el('div','note warn','The trace stopped at its limit: more may sit beyond the last level.'));return s}
+function stat(n,label,dim){var d=el('div','stat'+(dim?' dim':''));d.appendChild(el('b',null,n==null?'\\u2013':n));d.appendChild(el('span',null,label));return d}
+function fold(title,count,items){var d=el('details','panel fold');var s=el('summary',null,title+' ');s.appendChild(el('span',null,'('+(count==null?'not reported':count)+')'));d.appendChild(s);var ul=el('ul');items.forEach(function(it){ul.appendChild(it)});if(!items.length)ul.appendChild(el('li','why',count==null?'Not reported by this altimate-code build.':count?'Only the count is known.':'None.'));d.appendChild(ul);return d}
+function li(name,rest){var l=el('li');l.appendChild(el('span','mono',name));if(rest){l.appendChild(document.createTextNode(' '));l.appendChild(el('span','why',rest))}return l}
+function render(){
+  var f=DATA.focuses[state.focus],i=state.focus;app.textContent='';
+  var bar=el('div','pathbar');bar.id='pathbar';var wrap=el('div','wrap');wrap.appendChild(bar);
+  var top=el('header','top');top.appendChild(el('h1',null,DATA.title));top.appendChild(el('span','when','Generated '+DATA.generatedAt+' \\u00b7 downstream read from '+DATA.manifest));wrap.appendChild(top);
+  var ch=el('div','panel changes');ch.appendChild(el('h2',null,'What this task changed'));DATA.changes.forEach(function(c){var m=el('div','change-model mono',c.model);m.appendChild(el('span','file',c.file));ch.appendChild(m);if(!c.columns.length){ch.appendChild(el('div','empty','No output column changed (a filter or a join): only the model-level count applies.'));return}var d=el('div','diff');c.columns.forEach(function(col){d.appendChild(el('div','col-name mono',col.name));var was=el('div','was mono'+(col.before?'':' none'),col.before||'(not in the model before)');var now=el('div','now mono'+(col.after?'':' none'),col.after||'(removed)');if(col.before&&col.after&&col.before===col.after){d.appendChild(el('div','same','Expression unchanged; the column is named on a changed line.'));d.appendChild(el('div'))}else{d.appendChild(was);d.appendChild(now)}});ch.appendChild(d)});wrap.appendChild(ch);
+  if(DATA.focuses.length>1){var tabs=el('div','tabs');tabs.setAttribute('role','tablist');DATA.focuses.forEach(function(g,j){var t=el('button','tab',g.column?g.model+'.'+g.column:g.model+' (model)');t.type='button';t.setAttribute('role','tab');t.setAttribute('aria-selected',j===i?'true':'false');t.addEventListener('click',function(){state.focus=j;state.selected=null;render()});tabs.appendChild(t)});wrap.appendChild(tabs)}
+  var r=f.reach,stats=el('div','stats');
+  if(r){stats.appendChild(stat(r.columns,'columns downstream'));stats.appendChild(stat(r.models,'models carry it'));stats.appendChild(stat(r.ends,'end columns'));stats.appendChild(stat(r.mayCarry,'may carry it',!r.mayCarry));stats.appendChild(stat(r.cleared,'cleared',r.cleared==null))}
+  stats.appendChild(stat(f.modelLevel,'downstream at model level',true));wrap.appendChild(stats);
+  if(r&&(r.unresolved||r.truncated))wrap.appendChild(el('div','note warn','\\u26a0 Lower bound: '+[r.unresolved?plural(r.unresolved,'model')+' could not be read':'',r.truncated?'the trace hit its limit':''].filter(Boolean).join('; ')+'. See \\u201cNot resolved\\u201d below.'));
+  else if(r)wrap.appendChild(el('div','note ok','\\u2713 Every downstream model was read.'));
+  var inp=[];if(f.inputs.engine)inp.push('engine '+f.inputs.engine);inp.push(f.inputs.catalog?'with catalog types':'no catalog: types from the manifest');if(f.inputs.olderThanSql)inp.push('the manifest is older than the SQL');f.inputs.workarounds.forEach(function(w){inp.push(w)});wrap.appendChild(el('div','inputs',inp.join(' \\u00b7 ')));
+  var lg=el('div','legend');['=','~','\\u0192','\\u03a3','?'].forEach(function(g){var s=el('span');s.appendChild(glyph(g,false));s.appendChild(document.createTextNode(HOW[g]));lg.appendChild(s)});var bn=el('span');bn.appendChild(glyph('=',true));bn.appendChild(document.createTextNode('matched by name'));lg.appendChild(bn);var cb=el('span');cb.appendChild(el('span','badge c','C'));cb.appendChild(document.createTextNode(' contract enforced'));lg.appendChild(cb);wrap.appendChild(lg);
+  wrap.appendChild(section(f,i,'up'));
+  var fc=el('div','panel focus');fc.appendChild(el('div','label','The changed column'));var ti=el('div','title');if(f.key){ti.appendChild(colButton({key:f.key,column:f.model+'.'+(f.column||''),glyph:f.glyph||'?',byName:f.byName,end:false,type:null}))}else ti.appendChild(el('span','mono',f.column?f.model+'.'+f.column:f.model));fc.appendChild(ti);if(f.glyph)var hw=HOW[f.glyph]||'unknown';fc.appendChild(el('div','empty',hw.charAt(0).toUpperCase()+hw.slice(1)+' from what it reads'+(f.byName?' (matched by name)':'')+'. Click any column to light up its path.'));wrap.appendChild(fc);
+  wrap.appendChild(section(f,i,'down'));
+  wrap.appendChild(fold('Also reads it, outside the select',f.alsoReads.length,f.alsoReads.map(function(a){return li(a.name,'reads '+a.columns.join(', ')+(a.downstream!=null?' \\u00b7 '+plural(a.downstream,'model')+' downstream of it':''))})));
+  wrap.appendChild(fold('Not resolved',f.unresolved.length,f.unresolved.map(function(u){return li(u.name,u.reason+(u.downstream!=null?' \\u00b7 '+plural(u.downstream,'model')+' downstream of it':''))})));
+  wrap.appendChild(fold('Cleared: downstream, but does not carry it',f.cleared.count,f.cleared.names.map(function(n){return li(n,'')})));
+  app.appendChild(wrap);applyHighlight();
+}
+function select(key){state.selected=state.selected===key?null:key;applyHighlight()}
+function applyHighlight(){var f=DATA.focuses[state.focus],bar=document.getElementById('pathbar');var cols=document.querySelectorAll('.col');if(!state.selected){document.body.classList.remove('hl');cols.forEach(function(c){c.classList.remove('on','sel')});document.querySelectorAll('.model').forEach(function(m){m.classList.remove('has-on')});return}
+  var p=pathOf(f,state.selected);document.body.classList.add('hl');cols.forEach(function(c){var on=!!p.all[c.dataset.key];c.classList.toggle('on',on);c.classList.toggle('sel',c.dataset.key===state.selected)});document.querySelectorAll('.model').forEach(function(m){m.classList.toggle('has-on',!!m.querySelector('.col.on'))});
+  var shown={};cols.forEach(function(c){shown[c.dataset.key]=1});var hidden=Object.keys(p.all).filter(function(k){return!shown[k]}).length;
+  bar.textContent='';bar.appendChild(el('span',null,'Path of '+state.selected.split('|').pop()+': '+plural(p.up,'column')+' upstream, '+plural(p.down,'column')+' downstream'+(hidden?' \\u00b7 '+hidden+' more on hidden levels':'')));var clr=el('button',null,'Clear');clr.type='button';clr.addEventListener('click',function(){select(state.selected)});bar.appendChild(clr)}
+document.addEventListener('keydown',function(e){if(e.key==='Escape'&&state.selected)select(state.selected)});
+render();
+})();
+`
+
+/** The command that opens a file in the person's browser, per platform; null when none applies. */
+export type Platform = 'mac' | 'linux' | 'wsl' | 'windows'
+export function openerFor(platform: Platform, path: string, wsl: { wslview: boolean; windowsPath?: string | null } = { wslview: false }): { argv: string[]; okExits: number[] } | null {
+  if (platform === 'mac') return { argv: ['open', path], okExits: [0] }
+  if (platform === 'linux') return { argv: ['xdg-open', path], okExits: [0] }
+  if (platform === 'windows') return { argv: ['cmd', '/c', 'start', '', path], okExits: [0] }
+  if (wsl.wslview) return { argv: ['wslview', path], okExits: [0] }
+  // explorer.exe exits 1 even when it opened the file.
+  return wsl.windowsPath ? { argv: ['explorer.exe', wsl.windowsPath], okExits: [0, 1] } : null
+}
diff --git a/plugins/altimate-code/hooks/integrations.tsx b/plugins/altimate-code/hooks/integrations.tsx
index 256131b..198038a 100644
--- a/plugins/altimate-code/hooks/integrations.tsx
+++ b/plugins/altimate-code/hooks/integrations.tsx
@@ -3,7 +3,8 @@ import type { EngineInterface, Register } from 'claude-code'
 
 import type { Busy, Expanded, Form, IntegrationsStatus, Provider, ProviderId, WorkspaceChoice } from '../types'
 import { MISSING_BINARY, later, parseJson, runAltimate } from './altimate-cli'
-import { lineageBand, registerLineage, startLineage } from './lineage'
+import { registerLineage, startLineage } from './lineage'
+import { registerTaskImpact, startTaskImpact, taskBand } from './task-impact'
 
 const PANE = 'altimate-integrations'
 const PANE_TITLE = 'Altimate integrations'
@@ -560,6 +561,7 @@ export const register: Register = on => {
     })
     // The lineage half failing to start must not stop this pane's own setup below.
     await startLineage($).catch(error => $.ui.log(`lineage-pane · could not start: ${String(error)}`))
+    await startTaskImpact($).catch(error => $.ui.log(`lineage-summary · could not start: ${String(error)}`))
     // A press that was running when an earlier session ended can never finish, so it must not block this one.
     await update($, busy, () => null)
     // A `-p` run or the SDK has nobody to show the band to, so it does not scan the machine.
@@ -580,9 +582,9 @@ export const register: Register = on => {
   })
 
   on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
-    // One band per plugin: the lineage impact line rides under the integrations one, or alone.
+    // One band per plugin: the end-of-task lineage summary rides under the integrations one, or alone.
     if (e.props.hasSurvey) return next(e)
-    const lineage = await lineageBand($, $.ui.resolve(e))
+    const lineage = await taskBand($, $.ui.resolve(e))
     const pass = async () => lineage ?? next(e)
     const current = await read($, status)
     if (!current || (await read($, isBandHidden))) return pass()
@@ -796,6 +798,7 @@ export const register: Register = on => {
   })
 
   registerLineage(on)
+  registerTaskImpact(on)
 }
 
 // One row of buttons per provider, chosen by its state. Credentials are added
diff --git a/plugins/altimate-code/hooks/lineage.test.tsx b/plugins/altimate-code/hooks/lineage.test.tsx
index e8e18fb..31a9fc5 100644
--- a/plugins/altimate-code/hooks/lineage.test.tsx
+++ b/plugins/altimate-code/hooks/lineage.test.tsx
@@ -66,6 +66,8 @@ async function start($: any, on: any, options: Options = {}) {
   const clock = mock.clock(on)
   const calls: string[] = []
   const toasts: string[] = []
+  // The per-edit impact note: logged for the record, never a toast (the person sees the end-of-task summary).
+  const notes: string[] = []
   const logs: string[] = []
   const lists: string[] = []
   on('command.register', () => ({ value: { command: 'lineage' } }))
@@ -82,6 +84,7 @@ async function start($: any, on: any, options: Options = {}) {
   })
   on('ui.log', (_: unknown, e: { text: string }) => {
     logs.push(e.text)
+    if (e.text.startsWith('◆ impact-first · ') && !e.text.startsWith('◆ impact-first · impact_analysis(')) notes.push(e.text)
     return { value: undefined }
   })
   on('ui.render', ($$: any, e: any) => {
@@ -188,7 +191,7 @@ async function start($: any, on: any, options: Options = {}) {
   })
   await $.session.start({ cwd: ROOT, surface: 'terminal', isInteractive: true })
   await clock.settle()
-  return { clock, calls, toasts, logs, lists }
+  return { clock, calls, toasts, notes, logs, lists }
 }
 
 test('reading a model points the pane at it: the manifest graph, then its columns from dbt_lineage', async ($, on) => {
@@ -209,26 +212,23 @@ test('reading a model points the pane at it: the manifest graph, then its column
   await ui.unmount()
 })
 
-test('an edit naming a column is held until its reach is known, then the reach goes to Claude and the band', async ($, on) => {
-  const { clock, calls, toasts, logs } = await start($, on)
+test('an edit naming a column is held until its reach is known, then the reach goes to Claude and the log, not the person', async ($, on) => {
+  const { clock, calls, toasts, notes, logs } = await start($, on)
   const edit = { tool: 'Edit' as const, file_path: FILE, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) - sum(refunds) as revenue' }
   const result: any = await $.tool.call(edit)
   await clock.settle()
 
   // The reach is looked up before the edit runs.
   expect(calls.indexOf('mcp:impact_analysis:revenue')).toBeLessThan(calls.indexOf('tool:Edit'))
-  expect(toasts[0]).toBe('◆ impact-first · fct_orders.revenue is read by 2 models and 1 dashboard · Exec Revenue')
+  expect(notes[0]).toBe('◆ impact-first · fct_orders.revenue is read by 2 models and 1 dashboard · Exec Revenue')
+  expect(toasts).toEqual([])
   expect(result.context?.[0]).toContain('read by 2 downstream models: fct_revenue_daily (revenue), rpt_finance_weekly (revenue)')
   expect(result.context?.[0]).toContain('dashboards on them: "Exec Revenue"')
   expect(logs).toContain("impact-first · added to Claude's context: lineage for fct_orders.revenue")
 
+  // The band waits for the end of the task (task-impact.tsx): nothing per edit.
   const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
-  expect(await band.find({ type: 'Text', text: 'fct_orders.revenue' })).toBeDefined()
-  expect(await band.find({ type: 'Text', text: 'MEDIUM' })).toBeDefined()
-  expect(await band.find({ type: 'Text', text: /direct 5 · transitive 1 · tests 1 · read by 2 models · 1 dashboards/ })).toBeDefined()
-  await band.press({ key: 'lineage-dismiss' })
-  await clock.settle()
-  expect(await band.find({ key: 'lineage-open' })).toBeUndefined()
+  expect(await band.find({ type: 'Text', text: /fct_orders\.revenue/ })).toBeUndefined()
   await band.unmount()
 
   // The same column again adds nothing new to Claude's context.
@@ -352,7 +352,7 @@ test('/lineage names a model and column; an unknown model says so', async ($, on
 })
 
 test('a manifest over 4 MiB is read through altimate-code: the graph comes from dbt_lineage with include_graph', async ($, on) => {
-  const { clock, calls, toasts } = await start($, on, { size: 6 * 1024 * 1024 })
+  const { clock, calls, notes } = await start($, on, { size: 6 * 1024 * 1024 })
   await $.tool.call({ tool: 'Read', file_path: FILE })
   await clock.settle()
   expect(calls).toEqual(['tool:Read', 'cli:dbt_lineage:graph'])
@@ -365,7 +365,7 @@ test('a manifest over 4 MiB is read through altimate-code: the graph comes from
   // Impact-first works on the same path.
   await $.tool.call({ tool: 'Edit', file_path: FILE, old_string: 'x as revenue', new_string: 'y as revenue' })
   await clock.settle()
-  expect(toasts[0]).toContain('fct_orders.revenue is read by 2 models')
+  expect(notes[0]).toContain('fct_orders.revenue is read by 2 models')
 })
 
 test('a recompiled manifest is a new focus: the column lineage is read again', async ($, on) => {
@@ -384,17 +384,14 @@ test('a recompiled manifest is a new focus: the column lineage is read again', a
 
 test('a subagent gets the lineage context the main agent already got, and an untraced model keeps the count a lower bound', async ($, on) => {
   const reach = { ...REACH, column_reach: { ...REACH.column_reach, untraced: [{ name: 'mart_cohort_ltv', reason: 'No compiled SQL found' }], uncertain: [] } }
-  const { clock, toasts } = await start($, on, { reach })
+  const { clock, notes } = await start($, on, { reach })
   const edit = { tool: 'Edit' as const, file_path: FILE, old_string: 'x as revenue', new_string: 'y as revenue' }
   const main: any = await $.tool.call(edit)
   const sub: any = await $.tool.call({ ...edit, agentId: 'sub-1' } as any)
   await clock.settle()
-  expect(toasts[0]).toContain('is read by at least 2 models')
+  expect(notes[0]).toContain('is read by at least 2 models')
   expect(main.context?.[0]).toContain('could not be traced: mart_cohort_ltv ("No compiled SQL found")')
   expect(sub.context?.[0]).toContain('read by at least 2 downstream models')
-  const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
-  expect(await band.find({ type: 'Text', text: /read by at least 2 models/ })).toBeDefined()
-  await band.unmount()
 })
 
 test('a read Claude makes outside a dbt project stays quiet', async ($, on) => {
@@ -444,10 +441,10 @@ test("a dbt_lineage result Claude's call got cut for size leaves the pane to fet
 
 test('dashboards on models that may read the column are counted and named', async ($, on) => {
   const reach = { ...REACH, column_reach: { ...REACH.column_reach, uncertain: [{ name: 'rpt_ops', reason: 'names it only outside its select list' }], uncertain_exposures: [{ name: 'ops', label: 'Ops Board' }] } }
-  const { clock, toasts } = await start($, on, { reach })
+  const { clock, notes } = await start($, on, { reach })
   const edit: any = await $.tool.call({ tool: 'Edit', file_path: FILE, old_string: 'x as revenue', new_string: 'y as revenue' })
   await clock.settle()
-  expect(toasts[0]).toBe('◆ impact-first · fct_orders.revenue is read by at least 2 models and 2 dashboards · Exec Revenue · Ops Board')
+  expect(notes[0]).toBe('◆ impact-first · fct_orders.revenue is read by at least 2 models and 2 dashboards · Exec Revenue · Ops Board')
   expect(edit.context?.[0]).toContain('dashboards on models that may read it: "Ops Board"')
 })
 
@@ -465,28 +462,28 @@ test('/lineage on the same model with another column traces that column', async
   await ui.unmount()
 })
 
-test('the impact toast shows before the edit runs', async ($, on) => {
-  const { clock, toasts } = await start($, on, { toolResult: e => (e.tool === 'Edit' ? { toastsSoFar: toasts.length } : undefined) })
+test('the impact note is logged before the edit runs', async ($, on) => {
+  const { clock, notes } = await start($, on, { toolResult: e => (e.tool === 'Edit' ? { notesSoFar: notes.length } : undefined) })
   const result: any = await $.tool.call({ tool: 'Edit', file_path: FILE, old_string: 'x as revenue', new_string: 'y as revenue' })
   await clock.settle()
-  expect(result.result).toEqual({ toastsSoFar: 1 })
+  expect(result.result).toEqual({ notesSoFar: 1 })
 })
 
 test('an edit touching two columns traces both and reports their combined reach', async ($, on) => {
-  const { clock, calls, toasts } = await start($, on)
+  const { clock, calls, notes } = await start($, on)
   await $.tool.call({ tool: 'Edit', file_path: FILE, old_string: 'i.revenue, i.order_id', new_string: 'coalesce(i.revenue, 0) as revenue, i.order_id + 0 as order_id' })
   await clock.settle()
   expect(calls).toContain('mcp:impact_analysis:revenue')
   expect(calls).toContain('mcp:impact_analysis:order_id')
-  expect(toasts[0]).toContain('fct_orders.')
-  expect(toasts[0]).toContain('is read by 2 models and 1 dashboard')
+  expect(notes[0]).toContain('fct_orders.')
+  expect(notes[0]).toContain('is read by 2 models and 1 dashboard')
 })
 
 test('a touched column whose check fails keeps the combined count a lower bound', async ($, on) => {
-  const { clock, toasts } = await start($, on, { failColumn: 'order_id' })
+  const { clock, notes } = await start($, on, { failColumn: 'order_id' })
   const edit: any = await $.tool.call({ tool: 'Edit', file_path: FILE, old_string: 'i.revenue, i.order_id', new_string: 'coalesce(i.revenue, 0) as revenue, i.order_id + 0 as order_id' })
   await clock.settle()
-  expect(toasts[0]).toContain('fct_orders.revenue is read by at least 2 models')
+  expect(notes[0]).toContain('fct_orders.revenue is read by at least 2 models')
   expect(edit.context?.[0]).toContain('columns not checked (over the limit or no answer in time): order_id')
 })
 
@@ -500,7 +497,7 @@ test('a new unchecked column in the same turn still reaches Claude', async ($, o
 })
 
 test('columns beyond the cap are named as unchecked and make the count a lower bound', async ($, on) => {
-  const { clock, calls, toasts } = await start($, on)
+  const { clock, calls, notes } = await start($, on)
   const edit: any = await $.tool.call({
     tool: 'Edit',
     file_path: FILE,
@@ -509,7 +506,7 @@ test('columns beyond the cap are named as unchecked and make the count a lower b
   })
   await clock.settle()
   expect(calls.filter(call => call.startsWith('mcp:impact_analysis'))).toHaveLength(3)
-  expect(toasts[0]).toContain('is read by at least 2 models')
+  expect(notes[0]).toContain('is read by at least 2 models')
   expect(edit.context?.[0]).toMatch(/columns not checked \(over the limit or no answer in time\): \w+;/)
 })
 
@@ -1042,22 +1039,22 @@ test('an older column-reach answer does not replace the newer one', async ($, on
   await ui.unmount()
 })
 
-test('when the whole lookup runs out of time, a toast says the edit went ahead without lineage', async ($, on) => {
-  const { clock, toasts } = await start($, on, { holdFirstManifestRead: new Promise<void>(() => {}) })
+test('when the whole lookup runs out of time, the log says the edit went ahead without lineage', async ($, on) => {
+  const { clock, notes } = await start($, on, { holdFirstManifestRead: new Promise<void>(() => {}) })
   const call = $.tool.call({ tool: 'Edit', file_path: FILE, old_string: 'x as revenue', new_string: 'y as revenue' })
   await clock.advance(9_000)
   await call
   await clock.settle()
-  expect(toasts).toContain('◆ impact-first · the lineage lookup did not finish in time; the edit went ahead without it')
+  expect(notes).toContain('◆ impact-first · the lineage lookup did not finish in time; the edit went ahead without it')
 })
 
-test('a .sql file outside any dbt project gets no timeout toast', async ($, on) => {
-  const { clock, toasts } = await start($, on)
+test('a .sql file outside any dbt project gets no timeout note', async ($, on) => {
+  const { clock, notes } = await start($, on)
   const call = $.tool.call({ tool: 'Edit', file_path: '/elsewhere/migrations/001.sql', old_string: 'a', new_string: 'b' })
   await clock.advance(9_000)
   await call
   await clock.settle()
-  expect(toasts).toEqual([])
+  expect(notes).toEqual([])
 })
 
 test("the pane reads the dbt integration's model lineage from altimate-code", async ($, on) => {
@@ -1140,14 +1137,11 @@ test("project text in the impact note is one line per name, quoted, capped, and
 })
 
 test('an unreadable dashboards section keeps the dashboard count a lower bound', async ($, on) => {
-  const { clock, toasts } = await start($, on, { reach: { ...REACH, exposures_error: 'exposures: bad yaml' } })
+  const { clock, notes } = await start($, on, { reach: { ...REACH, exposures_error: 'exposures: bad yaml' } })
   const edit: any = await $.tool.call({ tool: 'Edit', file_path: FILE, old_string: 'x as revenue', new_string: 'y as revenue' })
   await clock.settle()
-  expect(toasts[0]).toBe('◆ impact-first · fct_orders.revenue is read by 2 models and at least 1 dashboard · Exec Revenue')
+  expect(notes[0]).toBe('◆ impact-first · fct_orders.revenue is read by 2 models and at least 1 dashboard · Exec Revenue')
   expect(edit.context?.[0]).toContain('the dashboards could not be read ("exposures: bad yaml")')
-  const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
-  expect(await band.find({ type: 'Text', text: /at least 1 dashboards/ })).toBeDefined()
-  await band.unmount()
 })
 
 test('no column trace starts once the hold has run out', async ($, on) => {
diff --git a/plugins/altimate-code/hooks/lineage.tsx b/plugins/altimate-code/hooks/lineage.tsx
index 2e72a34..fb82e8e 100644
--- a/plugins/altimate-code/hooks/lineage.tsx
+++ b/plugins/altimate-code/hooks/lineage.tsx
@@ -1,5 +1,5 @@
 import { atom, read, update } from 'claude-code'
-import type { EngineInterface, On, RenderElement } from 'claude-code'
+import type { EngineInterface, On } from 'claude-code'
 
 import type {
   AnswerModel,
@@ -33,6 +33,7 @@ import {
   upstreamArt,
   warehouseEdges,
 } from './lineage-graph'
+import { taskBeforeTool, taskTurnComplete, taskTurnStart } from './task-impact'
 
 const PANE = 'altimate-lineage'
 const PANE_TITLE = 'Altimate lineage'
@@ -67,10 +68,8 @@ let revealFor: string | null = null
 const answerAtom = atom({ plugin: 'altimate-code', key: 'lineageAnswer' } as const, [] as AnswerModel[])
 // Where the graph canvas is panned to: its first visible column; null centres it on the model.
 const panAtom = atom({ plugin: 'altimate-code', key: 'lineagePan' } as const, null as number | null)
-const impactAtom = atom({ plugin: 'altimate-code', key: 'lineageImpact' } as const, null, { shape: 'lineage-impact-1' })
 const messageAtom = atom({ plugin: 'altimate-code', key: 'lineageMessage' } as const, null as string | null)
 const loadingAtom = atom({ plugin: 'altimate-code', key: 'lineageLoading' } as const, false)
-const bandHiddenAtom = atom({ plugin: 'altimate-code', key: 'isLineageBandHidden' } as const, false)
 
 // Caches, rebuilt from the manifest file after a reload.
 let manifestCache: { path: string; mtimeMs: number; graph: LineageGraph } | null = null
@@ -135,7 +134,7 @@ const SEVERITY_COLOR: Record<ImpactView['severity'], string> = {
 }
 
 /** Resolves with the work's value, or null once `ms` pass or it fails. */
-function within<T>($: EngineInterface, ms: number, work: Promise<T>): Promise<T | null> {
+export function within<T>($: EngineInterface, ms: number, work: Promise<T>): Promise<T | null> {
   return new Promise(resolve => {
     let settled = false
     const settle = (value: T | null) => {
@@ -167,7 +166,7 @@ const dirname = (path: string) => path.replace(/[\\/][^\\/]*$/, '') || path
 const relative = (root: string, path: string) => path.slice(root.length).replace(/^[\\/]+/, '').replace(/\\/g, '/')
 
 /** The dbt project above a file or folder: the closest folder holding dbt_project.yml. */
-async function projectRoot($: EngineInterface, start: string, isFile: boolean): Promise<string | null> {
+export async function projectRoot($: EngineInterface, start: string, isFile: boolean): Promise<string | null> {
   let dir = isFile ? dirname(start) : start
   for (let i = 0; i < 40; i++) {
     if (await $.fs.exists(`${dir}/dbt_project.yml`).catch(() => false)) return dir
@@ -406,7 +405,7 @@ function fileUriPath(uri: string): string {
  * `cliOnly` goes straight to the CLI, whose --json carries the whole metadata; a structured result
  * the server left out for size is fetched that way too.
  */
-async function runTool($: EngineInterface, name: string, args: Record<string, unknown>, cliOnly = false, until?: number) {
+export async function runTool($: EngineInterface, name: string, args: Record<string, unknown>, cliOnly = false, until?: number) {
   // With a deadline, nothing starts once it has passed, and the CLI is stopped at it.
   const left = async () => {
     const ms = until === undefined ? TOOL_TIMEOUT_MS : until - (await $.clock.now())
@@ -857,7 +856,7 @@ function cut(text: string, max: number): string {
 
 /**
  * Before an edit to a model's SQL: what reads the model, and, when the edit changes one of its
- * columns, which downstream models and dashboards read that column. Shown as a toast, then added to
+ * columns, which downstream models and dashboards read that column. Logged, then added to
  * Claude's context with the edit's result.
  */
 async function impactFirst($: EngineInterface, e: any, file: string, deadline: number, progress: { project: boolean }): Promise<ImpactNote | null> {
@@ -1012,36 +1011,6 @@ export async function startLineage($: EngineInterface) {
 
 type Ui = { Box: any; Button: any; Text: any }
 
-/** The band line after Claude edits a model; drawn by the plugin's one band hook. */
-export async function lineageBand($: EngineInterface, ui: Ui): Promise<RenderElement | null> {
-  const impact = await read($, impactAtom)
-  if (!impact || (await read($, bandHiddenAtom))) return null
-  const { Box, Button, Text } = ui
-  const target = impact.column ? `${impact.model}.${impact.column}` : impact.model
-  // One Text, so a narrow band wraps it as a line, not word by word in each piece.
-  return (
-    <Box key="lineage-band" flexDirection="column">
-      <Text>
-        <Text color="warning">⚠ Impact </Text>
-        <Text bold>{target}</Text>
-        <Text dimColor> (modify) </Text>
-        <Text color={SEVERITY_COLOR[impact.severity]} bold>
-          {impact.severity}
-        </Text>
-        <Text dimColor>
-          {'  '}direct {impact.direct} · transitive {impact.transitive}{impact.truncated ? '+' : ''} · tests {impact.tests}
-          {impact.readers !== null ? ` · read by ${impact.unsettled ? 'at least ' : ''}${impact.readers} models` : ''}
-          {impact.exposures.length || impact.dashboardsUnsettled ? ` · ${impact.dashboardsUnsettled ? 'at least ' : ''}${impact.exposures.length} dashboards` : ''}
-        </Text>
-      </Text>
-      <Box>
-        <Button key="lineage-open" label="Open lineage" onPress={() => later($, () => openPane($))} />
-        <Button key="lineage-dismiss" label="Dismiss" onPress={() => update($, bandHiddenAtom, () => true)} />
-      </Box>
-    </Box>
-  )
-}
-
 function drawRow(ui: Ui, $: EngineInterface, graph: LineageGraph, segments: Segment[], key: string) {
   const { Box, Button, Text } = ui
   return (
@@ -1084,6 +1053,8 @@ export function registerLineage(on: On) {
     if (!(e as { agentId?: string }).agentId) {
       contextGiven.clear()
       turnCount++
+      // The end-of-task summary's share of these events (a plugin hooks each event once).
+      await taskTurnStart($).catch(error => $.ui.log(`lineage-summary · task start: ${String(error)}`))
     }
     return next(e)
   })
@@ -1092,6 +1063,7 @@ export function registerLineage(on: On) {
   // answered from memory) it follows the first one named, so the pane shows what the answer is about.
   on('turn.complete', async ($, e, next) => {
     const out = await next(e)
+    taskTurnComplete($, e as { agentId?: string })
     if ((e as { agentId?: string }).agentId || e.reason !== 'answer' || !out.text) return out
     const text = out.text
     const turn = turnCount
@@ -1152,6 +1124,8 @@ export function registerLineage(on: On) {
 
   // Follow the model Claude reads or edits; before an edit lands, look up what it reaches.
   on('tool.call', async ($, e, next) => {
+    // Never holds an edit back on its own failure.
+    await taskBeforeTool($, e).catch(error => $.ui.log(`lineage-summary · before ${e.tool}: ${String(error)}`))
     const file = (EDIT_TOOLS.has(e.tool) || e.tool === 'Read') && 'file_path' in e ? String(e.file_path) : null
     const isSql = !!file && /\.sql$/i.test(file)
     const isEdit = isSql && EDIT_TOOLS.has(e.tool)
@@ -1165,9 +1139,10 @@ export function registerLineage(on: On) {
     }
     const note = lookup ? await within($, HOLD_TOTAL_MS, lookup) : null
     // Out of time before even the model-level lookup finished: say so, rather than nothing.
-    if (lookup && !note && !finished && progress.project) $.ui.toast('◆ impact-first · the lineage lookup did not finish in time; the edit went ahead without it', { timeoutMs: 8000 })
-    // Before the edit runs: the point is to see what it reaches first.
-    if (note) $.ui.toast(note.toast, { timeoutMs: 8000 })
+    // The person sees the end-of-task summary (task-impact.tsx), not a note per edit: these lines go
+    // to the log, and the note itself to Claude's context below.
+    if (lookup && !note && !finished && progress.project) $.ui.log('◆ impact-first · the lineage lookup did not finish in time; the edit went ahead without it')
+    if (note) $.ui.log(note.toast)
     const result = await next(e)
     if (result.deny || result.isError) return result
     // After the edit lands: a .sql file or dbt_project.yml changed, so the SQL-file graphs are stale.
@@ -1218,8 +1193,6 @@ export function registerLineage(on: On) {
       }
     }
     if (note) {
-      await update($, impactAtom, () => note.view)
-      await update($, bandHiddenAtom, () => false)
       if (!contextGiven.has(note.key)) {
         contextGiven.add(note.key)
         $.ui.log(`impact-first · added to Claude's context: lineage for ${note.view.column ? `${note.view.model}.${note.view.column}` : note.view.model}`)
diff --git a/plugins/altimate-code/hooks/task-impact.test.tsx b/plugins/altimate-code/hooks/task-impact.test.tsx
new file mode 100644
index 0000000..63e78ca
--- /dev/null
+++ b/plugins/altimate-code/hooks/task-impact.test.tsx
@@ -0,0 +1,261 @@
+import { expect, mock, test } from 'claude-code/testing'
+
+import { DOWN, UP, embedded } from './impact-report.test'
+
+const ROOT = '/repo'
+const MANIFEST = `${ROOT}/target/manifest.json`
+const SNAPSHOT = `${ROOT}/target/.altimate-lineage/manifest-before.json`
+const REPORT = `${ROOT}/target/.altimate-lineage/report.html`
+const MODEL = `${ROOT}/models/fct_orders.sql`
+const STAGING = `${ROOT}/models/stg_payments.sql`
+const MACRO = `${ROOT}/macros/cents.sql`
+
+const BAND = {
+  plugin: 'altimate-code',
+  component: 'AbovePrompt',
+  props: { hasSurvey: false, isWorking: false, maxRows: 10, bodyColumns: 120, scroll: { offset: 0, bodyRows: 10 }, view: {} },
+} as const
+
+const ORDERS_SQL = 'select\n  order_id,\n  sum(amount) as revenue\nfrom {{ ref("int_orders") }}\ngroup by 1\n'
+const PAYMENTS_SQL = 'select\n  payment_id,\n  amount_cents / 100 as amount\nfrom {{ source("raw", "payments") }}\nwhere status = \'ok\'\n'
+
+type Options = {
+  /** What `uname -s` prints; null when it cannot start (Windows). */
+  uname?: string | null
+  /** Exit code per opener command; a command missing here cannot start. */
+  openers?: Record<string, number>
+  /** Files git sees as changed against HEAD, project-relative. */
+  gitChanged?: () => string[]
+  /** HEAD's text per project-relative path. */
+  head?: Record<string, string>
+  noManifest?: boolean
+}
+
+/**
+ * A dbt project at /repo in a git repo, its files held in memory (edits apply to them), altimate-code
+ * over MCP answering impact_analysis with a column answer per direction, and an opener per platform.
+ */
+async function start($: any, on: any, options: Options = {}) {
+  const clock = mock.clock(on)
+  const files: Record<string, string> = {
+    [`${ROOT}/dbt_project.yml`]: "name: 'shop'\nmodel-paths: ['models']\n",
+    [MODEL]: ORDERS_SQL,
+    [STAGING]: PAYMENTS_SQL,
+    [MACRO]: '{% macro cents(x) %}{{ x }} / 100{% endmacro %}',
+  }
+  const runs: string[][] = []
+  const tools: Record<string, any>[] = []
+  const writes = new Map<string, string>()
+  const logs: string[] = []
+  on('command.register', () => ({ value: { command: 'x' } }))
+  on('turn.start', (_: unknown, e: { turnId: string }) => ({ turnId: e.turnId }))
+  on('turn.complete', (_: unknown, e: { answer: string }) => ({ text: e.answer }))
+  on('session.start', (_: unknown, e: { cwd: string }) => ({ cwd: e.cwd }))
+  on('session.root', () => ({ value: ROOT }))
+  on('ui.open', () => ({ value: {} }))
+  on('ui.toast', () => ({ value: undefined }))
+  on('ui.log', (_: unknown, e: { text: string }) => {
+    logs.push(e.text)
+    return { value: undefined }
+  })
+  on('ui.render', ($$: any, e: any) => {
+    const { Box } = $$.ui.resolve(e)
+    return <Box key="engine" />
+  })
+  on('fs.exists', (_: unknown, e: { path: string }) => ({ value: e.path in files || (e.path === MANIFEST && !options.noManifest) || writes.has(e.path) }))
+  on('fs.stat', (_: unknown, e: { path: string }) => {
+    if (e.path === MANIFEST && options.noManifest) throw new Error('ENOENT')
+    return { value: { kind: 'file', size: 50 * 1024 * 1024, mtimeMs: 1, isLink: false } }
+  })
+  on('fs.list', () => ({ value: [] }))
+  on('fs.read', (_: unknown, e: { path: string }) => {
+    if (e.path === MANIFEST) throw new Error('over 4 MiB')
+    if (e.path in files) return { value: files[e.path] }
+    throw new Error(`ENOENT ${e.path}`)
+  })
+  on('fs.write', (_: unknown, e: { path: string; text: string }) => {
+    writes.set(e.path, e.text)
+    return { value: undefined }
+  })
+  on('tool.list', () => ({ value: [] }))
+  on('mcp.connect', () => ({ value: { isConnected: true, server: 'plugin:altimate-code:altimate-code' } }))
+  on('mcp.call', (_: unknown, e: { tool: string; args: Record<string, any> }) => {
+    if (e.tool !== 'impact_analysis') return { value: { content: [], isError: true } }
+    tools.push(e.args)
+    // impactFirst's own call (no direction) gets the older column reach shape.
+    const body = !e.args.direction
+      ? { severity: 'LOW', direct_count: 4, transitive_count: 2, column_reach: { models: [], exposures: [] } }
+      : !e.args.column
+        ? { severity: 'LOW', direct_count: 4, transitive_count: 2 }
+        : { severity: 'LOW', direct_count: 4, transitive_count: 2, column_answer: e.args.direction === 'upstream' ? UP : DOWN }
+    return { value: { content: [{ type: 'text', text: JSON.stringify({ ...body, report: 'Impact' }) }], isError: false } }
+  })
+  on('process.run', (_: unknown, e: { argv: readonly string[] }) => {
+    const argv = [...e.argv]
+    runs.push(argv)
+    const ok = (stdout = '') => ({ value: { exitCode: 0, stdout, stderr: '' } })
+    const [bin] = argv
+    if (bin === 'mkdir' || bin === 'cp') return ok()
+    if (bin === 'git') {
+      const sub = argv[3]
+      if (sub === 'rev-parse') return ok(`${ROOT}\n`)
+      if (sub === 'diff') return ok((options.gitChanged?.() ?? []).join('\n'))
+      if (sub === 'ls-files') return ok('')
+      if (sub === 'show') {
+        const path = argv[4]!.replace(/^HEAD:/, '')
+        return path in (options.head ?? {}) ? ok(options.head![path]) : { value: { exitCode: 128, stdout: '', stderr: 'no such path' } }
+      }
+    }
+    if (bin === 'uname') {
+      if (options.uname === null) throw new Error('ENOENT: uname not found')
+      return ok(`${options.uname ?? 'Linux'}\n`)
+    }
+    if (bin === 'wslpath') return ok('\\\\wsl.localhost\\dev\\repo\\target\\.altimate-lineage\\report.html\n')
+    const code = options.openers?.[bin!]
+    if (code === undefined) throw new Error(`ENOENT: ${bin} not found`)
+    return { value: { exitCode: code, stdout: '', stderr: '' } }
+  })
+  // The tool beneath the plugin: an Edit applies to the files.
+  on('tool.call', (_: unknown, e: any) => {
+    if (e.tool === 'Edit' && e.file_path in files) files[e.file_path] = files[e.file_path]!.replace(e.old_string, e.new_string)
+    if (e.tool === 'Write') files[e.file_path] = e.content
+    return { result: { ok: true } }
+  })
+  await $.session.start({ cwd: ROOT, surface: 'terminal', isInteractive: true })
+  await clock.settle()
+  const turn = async (id: string, work: () => Promise<void>) => {
+    await $.turn.start({ text: 'change it', turnId: id })
+    await clock.settle()
+    await work()
+    await clock.settle()
+    await $.turn.complete({ answer: 'Done.', durationMs: 5, isAborted: false, reason: 'answer', turnId: id } as any)
+    await clock.settle()
+  }
+  return { clock, files, runs, tools, writes, logs, turn }
+}
+
+const directional = (tools: Record<string, any>[]) => tools.filter(one => one.direction)
+
+test('a task start copies the manifest aside, never reading it', async ($, on) => {
+  const { runs, turn } = await start($, on)
+  await turn('t1', async () => {})
+  expect(runs).toContainEqual(['mkdir', '-p', `${ROOT}/target/.altimate-lineage`])
+  expect(runs).toContainEqual(['cp', MANIFEST, SNAPSHOT])
+  expect(runs.findIndex(one => one[0] === 'mkdir')).toBeLessThan(runs.findIndex(one => one[0] === 'cp'))
+})
+
+test('an edited model is traced both ways from the snapshot at the task end, and the band sums it up', async ($, on) => {
+  const { tools, writes, turn, clock, logs } = await start($, on)
+  await turn('t1', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) - sum(refunds) as revenue' })
+    // A second edit of the same file: the original stays the one from before the first.
+    await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'order_id,', new_string: 'order_id ,' })
+  })
+  expect(directional(tools)).toEqual([
+    { manifest_path: SNAPSHOT, model: 'fct_orders', column: 'revenue', change_type: 'modify', direction: 'downstream' },
+    { manifest_path: SNAPSHOT, model: 'fct_orders', column: 'revenue', change_type: 'modify', direction: 'upstream' },
+  ])
+  expect(logs.some(line => line.startsWith('◆ Lineage after this task'))).toBe(true)
+
+  const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  expect(await band.find({ type: 'Text', text: '◆ Lineage after this task · 1 model changed' })).toBeDefined()
+  expect(await band.find({ type: 'Text', text: 'fct_orders · 6 downstream models at model level' })).toBeDefined()
+  expect(await band.find({ type: 'Text', text: '  revenue Σ  reaches 4 columns in 3 models (2 ends) · 1 may carry it · 2 cleared' })).toBeDefined()
+  expect(await band.find({ type: 'Text', text: '⚠ Lower bound: 1 model could not be read' })).toBeDefined()
+  expect(await band.find({ key: 'lineage-report-open' })).toBeDefined()
+  await band.press({ key: 'lineage-summary-dismiss' })
+  await clock.settle()
+  expect(await band.find({ key: 'lineage-report-open' })).toBeUndefined()
+  await band.unmount()
+
+  const report = embedded(writes.get(REPORT)!)
+  expect(report.changes).toEqual([
+    { model: 'fct_orders', file: 'models/fct_orders.sql', columns: [{ name: 'revenue', before: 'sum(amount) as revenue', after: 'sum(amount) - sum(refunds) as revenue' }] },
+  ])
+  expect(report.focuses[0].down.hops.length).toBe(3)
+  expect(report.focuses[0].up.hops.length).toBe(2)
+})
+
+test('model files changed outside the edit tools are found through git, and only what changed this task', async ($, on) => {
+  let changed: string[] = ['models/fct_orders.sql']
+  const opts = { gitChanged: () => changed, head: { 'models/stg_payments.sql': PAYMENTS_SQL, 'macros/cents.sql': 'x' } }
+  const { tools, files, turn } = await start($, on, opts)
+  await turn('t1', async () => {
+    // A sed in Bash: git sees the file, HEAD has its text before. fct_orders was already dirty
+    // before the task and is untouched by it; a macro is not a model.
+    files[STAGING] = PAYMENTS_SQL.replace('amount_cents / 100 as amount', 'amount_cents / 100.0 as amount')
+    files[MACRO] = 'changed'
+    changed = ['models/fct_orders.sql', 'models/stg_payments.sql', 'macros/cents.sql']
+  })
+  expect(directional(tools).map(one => `${one.model}.${one.column}:${one.direction}`)).toEqual(['stg_payments.amount:downstream', 'stg_payments.amount:upstream'])
+})
+
+test('a change to no output column falls back to the model-level count', async ($, on) => {
+  const { tools, writes, turn } = await start($, on)
+  await turn('t1', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: STAGING, old_string: "status = 'ok'", new_string: "status in ('ok', 'settled')" })
+  })
+  expect(directional(tools)).toEqual([{ manifest_path: SNAPSHOT, model: 'stg_payments', change_type: 'modify', direction: 'downstream' }])
+  const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  expect(await band.find({ type: 'Text', text: 'stg_payments · 6 downstream models at model level' })).toBeDefined()
+  expect(await band.find({ type: 'Text', text: '  no output column changed: the model-level count stands' })).toBeDefined()
+  await band.unmount()
+  expect(embedded(writes.get(REPORT)!).focuses[0]).toMatchObject({ model: 'stg_payments', column: null, modelLevel: 6 })
+})
+
+test('a task that changes no model shows nothing, and the next task clears the last summary', async ($, on) => {
+  const { tools, turn } = await start($, on)
+  await turn('t1', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
+  })
+  await turn('t2', async () => {})
+  expect(directional(tools).length).toBe(2)
+  const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  expect(await band.find({ key: 'lineage-report-open' })).toBeUndefined()
+  await band.unmount()
+})
+
+test('Open report on WSL falls back to explorer.exe, whose exit 1 is success; /lineage-report opens the last report', async ($, on) => {
+  mock.env(on, { WSL_DISTRO_NAME: 'dev' })
+  const { runs, turn, clock } = await start($, on, { openers: { 'explorer.exe': 1 } })
+  await turn('t1', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
+  })
+  const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  await band.press({ key: 'lineage-report-open' })
+  await clock.settle()
+  expect(runs).toContainEqual(['wslview', REPORT])
+  expect(runs).toContainEqual(['wslpath', '-w', REPORT])
+  expect(runs).toContainEqual(['explorer.exe', '\\\\wsl.localhost\\dev\\repo\\target\\.altimate-lineage\\report.html'])
+  // Opened: no fallback path is shown.
+  expect(await band.find({ type: 'Text', text: /No browser opened/ })).toBeUndefined()
+  await band.unmount()
+
+  const out: any = await $.command.run({ command: 'lineage-report', args: '' } as any)
+  expect(out.text).toBe(`Opened the column impact report: ${REPORT}`)
+})
+
+test('when no browser opens, the band shows the report path as a link', async ($, on) => {
+  const { runs, turn, clock } = await start($, on, { uname: 'Linux', openers: { 'xdg-open': 3 } })
+  await turn('t1', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
+  })
+  const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  await band.press({ key: 'lineage-report-open' })
+  await clock.settle()
+  expect(runs).toContainEqual(['xdg-open', REPORT])
+  expect(await band.find({ type: 'Text', text: /No browser opened/ })).toBeDefined()
+  expect(await band.find({ type: 'Link' })).toBeDefined()
+  await band.unmount()
+})
+
+test('macOS opens with open; /lineage-report before any report says so', async ($, on) => {
+  const { runs, turn } = await start($, on, { uname: 'Darwin', openers: { open: 0 } })
+  const none: any = await $.command.run({ command: 'lineage-report', args: '' } as any)
+  expect(none.text).toBe('No column impact report yet: one is written when a task changes a dbt model.')
+  await turn('t1', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
+  })
+  await $.command.run({ command: 'lineage-report', args: '' } as any)
+  expect(runs).toContainEqual(['open', REPORT])
+})
diff --git a/plugins/altimate-code/hooks/task-impact.tsx b/plugins/altimate-code/hooks/task-impact.tsx
new file mode 100644
index 0000000..3912ec0
--- /dev/null
+++ b/plugins/altimate-code/hooks/task-impact.tsx
@@ -0,0 +1,343 @@
+// The end-of-task column impact: what a task changed in its dbt models, how far each changed column's
+// value reaches, as one summary in the band, and a full offline report that opens in the browser.
+import { atom, read, update } from 'claude-code'
+import type { EngineInterface, On, RenderElement } from 'claude-code'
+
+import type { TaskSummaryView } from '../types'
+import { later } from './altimate-cli'
+import {
+  answerOf,
+  changedColumns,
+  type ColumnTrace,
+  type ModelChange,
+  modelLevelOf,
+  openerFor,
+  type Platform,
+  reportData,
+  reportHtml,
+  summaryLines,
+  summaryOf,
+} from './impact-report'
+import { projectLayout } from './lineage-graph'
+import { projectRoot, runTool, within } from './lineage'
+
+export const REPORT_COMMAND = 'lineage-report'
+// Under the project's target/, which dbt already keeps out of git.
+const LINEAGE_DIR = 'target/.altimate-lineage'
+const EDIT_TOOLS = new Set(['Edit', 'Write', 'MultiEdit'])
+// The most changed models one task traces; the rest are named in the log.
+const MAX_MODELS = 5
+// Dirty files whose text is kept at a task's start, per project.
+const MAX_DIRTY = 200
+// The most impact_analysis calls running at once at a task's end.
+const PARALLEL = 4
+// Lines the band shows before pointing at the report.
+const MAX_BAND_LINES = 8
+
+const summaryAtom = atom({ plugin: 'altimate-code', key: 'lineageTaskSummary' } as const, null, { shape: 'lineage-task-summary-1' })
+const hiddenAtom = atom({ plugin: 'altimate-code', key: 'isLineageSummaryHidden' } as const, false)
+
+type Layout = { models: string[] }
+type GitStart = { top: string; dirty: Map<string, string | null> }
+type RootState = { snapshot: string | null; layout: Layout; git: GitStart | null }
+type Task = { roots: Map<string, Promise<RootState>>; originals: Map<string, { root: string; text: string }> }
+
+// The task under way: from a main-loop turn's start to its end.
+let task: Task | null = null
+let lastReport: string | null = null
+let finishSeq = 0
+
+const newTask = (): Task => ({ roots: new Map(), originals: new Map() })
+const relative = (root: string, path: string) => path.slice(root.length).replace(/^[\\/]+/, '').replace(/\\/g, '/')
+const modelName = (file: string) => (file.split(/[\\/]/).pop() ?? file).replace(/\.sql$/i, '')
+
+/** Whether a project-relative path is a model's or a snapshot's SQL. */
+function isModelFile(layout: Layout, rel: string): boolean {
+  if (!/\.sql$/i.test(rel)) return false
+  return layout.models.some(dir => {
+    const clean = dir.replace(/^\.\//, '').replace(/\/+$/, '')
+    return clean === '.' || clean === '' || rel.startsWith(`${clean}/`)
+  })
+}
+
+async function git($: EngineInterface, args: string[]): Promise<string | null> {
+  const result = await $.process.run(['git', ...args], { timeoutMs: 10_000 }).catch(() => null)
+  return result && result.exitCode === 0 ? result.stdout : null
+}
+
+/** The project's model SQL that differs from HEAD, tracked or new, as absolute paths. */
+async function changedSql($: EngineInterface, top: string, root: string, layout: Layout): Promise<string[]> {
+  const tracked = (await git($, ['-C', top, 'diff', '--name-only', 'HEAD'])) ?? ''
+  const fresh = (await git($, ['-C', top, 'ls-files', '--others', '--exclude-standard'])) ?? ''
+  const paths = [...tracked.split('\n'), ...fresh.split('\n')].map(one => one.trim()).filter(Boolean)
+  return [...new Set(paths.map(one => `${top}/${one}`))].filter(abs => abs.startsWith(`${root}/`) && isModelFile(layout, relative(root, abs)))
+}
+
+/**
+ * A project the task works in, once per task: the manifest copied as it stands (so the answer reads
+ * the SQL from before the task, even when Claude recompiles mid-task), the model folders, and the
+ * text of each model file git already sees as changed (so only this task's changes are reported).
+ */
+function prepareRoot($: EngineInterface, t: Task, root: string): Promise<RootState> {
+  const known = t.roots.get(root)
+  if (known) return known
+  const work = (async (): Promise<RootState> => {
+    const layout = projectLayout(await $.fs.read(`${root}/dbt_project.yml`).catch(() => ''))
+    const models = { models: [...layout.models, ...layout.snapshots] }
+    let snapshot: string | null = null
+    const manifest = `${root}/target/manifest.json`
+    if (await $.fs.exists(manifest).catch(() => false)) {
+      // The manifest can be far over the 4 MiB a plugin reads, so it is copied, never read.
+      const dir = `${root}/${LINEAGE_DIR}`
+      const made = await $.process.run(['mkdir', '-p', dir], { timeoutMs: 5_000 }).catch(() => null)
+      const copied = made?.exitCode === 0 ? await $.process.run(['cp', manifest, `${dir}/manifest-before.json`], { timeoutMs: 20_000 }).catch(() => null) : null
+      if (copied?.exitCode === 0) snapshot = `${dir}/manifest-before.json`
+    }
+    const top = (await git($, ['-C', root, 'rev-parse', '--show-toplevel']))?.trim()
+    let gitStart: GitStart | null = null
+    if (top) {
+      const dirty = new Map<string, string | null>()
+      for (const abs of (await changedSql($, top, root, models)).slice(0, MAX_DIRTY)) dirty.set(abs, await $.fs.read(abs).catch(() => null))
+      gitStart = { top, dirty }
+    }
+    return { snapshot, layout: models, git: gitStart }
+  })()
+  t.roots.set(root, work)
+  return work
+}
+
+/** Every model file the task changed, with its text before the task and now. */
+async function collectChanges($: EngineInterface, t: Task): Promise<ModelChange[]> {
+  const files = new Map<string, { root: string; original: string }>()
+  for (const [file, one] of t.originals) files.set(file, { root: one.root, original: one.text })
+  // Files changed some other way (a Bash sed, a script): git knows them, and HEAD or the start of the
+  // task has their text before.
+  for (const [root, pending] of t.roots) {
+    const state = await pending.catch(() => null)
+    if (!state?.git) continue
+    for (const abs of await changedSql($, state.git.top, root, state.layout)) {
+      if (files.has(abs)) continue
+      const atStart = state.git.dirty.get(abs)
+      // Dirty at the start but past the number kept: what it was is unknown, so it is left out.
+      if (atStart === undefined && state.git.dirty.size >= MAX_DIRTY) continue
+      const original = atStart !== undefined ? atStart : ((await git($, ['-C', state.git.top, 'show', `HEAD:${relative(state.git.top, abs)}`])) ?? '')
+      if (original === null) continue
+      files.set(abs, { root, original })
+    }
+  }
+  const changes: ModelChange[] = []
+  for (const [file, one] of files) {
+    const state = await t.roots.get(one.root)?.catch(() => null)
+    if (state && !isModelFile(state.layout, relative(one.root, file))) continue
+    const current = await $.fs.read(file).catch(() => '')
+    if (current === one.original) continue
+    changes.push({ model: modelName(file), file: relative(one.root, file), root: one.root, columns: changedColumns(one.original, current) })
+  }
+  if (changes.length > MAX_MODELS) $.ui.log(`lineage-summary · ${changes.length} models changed; tracing the first ${MAX_MODELS}`)
+  return changes.slice(0, MAX_MODELS)
+}
+
+/** Runs the work items at most `limit` at a time, keeping their order. */
+async function pool<T>(items: (() => Promise<T>)[], limit: number): Promise<T[]> {
+  const out: T[] = new Array(items.length)
+  let next = 0
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, async () => {
+      while (next < items.length) {
+        const i = next++
+        out[i] = await items[i]!()
+      }
+    }),
+  )
+  return out
+}
+
+/** Downstream and upstream answers for each changed column; the model-level count for a model with none. */
+async function traceChanges($: EngineInterface, t: Task, changes: ModelChange[]): Promise<ColumnTrace[]> {
+  const ask = async (change: ModelChange, column: string | null, direction: 'downstream' | 'upstream') => {
+    const state = await t.roots.get(change.root)?.catch(() => null)
+    const manifest = state?.snapshot ?? `${change.root}/target/manifest.json`
+    const args = { manifest_path: manifest, model: change.model, ...(column && { column }), change_type: 'modify', direction }
+    const result = await runTool($, 'impact_analysis', args).catch(() => null)
+    return result?.ok ? result.metadata : null
+  }
+  const jobs: (() => Promise<ColumnTrace>)[] = []
+  for (const change of changes) {
+    if (change.columns.length === 0) {
+      jobs.push(async () => {
+        const meta = await ask(change, null, 'downstream')
+        return { model: change.model, column: null, down: null, up: null, modelLevel: modelLevelOf(meta), failed: meta === null }
+      })
+    }
+    for (const col of change.columns) {
+      jobs.push(async () => {
+        const [down, up] = await Promise.all([ask(change, col.name, 'downstream'), ask(change, col.name, 'upstream')])
+        const downAnswer = answerOf(down)
+        return { model: change.model, column: col.name, down: downAnswer, up: answerOf(up), modelLevel: modelLevelOf(down), failed: !downAnswer }
+      })
+    }
+  }
+  return pool(jobs, PARALLEL / 2)
+}
+
+const stamp = (ms: number) => new Date(ms).toISOString().slice(0, 16).replace('T', ' ') + ' UTC'
+
+/** At a task's end: what changed, traced, summed up in the band, and written as the report. */
+async function finishTask($: EngineInterface, t: Task) {
+  const seq = ++finishSeq
+  const changes = await collectChanges($, t)
+  if (changes.length === 0) return
+  const tracing: TaskSummaryView = {
+    state: 'tracing',
+    models: changes.map(one => ({ name: one.model, modelLevel: null, columns: one.columns.map(col => ({ name: col.name, how: null, reach: null, failed: false })) })),
+    unresolved: 0,
+    truncated: false,
+    report: null,
+    openFailed: false,
+  }
+  await update($, summaryAtom, () => tracing)
+  await update($, hiddenAtom, () => false)
+  const traces = await traceChanges($, t, changes)
+  const root = changes[0]!.root
+  const state = await t.roots.get(root)?.catch(() => null)
+  const data = reportData(changes, traces, stamp(await $.clock.now()), state?.snapshot ? 'the manifest as it was when the task started' : 'target/manifest.json')
+  const path = `${root}/${LINEAGE_DIR}/report.html`
+  let report: string | null = null
+  try {
+    await $.fs.write(path, reportHtml(data))
+    report = path
+    lastReport = path
+  } catch (error) {
+    $.ui.log(`lineage-summary · the report could not be written: ${String(error)}`)
+  }
+  // A newer task finished first: its summary stays.
+  if (seq !== finishSeq) return
+  const view = summaryOf(changes, traces, report)
+  await update($, summaryAtom, () => view)
+  $.ui.log(summaryLines(view).join('\n'))
+}
+
+/** Which opener family this machine has: macOS, Linux, WSL (Linux under Windows), or Windows itself. */
+async function platformOf($: EngineInterface): Promise<Platform> {
+  const uname = await $.process.run(['uname', '-s'], { timeoutMs: 5_000 }).catch(() => null)
+  if (!uname || uname.exitCode !== 0) return 'windows'
+  if (/darwin/i.test(uname.stdout)) return 'mac'
+  if (await $.env.get('WSL_DISTRO_NAME').catch(() => undefined)) return 'wsl'
+  return /microsoft/i.test(await $.fs.read('/proc/version').catch(() => '')) ? 'wsl' : 'linux'
+}
+
+/** Opens the report in the person's browser; false when no opener worked. */
+export async function openReport($: EngineInterface, path: string): Promise<boolean> {
+  const platform = await platformOf($)
+  let opener = openerFor(platform, path)
+  if (platform === 'wsl') {
+    // wslview when installed, else Windows' own explorer.exe on the Windows form of the path.
+    const viewed = await $.process.run(['wslview', path], { timeoutMs: 15_000 }).catch(() => null)
+    if (viewed?.exitCode === 0) return true
+    const windows = await $.process.run(['wslpath', '-w', path], { timeoutMs: 5_000 }).catch(() => null)
+    opener = openerFor('wsl', path, { wslview: false, windowsPath: windows?.exitCode === 0 ? windows.stdout.trim() : null })
+  }
+  if (!opener) return false
+  const result = await $.process.run(opener.argv, { timeoutMs: 15_000 }).catch(() => null)
+  return !!result && opener.okExits.includes(result.exitCode)
+}
+
+async function openAndSay($: EngineInterface, path: string): Promise<boolean> {
+  const opened = await openReport($, path)
+  if (!opened) await update($, summaryAtom, view => (view && view.report === path ? { ...view, openFailed: true } : view))
+  return opened
+}
+
+/** Registers /lineage-report; called from the plugin's one session.start hook. */
+export async function startTaskImpact($: EngineInterface) {
+  task = null
+  lastReport = null
+  await update($, summaryAtom, () => null)
+  await $.command.register({
+    name: REPORT_COMMAND,
+    description: 'Open the last column impact report (what a task changed in dbt models and what it reaches) in the browser',
+  })
+}
+
+type Ui = { Box: any; Button: any; Text: any; Link?: any }
+
+/** The summary of the last task that changed a model; drawn by the plugin's one band hook. */
+export async function taskBand($: EngineInterface, ui: Ui): Promise<RenderElement | null> {
+  const view = await read($, summaryAtom)
+  if (!view || (await read($, hiddenAtom))) return null
+  const { Box, Button, Link, Text } = ui
+  const lines = summaryLines(view)
+  const shown = lines.length > MAX_BAND_LINES ? [...lines.slice(0, MAX_BAND_LINES - 1), `… ${lines.length - MAX_BAND_LINES + 1} more lines in the report`] : lines
+  const report = view.report
+  return (
+    <Box key="lineage-summary" flexDirection="column">
+      {shown.map((line, i) => (
+        <Text
+          key={`lineage-summary-${i}`}
+          color={i === 0 ? 'claude' : line.startsWith('⚠') ? 'warning' : line.startsWith('✓') ? 'success' : undefined}
+          bold={i === 0 || (!line.startsWith(' ') && !line.startsWith('⚠') && !line.startsWith('✓') && !line.startsWith('…'))}
+          dimColor={line.startsWith('…')}
+        >
+          {line}
+        </Text>
+      ))}
+      {report && view.openFailed ? (
+        <Text dimColor>
+          No browser opened. Report: {Link ? <Link href={`file://${report}`}>{report}</Link> : report}
+        </Text>
+      ) : null}
+      <Box>
+        {report ? <Button key="lineage-report-open" label="Open report" onPress={() => later($, () => openAndSay($, report))} /> : null}
+        <Button key="lineage-summary-dismiss" label="Dismiss" onPress={() => update($, hiddenAtom, () => true)} />
+      </Box>
+    </Box>
+  )
+}
+
+// The task's share of the lineage hooks' events: registerLineage owns turn.start, tool.call and
+// turn.complete, since a plugin hooks each event once.
+
+/** A main-loop turn is one task: its start copies the manifest and notes what git already sees changed. */
+export async function taskTurnStart($: EngineInterface) {
+  const t = newTask()
+  task = t
+  await update($, summaryAtom, () => null)
+  const own = await projectRoot($, await $.session.root().catch(() => '.'), false).catch(() => null)
+  if (own) await within($, 20_000, prepareRoot($, t, own))
+}
+
+/** Before an edit lands: the model file's text as it was, the first time the task touches it. */
+export async function taskBeforeTool($: EngineInterface, e: any) {
+  const file = EDIT_TOOLS.has(e.tool) && 'file_path' in e ? String(e.file_path) : null
+  if (!file || !/\.sql$/i.test(file)) return
+  const t = (task ??= newTask())
+  if (t.originals.has(file)) return
+  const root = await projectRoot($, file, true).catch(() => null)
+  if (!root) return
+  // A project first touched mid-task has its manifest copied now, before the edit.
+  await within($, 20_000, prepareRoot($, t, root))
+  if (!t.originals.has(file)) t.originals.set(file, { root, text: await $.fs.read(file).catch(() => '') })
+}
+
+/** A main-loop turn ended: trace what it changed, after the answer is out. */
+export function taskTurnComplete($: EngineInterface, e: { agentId?: string }) {
+  if (e.agentId || !task) return
+  const done = task
+  task = null
+  later($, () => finishTask($, done).catch(error => $.ui.log(`lineage-summary · failed: ${String(error)}`)))
+}
+
+/** /lineage-report: opens the last report. */
+export function registerTaskImpact(on: On) {
+  on('command.run', { command: REPORT_COMMAND }, async $ => {
+    let path = lastReport
+    if (!path) {
+      const own = await projectRoot($, await $.session.root().catch(() => '.'), false).catch(() => null)
+      const candidate = own ? `${own}/${LINEAGE_DIR}/report.html` : null
+      if (candidate && (await $.fs.exists(candidate).catch(() => false))) path = candidate
+    }
+    if (!path) return { text: 'No column impact report yet: one is written when a task changes a dbt model.' }
+    const opened = await openAndSay($, path)
+    return { text: opened ? `Opened the column impact report: ${path}` : `No browser could be opened. The report is at ${path}` }
+  })
+}
diff --git a/plugins/altimate-code/types/index.d.ts b/plugins/altimate-code/types/index.d.ts
index 8cfa3c7..a2876fa 100644
--- a/plugins/altimate-code/types/index.d.ts
+++ b/plugins/altimate-code/types/index.d.ts
@@ -172,6 +172,33 @@ export type ImpactView = {
   truncated: boolean
 }
 
+/** How far a changed column's value reaches downstream. */
+export type Reach = {
+  columns: number
+  models: number
+  ends: number
+  hops: number
+  mayCarry: number
+  cleared: number | null
+  unresolved: number
+  modelLevel: number | null
+  truncated: boolean
+}
+
+export type SummaryColumn = { name: string; how: string | null; reach: Reach | null; failed: boolean }
+
+/** What the band shows after a task that changed models. */
+export type TaskSummaryView = {
+  state: 'tracing' | 'ready'
+  models: { name: string; modelLevel: number | null; columns: SummaryColumn[] }[]
+  /** Models whose SQL could not be read, across every column traced: the reach is a lower bound. */
+  unresolved: number
+  truncated: boolean
+  report: string | null
+  /** The report could not be opened: its path is shown as a link instead. */
+  openFailed: boolean
+}
+
 declare module 'claude-code' {
   interface PluginState {
     'altimate-code': {
@@ -204,13 +231,14 @@ declare module 'claude-code' {
       lineageView: 'graph' | 'ends' | 'folders' | 'list'
       /** The graph canvas's first visible column; null centres it on the followed model. */
       lineagePan: number | null
-      lineageImpact: Shaped<ImpactView | null>
       /** The dbt models Claude's last answer names, first named first. */
       lineageAnswer: AnswerModel[]
       /** Why there is no lineage to show, or what the last step reported. */
       lineageMessage: string | null
       lineageLoading: boolean
-      isLineageBandHidden: boolean
+      /** The end-of-task column impact summary the band shows; null until a task changes a model. */
+      lineageTaskSummary: Shaped<TaskSummaryView | null>
+      isLineageSummaryHidden: boolean
     }
   }
 }

From 51eb5e49e98d5e3d63e8332b3ea0689a72f8a1b7 Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Thu, 5 Nov 2026 21:04:57 +0800
Subject: [PATCH 02/21] fix: the impact summary reads the column answer as
 altimate-code sends it

Name-matched edges carry "name" as a fourth element and show as such. Snapshots are not traced. Engine flags show on models. The band keeps Open lineage beside Open report.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YNQjkaiykbC1WtASw6Yegs
---
 .../altimate-code/hooks/impact-report.test.ts | 27 ++++++--
 plugins/altimate-code/hooks/impact-report.ts  | 67 ++++++++++---------
 plugins/altimate-code/hooks/lineage.tsx       |  2 +-
 .../altimate-code/hooks/task-impact.test.tsx  | 10 ++-
 plugins/altimate-code/hooks/task-impact.tsx   |  8 ++-
 plugins/altimate-code/types/index.d.ts        |  3 +-
 6 files changed, 71 insertions(+), 46 deletions(-)

diff --git a/plugins/altimate-code/hooks/impact-report.test.ts b/plugins/altimate-code/hooks/impact-report.test.ts
index 14855a9..6111905 100644
--- a/plugins/altimate-code/hooks/impact-report.test.ts
+++ b/plugins/altimate-code/hooks/impact-report.test.ts
@@ -32,7 +32,7 @@ export const DOWN: ColumnAnswer = {
     { id: 'model.shop.rpt_broken', name: 'rpt_broken', folder: 'reports', materialized: 'view', contract: false, tests: 0, exposures: [] },
   ],
   columns: [
-    { model: 0, column: 'revenue', hop: 0 },
+    { model: 0, column: 'revenue', hop: 0, how: null as any, how_from: null as any },
     { model: 1, column: 'daily_revenue', hop: 1, type: 'number' },
     { model: 1, column: 'revenue', hop: 1, end: true, how: '=', how_from: 'name' },
     { model: 2, column: 'weekly_revenue', hop: 2 },
@@ -40,12 +40,13 @@ export const DOWN: ColumnAnswer = {
   ],
   edges: [
     [0, 1, 'Σ'],
-    [0, 2, '='],
+    [0, 2, '=', 'name'],
     [1, 3, 'ƒ'],
-    [3, 4, '~'],
+    [3, 4, '~', 'name'],
   ],
   also_reads: [{ model: 4, columns: ['revenue'], downstream: 2 }],
   unresolved: [{ model: 5, reason: 'parse error' }],
+  flags: [{ model: 2, flag: 'filter_rewritten' }],
   truncated: false,
 }
 
@@ -59,12 +60,14 @@ export const UP: ColumnAnswer = {
     { id: 'source.shop.raw.orders', name: 'orders' },
   ],
   columns: [
-    { model: 0, column: 'revenue', hop: 0 },
+    { model: 0, column: 'revenue', hop: 0, how: null as any, how_from: null as any },
     { model: 1, column: 'amount', hop: 1 },
     { model: 2, column: 'amount_cents', hop: 2, end: true },
   ],
   edges: [
+    // Two edges into the focus: the traced aggregate is its how, not the name match.
     [1, 0, 'Σ'],
+    [2, 0, 'Σ', 'name'],
     [2, 1, 'ƒ'],
   ],
 }
@@ -126,6 +129,12 @@ describe('the summary', () => {
     ])
   })
 
+  test('a how inferred from matching names says so', () => {
+    const up = { ...UP, edges: [[1, 0, '=', 'name']] as ColumnAnswer['edges'] }
+    const lines = summaryLines(summaryOf([CHANGE], [{ ...TRACE, up }], null))
+    expect(lines[2]).toBe('  revenue = (by name)  reaches 4 columns in 3 models (2 ends) · 1 may carry it · 2 cleared')
+  })
+
   test('a model with no changed output column shows its model-level count alone', () => {
     const change = { ...CHANGE, columns: [] }
     const lines = summaryLines(summaryOf([change], [{ model: 'fct_orders', column: null, down: null, up: null, modelLevel: 6, failed: false }], null))
@@ -143,8 +152,12 @@ describe('the report', () => {
       ['daily_revenue', 'Σ', false, false],
       ['revenue', '=', true, true],
     ])
-    // Upstream: how each column feeds the one below it.
-    expect(sectionOf(UP).hops.map(one => one.models[0]!.columns[0]!.glyph)).toEqual(['Σ', 'ƒ'])
+    // An edge inferred from names (its 4th element) reads as matched by name, not traced.
+    const board = down.hops[2]!.models[0]!.columns[0]!
+    expect([board.column, board.glyph, board.byName]).toEqual(['board_revenue', '~', true])
+    expect(down.hops[1]!.models[0]!.flags).toEqual(['filter rewritten'])
+    // Upstream: how each column feeds the one below it, the strongest edge when several.
+    expect(sectionOf(UP).hops.map(one => one.models[0]!.columns.map(col => `${col.glyph}${col.byName ? '*' : ''}`).join())).toEqual(['Σ', 'Σ*'])
   })
 
   test('embeds both directions with edges keyed by model and column, folds, and two levels by default', () => {
@@ -154,7 +167,7 @@ describe('the report', () => {
     expect(data.defaultLevels).toBe(DEFAULT_LEVELS)
     expect(DEFAULT_LEVELS).toBe(2)
     const focus = data.focuses[0]
-    expect(focus).toMatchObject({ model: 'fct_orders', column: 'revenue', key: 'model.shop.fct_orders|revenue', glyph: 'Σ', before: 'sum(amount) as revenue' })
+    expect(focus).toMatchObject({ model: 'fct_orders', column: 'revenue', key: 'model.shop.fct_orders|revenue', glyph: 'Σ', byName: false, before: 'sum(amount) as revenue' })
     expect(focus.up.hops.map((one: any) => one.hop)).toEqual([1, 2])
     expect(focus.down.hops.map((one: any) => one.hop)).toEqual([1, 2, 3])
     // The highlight walks these edges both ways from the clicked column.
diff --git a/plugins/altimate-code/hooks/impact-report.ts b/plugins/altimate-code/hooks/impact-report.ts
index c8b713d..2e950c4 100644
--- a/plugins/altimate-code/hooks/impact-report.ts
+++ b/plugins/altimate-code/hooks/impact-report.ts
@@ -15,7 +15,8 @@ export type ColumnAnswer = {
   counts?: Record<string, unknown>
   nodes: { id?: string; name?: string; folder?: string; materialized?: string; contract?: boolean; tests?: number; exposures?: string[] }[]
   columns: { model: number; column: string; hop: number; end?: boolean; how?: string; how_from?: string; type?: string }[]
-  edges?: [number, number, string?][]
+  /** [from, to, how], plus "name" when the how was inferred from matching names. */
+  edges?: [number, number, string?, string?][]
   also_reads?: { model: number; columns?: string[]; downstream?: number }[]
   unresolved?: { model: number; reason?: string; downstream?: number }[]
   cleared?: (number | { model: number })[]
@@ -36,7 +37,6 @@ export const MAX_TASK_COLUMNS = 3
 export const DEFAULT_LEVELS = 2
 export const GLYPHS = ['=', '~', 'ƒ', 'Σ', '?'] as const
 const RANK: Record<string, number> = { 'Σ': 4, 'ƒ': 3, '~': 2, '=': 1, '?': 0 }
-export const HOW_NAME: Record<string, string> = { '=': 'same value', '~': 'renamed', 'ƒ': 'calculated', 'Σ': 'aggregated', '?': 'unknown' }
 
 /** A select item's expression for the header: the last scope's (the model's own select) when several share the name. */
 const lastExpr = (items: Map<string, string>, name: string) => items.get(name)?.split('\u0000').pop()?.replace(/\s+/g, ' ').trim() ?? null
@@ -76,36 +76,35 @@ export function modelLevelOf(metadata: unknown): number | null {
 
 const num = (value: unknown) => (typeof value === 'number' && Number.isFinite(value) ? value : null)
 
-/** A how as the contract spells it: its glyph, and whether the link was matched by name rather than traced. */
-export function parseHow(how: unknown, howFrom?: unknown): { glyph: string; byName: boolean } {
+export type How = { glyph: string; byName: boolean }
+
+/** A how as the contract spells it: its glyph, and whether the link was inferred from matching names rather than traced. */
+export function parseHow(how: unknown, howFrom?: unknown): How {
   const text = typeof how === 'string' ? how : ''
-  const glyph = GLYPHS.find(one => text.startsWith(one)) ?? '?'
-  return { glyph, byName: howFrom === 'name' || (text.length > 1 && text.endsWith('?')) }
+  return { glyph: GLYPHS.find(one => text === one) ?? '?', byName: howFrom === 'name' }
 }
 
-/** The strongest derivation among several edges: aggregated, calculated, renamed, same, unknown. */
-function strongest(hows: string[]): string | null {
-  if (hows.length === 0) return null
-  return hows.reduce((best, one) => ((RANK[parseHow(one).glyph] ?? 0) > (RANK[parseHow(best).glyph] ?? 0) ? one : best))
+/** The strongest derivation among several edges (aggregated, calculated, renamed, same, unknown); a traced one over one matched by name. */
+function strongest(edges: NonNullable<ColumnAnswer['edges']>): How | null {
+  const hows = edges.map(edge => parseHow(edge[2], edge[3]))
+  const score = (one: How) => (RANK[one.glyph] ?? 0) * 2 + (one.byName ? 0 : 1)
+  return hows.length ? hows.reduce((best, one) => (score(one) > score(best) ? one : best)) : null
 }
 
-/** How one column of an answer is derived: its own how, else the strongest edge into it (downstream) or out of it (upstream). */
-function howOf(answer: ColumnAnswer, index: number): string | null {
-  const own = answer.columns[index]?.how
-  if (typeof own === 'string' && own) return own
+/** How one column of an answer is derived: the edge that first reached it, else the strongest edge into it (downstream) or out of it (upstream). */
+function howOf(answer: ColumnAnswer, index: number): How | null {
+  const col = answer.columns[index]
+  if (typeof col?.how === 'string' && col.how) return parseHow(col.how, col.how_from)
   const upstream = answer.direction === 'upstream'
-  const edges = (answer.edges ?? []).filter(edge => Array.isArray(edge) && (upstream ? edge[0] === index : edge[1] === index))
-  return strongest(edges.map(edge => String(edge[2] ?? '?')))
+  return strongest((answer.edges ?? []).filter(edge => Array.isArray(edge) && (upstream ? edge[0] === index : edge[1] === index)))
 }
 
 /** The focus column's own derivation, from the upstream answer: how it is made from what it reads. */
-export function focusHow(upstream: ColumnAnswer | null): string | null {
+export function focusHow(upstream: ColumnAnswer | null): How | null {
   if (!upstream) return null
   const focus = upstream.columns.findIndex(one => one.hop === 0)
   if (focus < 0) return null
-  const own = upstream.columns[focus]!.how
-  if (typeof own === 'string' && own) return own
-  return strongest((upstream.edges ?? []).filter(edge => edge[1] === focus).map(edge => String(edge[2] ?? '?')))
+  return strongest((upstream.edges ?? []).filter(edge => Array.isArray(edge) && edge[1] === focus))
 }
 
 /** The downstream reach in counts, read from the answer's counts where it gives them, else counted. */
@@ -118,7 +117,7 @@ export function reachOf(answer: ColumnAnswer): Reach {
     models: num(counts.models) ?? new Set(beyond.map(one => one.model)).size,
     ends: num(counts.ends) ?? beyond.filter(one => one.end).length,
     hops: num(counts.hops) ?? Math.max(0, ...answer.columns.map(one => one.hop)),
-    mayCarry: num(counts.may_carry_models) ?? num(counts.also_reads_models) ?? answer.also_reads?.length ?? 0,
+    mayCarry: num(counts.may_carry_models) ?? answer.also_reads?.length ?? 0,
     cleared,
     unresolved: num(counts.unresolved_models) ?? answer.unresolved?.length ?? 0,
     modelLevel: num(counts.model_level),
@@ -142,7 +141,8 @@ export function summaryOf(changes: ModelChange[], traces: ColumnTrace[], report:
         const reach = one.down ? reachOf(one.down) : null
         for (const entry of one.down?.unresolved ?? []) unresolved.add(one.down!.nodes[entry.model]?.id ?? one.down!.nodes[entry.model]?.name ?? String(entry.model))
         if (reach?.truncated) truncated = true
-        return { name: one.column!, how: focusHow(one.up), reach, failed: one.failed }
+        const how = focusHow(one.up)
+        return { name: one.column!, how: how?.glyph ?? null, byName: how?.byName ?? false, reach, failed: one.failed }
       })
     return { name: change.model, modelLevel, columns }
   })
@@ -157,7 +157,7 @@ export function summaryLines(view: TaskSummaryView): string[] {
     lines.push(`${model.name}${model.modelLevel !== null ? ` · ${plural(model.modelLevel, 'downstream model')} at model level` : ''}`)
     if (model.columns.length === 0) lines.push('  no output column changed: the model-level count stands')
     for (const col of model.columns) {
-      const glyph = col.how ? parseHow(col.how).glyph : '·'
+      const glyph = col.how ? `${col.how}${col.byName ? ' (by name)' : ''}` : '·'
       if (view.state === 'tracing' && !col.reach) lines.push(`  ${col.name} ${glyph}  tracing…`)
       else if (!col.reach) lines.push(`  ${col.name} ${glyph}  ${col.failed ? 'could not be traced' : 'no column answer'}`)
       else {
@@ -190,6 +190,8 @@ export type ReportModel = {
   contract: boolean
   tests: number
   exposures: string[]
+  /** What the engine noted on the model, such as a filter it rewrote before analysis. */
+  flags: string[]
   columns: ReportColumn[]
 }
 export type ReportSection = { hops: { hop: number; models: ReportModel[] }[]; truncated: boolean; error: string | null }
@@ -247,10 +249,11 @@ export function sectionOf(answer: ColumnAnswer | null, failed = false): ReportSe
       contract: node.contract === true,
       tests: num(node.tests) ?? 0,
       exposures: Array.isArray(node.exposures) ? node.exposures.map(String) : [],
+      flags: [...new Set((answer.flags ?? []).filter(one => one?.model === col.model).map(one => String(one.flag).replace(/_/g, ' ')))],
       columns: [],
     }
     hop.set(col.model, model)
-    const how = parseHow(howOf(answer, i), col.how_from)
+    const how = howOf(answer, i) ?? { glyph: '?', byName: false }
     model.columns.push({ key: keyOf(answer, i), column: String(col.column), glyph: how.glyph, byName: how.byName, end: col.end === true, type: col.type ?? null, hop: col.hop })
   })
   const hops = [...byHop.entries()]
@@ -265,7 +268,7 @@ export function focusOf(change: ModelChange, column: ModelChange['columns'][numb
   const up = trace?.up ?? null
   const any = down ?? up
   const focusIndex = any ? any.columns.findIndex(one => one.hop === 0) : -1
-  const how = parseHow(focusHow(up), up?.columns.find(one => one.hop === 0)?.how_from)
+  const how = focusHow(up)
   const edges: [string, string, string][] = []
   for (const answer of [up, down]) {
     if (!answer) continue
@@ -281,8 +284,8 @@ export function focusOf(change: ModelChange, column: ModelChange['columns'][numb
     model: change.model,
     column: column?.name ?? null,
     key: any && focusIndex >= 0 ? keyOf(any, focusIndex) : null,
-    glyph: up ? how.glyph : null,
-    byName: how.byName,
+    glyph: how?.glyph ?? null,
+    byName: how?.byName ?? false,
     before: column?.before ?? null,
     after: column?.after ?? null,
     reach,
@@ -413,6 +416,7 @@ header.top .when{color:var(--muted);font-size:12.5px}
 .badge{font-size:11px;border-radius:4px;padding:0 5px;border:1px solid var(--line-strong);color:var(--muted);line-height:17px}
 .badge.c{border-color:var(--accent);color:var(--accent);font-weight:700}
 .badge.x{border-color:var(--agg);color:var(--agg)}
+.badge.f{border-color:var(--warn);color:var(--warn);background:var(--warn-bg)}
 .model-meta{color:var(--faint);font-size:11.5px;margin-bottom:4px}
 .col{display:flex;align-items:center;gap:7px;width:100%;appearance:none;border:0;background:transparent;color:inherit;font:inherit;text-align:left;padding:3px 4px;border-radius:6px;cursor:pointer}
 .col:hover{background:var(--accent-soft)}
@@ -469,7 +473,7 @@ function graphOf(f){var fwd={},back={};f.edges.forEach(function(e){(fwd[e[0]]=fw
 function walk(start,adj){var seen={},q=[start];seen[start]=1;while(q.length){var k=q.shift();(adj[k]||[]).forEach(function(n){if(!seen[n]){seen[n]=1;q.push(n)}})}return seen}
 function pathOf(f,key){var g=graphOf(f),up=walk(key,g.back),down=walk(key,g.fwd),all={};Object.keys(up).forEach(function(k){all[k]=1});Object.keys(down).forEach(function(k){all[k]=1});return{all:all,up:Object.keys(up).length-1,down:Object.keys(down).length-1}}
 function colButton(c){var b=el('button','col');b.type='button';b.dataset.key=c.key;b.appendChild(glyph(c.glyph,c.byName));b.appendChild(el('span','name mono',c.column));if(c.type)b.appendChild(el('span','type',c.type));if(c.end){var e=el('span','end','end');e.title='Nothing further downstream reads it';b.appendChild(e)}b.addEventListener('click',function(ev){ev.stopPropagation();select(c.key)});return b}
-function modelCard(m){var card=el('div','panel model');var head=el('div','model-head');head.appendChild(el('span','model-name mono',m.name));if(m.contract){var c=el('span','badge c','C');c.title='Contract enforced: a change to this column can fail its build';head.appendChild(c)}if(m.tests){head.appendChild(el('span','badge',plural(m.tests,'test')))}m.exposures.forEach(function(x){var b=el('span','badge x','\\u25a3 '+x);b.title='Exposure (dashboard or app) on this model';head.appendChild(b)});card.appendChild(head);var meta=[m.folder,m.materialized].filter(Boolean).join(' \\u00b7 ');if(meta)card.appendChild(el('div','model-meta',meta));m.columns.forEach(function(c){card.appendChild(colButton(c))});return card}
+function modelCard(m){var card=el('div','panel model');var head=el('div','model-head');head.appendChild(el('span','model-name mono',m.name));if(m.contract){var c=el('span','badge c','C');c.title='Contract enforced: a change to this column can fail its build';head.appendChild(c)}if(m.tests){head.appendChild(el('span','badge',plural(m.tests,'test')))}m.exposures.forEach(function(x){var b=el('span','badge x','\\u25a3 '+x);b.title='Exposure (dashboard or app) on this model';head.appendChild(b)});(m.flags||[]).forEach(function(x){var b=el('span','badge f',x);b.title='Noted by the engine: the trace through this model is less certain';head.appendChild(b)});card.appendChild(head);var meta=[m.folder,m.materialized].filter(Boolean).join(' \\u00b7 ');if(meta)card.appendChild(el('div','model-meta',meta));m.columns.forEach(function(c){card.appendChild(colButton(c))});return card}
 function hopBlock(h,dir){var d=el('div','hop');var cols=h.models.reduce(function(n,m){return n+m.columns.length},0);d.appendChild(el('div','hop-label',(dir==='up'?'Reads from \\u00b7 ':'')+plural(h.hop,'hop')+' '+(dir==='up'?'up':'down')+' \\u00b7 '+plural(h.models.length,'model')+' \\u00b7 '+plural(cols,'column')));var grid=el('div','models');h.models.forEach(function(m){grid.appendChild(modelCard(m))});d.appendChild(grid);return d}
 function section(f,i,dir){var sec=f[dir],lv=state.levels[i][dir],s=el('section','section');var head=el('div','section-head');head.appendChild(el('h2',null,dir==='up'?'Upstream: where it comes from':'Downstream: where it goes'));var total=sec.hops.length,hidden=sec.hops.filter(function(h){return h.hop>lv}).length;if(hidden>0){var more=el('button','more',hidden===1?'Show 1 more level':'Show more levels ('+hidden+' hidden)');more.type='button';more.addEventListener('click',function(){state.levels[i][dir]=lv+1;render()});head.appendChild(more);if(hidden>1){var all=el('button','more','Show all');all.type='button';all.addEventListener('click',function(){state.levels[i][dir]=Infinity;render()});head.appendChild(all)}}else if(total>DATA.defaultLevels&&lv>DATA.defaultLevels){var less=el('button','more','Back to '+DATA.defaultLevels+' levels');less.type='button';less.addEventListener('click',function(){state.levels[i][dir]=DATA.defaultLevels;render()});head.appendChild(less)}s.appendChild(head);if(sec.error){s.appendChild(el('div','empty',sec.error));return s}var shown=sec.hops.filter(function(h){return h.hop<=lv});if(!shown.length)s.appendChild(el('div','empty',dir==='up'?'Nothing upstream was traced for this column.':'No downstream model carries this column\\u2019s value.'));if(dir==='up')shown=shown.slice().reverse();shown.forEach(function(h){s.appendChild(hopBlock(h,dir))});if(sec.truncated)s.appendChild(el('div','note warn','The trace stopped at its limit: more may sit beyond the last level.'));return s}
 function stat(n,label,dim){var d=el('div','stat'+(dim?' dim':''));d.appendChild(el('b',null,n==null?'\\u2013':n));d.appendChild(el('span',null,label));return d}
@@ -486,21 +490,22 @@ function render(){
   stats.appendChild(stat(f.modelLevel,'downstream at model level',true));wrap.appendChild(stats);
   if(r&&(r.unresolved||r.truncated))wrap.appendChild(el('div','note warn','\\u26a0 Lower bound: '+[r.unresolved?plural(r.unresolved,'model')+' could not be read':'',r.truncated?'the trace hit its limit':''].filter(Boolean).join('; ')+'. See \\u201cNot resolved\\u201d below.'));
   else if(r)wrap.appendChild(el('div','note ok','\\u2713 Every downstream model was read.'));
-  var inp=[];if(f.inputs.engine)inp.push('engine '+f.inputs.engine);inp.push(f.inputs.catalog?'with catalog types':'no catalog: types from the manifest');if(f.inputs.olderThanSql)inp.push('the manifest is older than the SQL');f.inputs.workarounds.forEach(function(w){inp.push(w)});wrap.appendChild(el('div','inputs',inp.join(' \\u00b7 ')));
+  var inp=[];if(f.inputs.engine)inp.push('engine '+f.inputs.engine);inp.push(f.inputs.catalog?'with catalog types':'no catalog: types from the manifest');if(f.inputs.olderThanSql)inp.push('the manifest is older than the SQL');wrap.appendChild(el('div','inputs',inp.join(' \\u00b7 ')));
   var lg=el('div','legend');['=','~','\\u0192','\\u03a3','?'].forEach(function(g){var s=el('span');s.appendChild(glyph(g,false));s.appendChild(document.createTextNode(HOW[g]));lg.appendChild(s)});var bn=el('span');bn.appendChild(glyph('=',true));bn.appendChild(document.createTextNode('matched by name'));lg.appendChild(bn);var cb=el('span');cb.appendChild(el('span','badge c','C'));cb.appendChild(document.createTextNode(' contract enforced'));lg.appendChild(cb);wrap.appendChild(lg);
   wrap.appendChild(section(f,i,'up'));
-  var fc=el('div','panel focus');fc.appendChild(el('div','label','The changed column'));var ti=el('div','title');if(f.key){ti.appendChild(colButton({key:f.key,column:f.model+'.'+(f.column||''),glyph:f.glyph||'?',byName:f.byName,end:false,type:null}))}else ti.appendChild(el('span','mono',f.column?f.model+'.'+f.column:f.model));fc.appendChild(ti);if(f.glyph)var hw=HOW[f.glyph]||'unknown';fc.appendChild(el('div','empty',hw.charAt(0).toUpperCase()+hw.slice(1)+' from what it reads'+(f.byName?' (matched by name)':'')+'. Click any column to light up its path.'));wrap.appendChild(fc);
+  var fc=el('div','panel focus');fc.appendChild(el('div','label','The changed column'));var ti=el('div','title');if(f.key){ti.appendChild(colButton({key:f.key,column:f.model+'.'+(f.column||''),glyph:f.glyph||'?',byName:f.byName,end:false,type:null}))}else ti.appendChild(el('span','mono',f.column?f.model+'.'+f.column:f.model));fc.appendChild(ti);var hw=f.glyph?HOW[f.glyph]||'unknown':'';fc.appendChild(el('div','empty',(hw?hw.charAt(0).toUpperCase()+hw.slice(1)+' from what it reads'+(f.byName?' (matched by name)':'')+'. ':'')+(f.key?'Click any column to light up its path.':'')));wrap.appendChild(fc);
   wrap.appendChild(section(f,i,'down'));
   wrap.appendChild(fold('Also reads it, outside the select',f.alsoReads.length,f.alsoReads.map(function(a){return li(a.name,'reads '+a.columns.join(', ')+(a.downstream!=null?' \\u00b7 '+plural(a.downstream,'model')+' downstream of it':''))})));
   wrap.appendChild(fold('Not resolved',f.unresolved.length,f.unresolved.map(function(u){return li(u.name,u.reason+(u.downstream!=null?' \\u00b7 '+plural(u.downstream,'model')+' downstream of it':''))})));
   wrap.appendChild(fold('Cleared: downstream, but does not carry it',f.cleared.count,f.cleared.names.map(function(n){return li(n,'')})));
+  if(f.inputs.workarounds.length)wrap.appendChild(fold('How the engine read the SQL',f.inputs.workarounds.length,f.inputs.workarounds.map(function(w){var l=el('li','why',w);return l})));
   app.appendChild(wrap);applyHighlight();
 }
 function select(key){state.selected=state.selected===key?null:key;applyHighlight()}
 function applyHighlight(){var f=DATA.focuses[state.focus],bar=document.getElementById('pathbar');var cols=document.querySelectorAll('.col');if(!state.selected){document.body.classList.remove('hl');cols.forEach(function(c){c.classList.remove('on','sel')});document.querySelectorAll('.model').forEach(function(m){m.classList.remove('has-on')});return}
   var p=pathOf(f,state.selected);document.body.classList.add('hl');cols.forEach(function(c){var on=!!p.all[c.dataset.key];c.classList.toggle('on',on);c.classList.toggle('sel',c.dataset.key===state.selected)});document.querySelectorAll('.model').forEach(function(m){m.classList.toggle('has-on',!!m.querySelector('.col.on'))});
   var shown={};cols.forEach(function(c){shown[c.dataset.key]=1});var hidden=Object.keys(p.all).filter(function(k){return!shown[k]}).length;
-  bar.textContent='';bar.appendChild(el('span',null,'Path of '+state.selected.split('|').pop()+': '+plural(p.up,'column')+' upstream, '+plural(p.down,'column')+' downstream'+(hidden?' \\u00b7 '+hidden+' more on hidden levels':'')));var clr=el('button',null,'Clear');clr.type='button';clr.addEventListener('click',function(){select(state.selected)});bar.appendChild(clr)}
+  bar.textContent='';bar.appendChild(el('span',null,'Path of '+state.selected.split('|')[0].split('.').pop()+'.'+state.selected.split('|').pop()+': '+plural(p.up,'column')+' upstream, '+plural(p.down,'column')+' downstream'+(hidden?' \\u00b7 '+hidden+' more on hidden levels':'')));var clr=el('button',null,'Clear');clr.type='button';clr.addEventListener('click',function(){select(state.selected)});bar.appendChild(clr)}
 document.addEventListener('keydown',function(e){if(e.key==='Escape'&&state.selected)select(state.selected)});
 render();
 })();
diff --git a/plugins/altimate-code/hooks/lineage.tsx b/plugins/altimate-code/hooks/lineage.tsx
index fb82e8e..b1b607d 100644
--- a/plugins/altimate-code/hooks/lineage.tsx
+++ b/plugins/altimate-code/hooks/lineage.tsx
@@ -790,7 +790,7 @@ async function loadWarehouse($: EngineInterface) {
   $.ui.log(`lineage-pane · ${server} · ${tool}(${node.relation}) · ${elapsed(ms)}`)
 }
 
-async function openPane($: EngineInterface) {
+export async function openPane($: EngineInterface) {
   paneOpened = true
   await $.ui.open({ id: PANE, title: PANE_TITLE, ...PANE_SIZE, focus: true, closeOnEscape: true })
 }
diff --git a/plugins/altimate-code/hooks/task-impact.test.tsx b/plugins/altimate-code/hooks/task-impact.test.tsx
index 63e78ca..1f6238b 100644
--- a/plugins/altimate-code/hooks/task-impact.test.tsx
+++ b/plugins/altimate-code/hooks/task-impact.test.tsx
@@ -9,6 +9,7 @@ const REPORT = `${ROOT}/target/.altimate-lineage/report.html`
 const MODEL = `${ROOT}/models/fct_orders.sql`
 const STAGING = `${ROOT}/models/stg_payments.sql`
 const MACRO = `${ROOT}/macros/cents.sql`
+const SNAPSHOT_SQL = `${ROOT}/snapshots/orders_snap.sql`
 
 const BAND = {
   plugin: 'altimate-code',
@@ -42,6 +43,7 @@ async function start($: any, on: any, options: Options = {}) {
     [MODEL]: ORDERS_SQL,
     [STAGING]: PAYMENTS_SQL,
     [MACRO]: '{% macro cents(x) %}{{ x }} / 100{% endmacro %}',
+    [SNAPSHOT_SQL]: '{% snapshot orders_snap %}select id, status from orders{% endsnapshot %}',
   }
   const runs: string[][] = []
   const tools: Record<string, any>[] = []
@@ -163,6 +165,7 @@ test('an edited model is traced both ways from the snapshot at the task end, and
   expect(await band.find({ type: 'Text', text: '  revenue Σ  reaches 4 columns in 3 models (2 ends) · 1 may carry it · 2 cleared' })).toBeDefined()
   expect(await band.find({ type: 'Text', text: '⚠ Lower bound: 1 model could not be read' })).toBeDefined()
   expect(await band.find({ key: 'lineage-report-open' })).toBeDefined()
+  expect(await band.find({ key: 'lineage-open' })).toBeDefined()
   await band.press({ key: 'lineage-summary-dismiss' })
   await clock.settle()
   expect(await band.find({ key: 'lineage-report-open' })).toBeUndefined()
@@ -178,14 +181,15 @@ test('an edited model is traced both ways from the snapshot at the task end, and
 
 test('model files changed outside the edit tools are found through git, and only what changed this task', async ($, on) => {
   let changed: string[] = ['models/fct_orders.sql']
-  const opts = { gitChanged: () => changed, head: { 'models/stg_payments.sql': PAYMENTS_SQL, 'macros/cents.sql': 'x' } }
+  const opts = { gitChanged: () => changed, head: { 'models/stg_payments.sql': PAYMENTS_SQL, 'macros/cents.sql': 'x', 'snapshots/orders_snap.sql': 'x' } }
   const { tools, files, turn } = await start($, on, opts)
   await turn('t1', async () => {
     // A sed in Bash: git sees the file, HEAD has its text before. fct_orders was already dirty
-    // before the task and is untouched by it; a macro is not a model.
+    // before the task and is untouched by it; a macro is not a model, and impact_analysis takes no snapshot.
     files[STAGING] = PAYMENTS_SQL.replace('amount_cents / 100 as amount', 'amount_cents / 100.0 as amount')
     files[MACRO] = 'changed'
-    changed = ['models/fct_orders.sql', 'models/stg_payments.sql', 'macros/cents.sql']
+    files[SNAPSHOT_SQL] = '{% snapshot orders_snap %}select id, upper(status) as status from orders{% endsnapshot %}'
+    changed = ['models/fct_orders.sql', 'models/stg_payments.sql', 'macros/cents.sql', 'snapshots/orders_snap.sql']
   })
   expect(directional(tools).map(one => `${one.model}.${one.column}:${one.direction}`)).toEqual(['stg_payments.amount:downstream', 'stg_payments.amount:upstream'])
 })
diff --git a/plugins/altimate-code/hooks/task-impact.tsx b/plugins/altimate-code/hooks/task-impact.tsx
index 3912ec0..7263fd6 100644
--- a/plugins/altimate-code/hooks/task-impact.tsx
+++ b/plugins/altimate-code/hooks/task-impact.tsx
@@ -19,7 +19,7 @@ import {
   summaryOf,
 } from './impact-report'
 import { projectLayout } from './lineage-graph'
-import { projectRoot, runTool, within } from './lineage'
+import { openPane, projectRoot, runTool, within } from './lineage'
 
 export const REPORT_COMMAND = 'lineage-report'
 // Under the project's target/, which dbt already keeps out of git.
@@ -51,7 +51,7 @@ const newTask = (): Task => ({ roots: new Map(), originals: new Map() })
 const relative = (root: string, path: string) => path.slice(root.length).replace(/^[\\/]+/, '').replace(/\\/g, '/')
 const modelName = (file: string) => (file.split(/[\\/]/).pop() ?? file).replace(/\.sql$/i, '')
 
-/** Whether a project-relative path is a model's or a snapshot's SQL. */
+/** Whether a project-relative path is a model's SQL. */
 function isModelFile(layout: Layout, rel: string): boolean {
   if (!/\.sql$/i.test(rel)) return false
   return layout.models.some(dir => {
@@ -83,7 +83,8 @@ function prepareRoot($: EngineInterface, t: Task, root: string): Promise<RootSta
   if (known) return known
   const work = (async (): Promise<RootState> => {
     const layout = projectLayout(await $.fs.read(`${root}/dbt_project.yml`).catch(() => ''))
-    const models = { models: [...layout.models, ...layout.snapshots] }
+    // Models only: impact_analysis does not take a snapshot as the column's model.
+    const models = { models: layout.models }
     let snapshot: string | null = null
     const manifest = `${root}/target/manifest.json`
     if (await $.fs.exists(manifest).catch(() => false)) {
@@ -288,6 +289,7 @@ export async function taskBand($: EngineInterface, ui: Ui): Promise<RenderElemen
       ) : null}
       <Box>
         {report ? <Button key="lineage-report-open" label="Open report" onPress={() => later($, () => openAndSay($, report))} /> : null}
+        <Button key="lineage-open" label="Open lineage" onPress={() => later($, () => openPane($))} />
         <Button key="lineage-summary-dismiss" label="Dismiss" onPress={() => update($, hiddenAtom, () => true)} />
       </Box>
     </Box>
diff --git a/plugins/altimate-code/types/index.d.ts b/plugins/altimate-code/types/index.d.ts
index a2876fa..3800db5 100644
--- a/plugins/altimate-code/types/index.d.ts
+++ b/plugins/altimate-code/types/index.d.ts
@@ -185,7 +185,8 @@ export type Reach = {
   truncated: boolean
 }
 
-export type SummaryColumn = { name: string; how: string | null; reach: Reach | null; failed: boolean }
+/** `how`: how the column is made from what it reads, before the task; `byName` when that was inferred from matching names. */
+export type SummaryColumn = { name: string; how: string | null; byName?: boolean; reach: Reach | null; failed: boolean }
 
 /** What the band shows after a task that changed models. */
 export type TaskSummaryView = {

From 4fd7f3773c7ac366855dc8ac237917175df5b7ac Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Thu, 5 Nov 2026 21:07:30 +0800
Subject: [PATCH 03/21] feat: the impact report lists the cleared models by
 name

The Cleared group names the models altimate-code clears, and keeps the count alone when an answer has no list. Links matched by name draw dimmer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YNQjkaiykbC1WtASw6Yegs
---
 plugins/altimate-code/hooks/impact-report.test.ts | 13 +++++++++++--
 plugins/altimate-code/hooks/impact-report.ts      |  8 +++++---
 plugins/altimate-code/hooks/task-impact.tsx       |  2 ++
 3 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/plugins/altimate-code/hooks/impact-report.test.ts b/plugins/altimate-code/hooks/impact-report.test.ts
index 6111905..73154b0 100644
--- a/plugins/altimate-code/hooks/impact-report.test.ts
+++ b/plugins/altimate-code/hooks/impact-report.test.ts
@@ -6,6 +6,7 @@ import {
   type ColumnAnswer,
   type ColumnTrace,
   DEFAULT_LEVELS,
+  focusOf,
   type ModelChange,
   openerFor,
   reachOf,
@@ -47,6 +48,10 @@ export const DOWN: ColumnAnswer = {
   also_reads: [{ model: 4, columns: ['revenue'], downstream: 2 }],
   unresolved: [{ model: 5, reason: 'parse error' }],
   flags: [{ model: 2, flag: 'filter_rewritten' }],
+  cleared: [
+    { id: 'model.shop.dim_dates', name: 'dim_dates' },
+    { id: 'model.shop.rpt_ops', name: 'rpt_ops' },
+  ],
   truncated: false,
 }
 
@@ -113,8 +118,10 @@ describe('the answer', () => {
 
   test('reach takes the contract counts, and counts for itself where they are absent', () => {
     expect(reachOf(DOWN)).toEqual({ columns: 4, models: 3, ends: 2, hops: 3, mayCarry: 1, cleared: 2, unresolved: 1, modelLevel: 6, truncated: false })
-    const bare = { ...DOWN, counts: undefined }
+    const bare = { ...DOWN, counts: undefined, cleared: undefined }
     expect(reachOf(bare)).toEqual({ columns: 4, models: 3, ends: 2, hops: 3, mayCarry: 1, cleared: null, unresolved: 1, modelLevel: null, truncated: false })
+    // With the cleared list but no counts, the list gives the cleared count.
+    expect(reachOf({ ...DOWN, counts: undefined }).cleared).toBe(2)
   })
 })
 
@@ -175,7 +182,9 @@ describe('the report', () => {
     expect(focus.edges).toContainEqual(['model.shop.rpt_finance|weekly_revenue', 'model.shop.rpt_board|board_revenue', '~'])
     expect(focus.alsoReads).toEqual([{ name: 'rpt_misc', columns: ['revenue'], downstream: 2 }])
     expect(focus.unresolved).toEqual([{ name: 'rpt_broken', reason: 'parse error', downstream: null }])
-    expect(focus.cleared).toEqual({ names: [], count: 2 })
+    expect(focus.cleared).toEqual({ names: ['dim_dates', 'rpt_ops'], count: 2 })
+    // An answer without the list keeps the count alone.
+    expect(focusOf(CHANGE, CHANGE.columns[0]!, { ...TRACE, down: { ...DOWN, cleared: undefined } }).cleared).toEqual({ names: [], count: 2 })
     expect(data.changes[0].columns[0].after).toBe('sum(amount) - sum(refunds) as revenue')
   })
 
diff --git a/plugins/altimate-code/hooks/impact-report.ts b/plugins/altimate-code/hooks/impact-report.ts
index 2e950c4..fbb5c9c 100644
--- a/plugins/altimate-code/hooks/impact-report.ts
+++ b/plugins/altimate-code/hooks/impact-report.ts
@@ -19,7 +19,8 @@ export type ColumnAnswer = {
   edges?: [number, number, string?, string?][]
   also_reads?: { model: number; columns?: string[]; downstream?: number }[]
   unresolved?: { model: number; reason?: string; downstream?: number }[]
-  cleared?: (number | { model: number })[]
+  /** Models at the model level that do not carry the value: off the path, so not in `nodes`. */
+  cleared?: { id?: string; name?: string }[]
   flags?: { model: number; flag: string }[]
   truncated?: boolean
   next?: unknown
@@ -277,7 +278,7 @@ export function focusOf(change: ModelChange, column: ModelChange['columns'][numb
       edges.push([keyOf(answer, edge[0]), keyOf(answer, edge[1]), String(edge[2] ?? '?')])
     }
   }
-  const clearedNames = (down?.cleared ?? []).map(one => nameOf(down!, typeof one === 'number' ? one : one?.model))
+  const clearedNames = (Array.isArray(down?.cleared) ? down!.cleared : []).map(one => String(one?.name ?? one?.id ?? '?'))
   const reach = down ? reachOf(down) : null
   const manifestInput = (down?.inputs ?? up?.inputs)?.manifest as any
   return {
@@ -429,7 +430,8 @@ header.top .when{color:var(--muted);font-size:12.5px}
 .g.calc{color:var(--calc);background:var(--calc-bg)}
 .g.agg{color:var(--agg);background:var(--agg-bg)}
 .g.unk{color:var(--unk);background:var(--unk-bg)}
-.g.byname{outline:1.5px dashed currentColor;outline-offset:-1.5px;background:transparent}
+.g.byname{outline:1.5px dashed currentColor;outline-offset:-1.5px;background:transparent;opacity:.7}
+.col .g.byname+.name{opacity:.8}
 .focus{padding:12px 14px;border:1.5px solid var(--focus-line);background:var(--focus);margin:6px 0}
 .focus .label{font-size:11px;text-transform:uppercase;letter-spacing:.06em;color:var(--muted)}
 .focus .title{font-size:17px;font-weight:650;margin:2px 0;display:flex;align-items:center;gap:8px;flex-wrap:wrap}
diff --git a/plugins/altimate-code/hooks/task-impact.tsx b/plugins/altimate-code/hooks/task-impact.tsx
index 7263fd6..748ab70 100644
--- a/plugins/altimate-code/hooks/task-impact.tsx
+++ b/plugins/altimate-code/hooks/task-impact.tsx
@@ -158,6 +158,8 @@ async function traceChanges($: EngineInterface, t: Task, changes: ModelChange[])
   const ask = async (change: ModelChange, column: string | null, direction: 'downstream' | 'upstream') => {
     const state = await t.roots.get(change.root)?.catch(() => null)
     const manifest = state?.snapshot ?? `${change.root}/target/manifest.json`
+    // Known limit: the model goes by its file name, which misses a versioned model (x_v2.sql) or a file
+    // named apart from its model.
     const args = { manifest_path: manifest, model: change.model, ...(column && { column }), change_type: 'modify', direction }
     const result = await runTool($, 'impact_analysis', args).catch(() => null)
     return result?.ok ? result.metadata : null

From 01eece27dd3760577e0ded140a822c1229166912 Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Thu, 5 Nov 2026 21:11:21 +0800
Subject: [PATCH 04/21] fix: the report opens on WSL without wslview, and the
 summary logs as one line
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

On WSL, explorer.exe is tried by name, then at /mnt/c/Windows, then xdg-open; a WSL kernel is known from uname. The log line joins the summary with " · ".

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YNQjkaiykbC1WtASw6Yegs
---
 .../altimate-code/hooks/impact-report.test.ts | 27 +++++++++------
 plugins/altimate-code/hooks/impact-report.ts  | 22 ++++++++----
 .../altimate-code/hooks/task-impact.test.tsx  | 34 +++++++++++++++++--
 plugins/altimate-code/hooks/task-impact.tsx   | 26 ++++++++------
 4 files changed, 78 insertions(+), 31 deletions(-)

diff --git a/plugins/altimate-code/hooks/impact-report.test.ts b/plugins/altimate-code/hooks/impact-report.test.ts
index 73154b0..3b5b1c7 100644
--- a/plugins/altimate-code/hooks/impact-report.test.ts
+++ b/plugins/altimate-code/hooks/impact-report.test.ts
@@ -8,13 +8,14 @@ import {
   DEFAULT_LEVELS,
   focusOf,
   type ModelChange,
-  openerFor,
+  openersFor,
   reachOf,
   reportData,
   reportHtml,
   sectionOf,
   summaryLines,
   summaryOf,
+  WINDOWS_EXPLORER,
 } from './impact-report'
 
 // A synthetic project: orders → fct_orders.revenue → three hops of readers.
@@ -200,17 +201,21 @@ describe('the report', () => {
 })
 
 describe('the opener', () => {
-  test('per platform: open, xdg-open, wslview or explorer.exe on the Windows path, start', () => {
+  test('per platform: open, xdg-open, start; on WSL wslview, explorer.exe by name then by path, xdg-open last', () => {
     const path = '/repo/target/.altimate-lineage/report.html'
-    expect(openerFor('mac', path)).toEqual({ argv: ['open', path], okExits: [0] })
-    expect(openerFor('linux', path)).toEqual({ argv: ['xdg-open', path], okExits: [0] })
-    expect(openerFor('wsl', path, { wslview: true })).toEqual({ argv: ['wslview', path], okExits: [0] })
+    const win = '\\\\wsl.localhost\\x\\report.html'
+    expect(openersFor('mac', path)).toEqual([{ argv: ['open', path], okExits: [0] }])
+    expect(openersFor('linux', path)).toEqual([{ argv: ['xdg-open', path], okExits: [0] }])
+    expect(openersFor('windows', path)).toEqual([{ argv: ['cmd', '/c', 'start', '', path], okExits: [0] }])
     // explorer.exe exits 1 even when it opened the file.
-    expect(openerFor('wsl', path, { wslview: false, windowsPath: '\\\\wsl.localhost\\x\\report.html' })).toEqual({
-      argv: ['explorer.exe', '\\\\wsl.localhost\\x\\report.html'],
-      okExits: [0, 1],
-    })
-    expect(openerFor('wsl', path, { wslview: false, windowsPath: null })).toBeNull()
-    expect(openerFor('windows', path)).toEqual({ argv: ['cmd', '/c', 'start', '', path], okExits: [0] })
+    expect(openersFor('wsl', path, { windowsPath: win, explorerAtC: true })).toEqual([
+      { argv: ['wslview', path], okExits: [0] },
+      { argv: ['explorer.exe', win], okExits: [0, 1] },
+      { argv: [WINDOWS_EXPLORER, win], okExits: [0, 1] },
+      { argv: ['xdg-open', path], okExits: [0] },
+    ])
+    expect(WINDOWS_EXPLORER).toBe('/mnt/c/Windows/explorer.exe')
+    // No Windows path: nothing for explorer.exe to open.
+    expect(openersFor('wsl', path, { windowsPath: null, explorerAtC: true }).map(one => one.argv[0])).toEqual(['wslview', 'xdg-open'])
   })
 })
diff --git a/plugins/altimate-code/hooks/impact-report.ts b/plugins/altimate-code/hooks/impact-report.ts
index fbb5c9c..3066485 100644
--- a/plugins/altimate-code/hooks/impact-report.ts
+++ b/plugins/altimate-code/hooks/impact-report.ts
@@ -513,13 +513,21 @@ render();
 })();
 `
 
-/** The command that opens a file in the person's browser, per platform; null when none applies. */
+/** The commands that may open a file in the person's browser, per platform, in the order to try them. */
 export type Platform = 'mac' | 'linux' | 'wsl' | 'windows'
-export function openerFor(platform: Platform, path: string, wsl: { wslview: boolean; windowsPath?: string | null } = { wslview: false }): { argv: string[]; okExits: number[] } | null {
-  if (platform === 'mac') return { argv: ['open', path], okExits: [0] }
-  if (platform === 'linux') return { argv: ['xdg-open', path], okExits: [0] }
-  if (platform === 'windows') return { argv: ['cmd', '/c', 'start', '', path], okExits: [0] }
-  if (wsl.wslview) return { argv: ['wslview', path], okExits: [0] }
+export type Opener = { argv: string[]; okExits: number[] }
+export function openersFor(platform: Platform, path: string, wsl: { windowsPath?: string | null; explorerAtC?: boolean } = {}): Opener[] {
+  if (platform === 'mac') return [{ argv: ['open', path], okExits: [0] }]
+  if (platform === 'linux') return [{ argv: ['xdg-open', path], okExits: [0] }]
+  if (platform === 'windows') return [{ argv: ['cmd', '/c', 'start', '', path], okExits: [0] }]
+  // WSL: wslview when installed; else Windows' explorer.exe on the Windows form of the path, by name
+  // (on PATH when Windows' folders are appended) and then where Windows keeps it; xdg-open last.
   // explorer.exe exits 1 even when it opened the file.
-  return wsl.windowsPath ? { argv: ['explorer.exe', wsl.windowsPath], okExits: [0, 1] } : null
+  const explorer = (bin: string): Opener => ({ argv: [bin, wsl.windowsPath!], okExits: [0, 1] })
+  return [
+    { argv: ['wslview', path], okExits: [0] },
+    ...(wsl.windowsPath ? [explorer('explorer.exe'), ...(wsl.explorerAtC ? [explorer(WINDOWS_EXPLORER)] : [])] : []),
+    { argv: ['xdg-open', path], okExits: [0] },
+  ]
 }
+export const WINDOWS_EXPLORER = '/mnt/c/Windows/explorer.exe'
diff --git a/plugins/altimate-code/hooks/task-impact.test.tsx b/plugins/altimate-code/hooks/task-impact.test.tsx
index 1f6238b..d252664 100644
--- a/plugins/altimate-code/hooks/task-impact.test.tsx
+++ b/plugins/altimate-code/hooks/task-impact.test.tsx
@@ -30,6 +30,8 @@ type Options = {
   /** HEAD's text per project-relative path. */
   head?: Record<string, string>
   noManifest?: boolean
+  /** Other paths that exist, such as Windows' explorer.exe under /mnt/c. */
+  present?: string[]
 }
 
 /**
@@ -64,7 +66,9 @@ async function start($: any, on: any, options: Options = {}) {
     const { Box } = $$.ui.resolve(e)
     return <Box key="engine" />
   })
-  on('fs.exists', (_: unknown, e: { path: string }) => ({ value: e.path in files || (e.path === MANIFEST && !options.noManifest) || writes.has(e.path) }))
+  on('fs.exists', (_: unknown, e: { path: string }) => ({
+    value: e.path in files || (e.path === MANIFEST && !options.noManifest) || writes.has(e.path) || !!options.present?.includes(e.path),
+  }))
   on('fs.stat', (_: unknown, e: { path: string }) => {
     if (e.path === MANIFEST && options.noManifest) throw new Error('ENOENT')
     return { value: { kind: 'file', size: 50 * 1024 * 1024, mtimeMs: 1, isLink: false } }
@@ -157,7 +161,8 @@ test('an edited model is traced both ways from the snapshot at the task end, and
     { manifest_path: SNAPSHOT, model: 'fct_orders', column: 'revenue', change_type: 'modify', direction: 'downstream' },
     { manifest_path: SNAPSHOT, model: 'fct_orders', column: 'revenue', change_type: 'modify', direction: 'upstream' },
   ])
-  expect(logs.some(line => line.startsWith('◆ Lineage after this task'))).toBe(true)
+  // One log line: the transcript draws a newline in a log as a replacement glyph.
+  expect(logs).toContain('◆ Lineage after this task · 1 model changed · fct_orders · 6 downstream models at model level · revenue Σ  reaches 4 columns in 3 models (2 ends) · 1 may carry it · 2 cleared · ⚠ Lower bound: 1 model could not be read')
 
   const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
   expect(await band.find({ type: 'Text', text: '◆ Lineage after this task · 1 model changed' })).toBeDefined()
@@ -239,6 +244,31 @@ test('Open report on WSL falls back to explorer.exe, whose exit 1 is success; /l
   expect(out.text).toBe(`Opened the column impact report: ${REPORT}`)
 })
 
+test('on WSL with no wslview and no explorer.exe on PATH, Windows\' own explorer.exe opens the report', async ($, on) => {
+  // The kernel release names Microsoft; WSL_DISTRO_NAME is unset.
+  const { runs, turn, clock } = await start($, on, { uname: 'Linux 6.6.87.2-microsoft-standard-WSL2', openers: { '/mnt/c/Windows/explorer.exe': 1 }, present: ['/mnt/c/Windows/explorer.exe'] })
+  await turn('t1', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
+  })
+  const out: any = await $.command.run({ command: 'lineage-report', args: '' } as any)
+  await clock.settle()
+  const win = '\\\\wsl.localhost\\dev\\repo\\target\\.altimate-lineage\\report.html'
+  const tried = runs.filter(one => ['wslview', 'explorer.exe', '/mnt/c/Windows/explorer.exe', 'xdg-open'].includes(one[0]!))
+  expect(tried).toEqual([['wslview', REPORT], ['explorer.exe', win], ['/mnt/c/Windows/explorer.exe', win]])
+  expect(out.text).toBe(`Opened the column impact report: ${REPORT}`)
+})
+
+test('on WSL with no Windows opener at all, xdg-open is the last try', async ($, on) => {
+  const { runs, turn } = await start($, on, { uname: 'Linux 6.6.87.2-microsoft-standard-WSL2', openers: { 'xdg-open': 0 } })
+  await turn('t1', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
+  })
+  const out: any = await $.command.run({ command: 'lineage-report', args: '' } as any)
+  const tried = runs.filter(one => ['wslview', 'explorer.exe', '/mnt/c/Windows/explorer.exe', 'xdg-open'].includes(one[0]!)).map(one => one[0])
+  expect(tried).toEqual(['wslview', 'explorer.exe', 'xdg-open'])
+  expect(out.text).toBe(`Opened the column impact report: ${REPORT}`)
+})
+
 test('when no browser opens, the band shows the report path as a link', async ($, on) => {
   const { runs, turn, clock } = await start($, on, { uname: 'Linux', openers: { 'xdg-open': 3 } })
   await turn('t1', async () => {
diff --git a/plugins/altimate-code/hooks/task-impact.tsx b/plugins/altimate-code/hooks/task-impact.tsx
index 748ab70..8b910a1 100644
--- a/plugins/altimate-code/hooks/task-impact.tsx
+++ b/plugins/altimate-code/hooks/task-impact.tsx
@@ -11,12 +11,13 @@ import {
   type ColumnTrace,
   type ModelChange,
   modelLevelOf,
-  openerFor,
+  openersFor,
   type Platform,
   reportData,
   reportHtml,
   summaryLines,
   summaryOf,
+  WINDOWS_EXPLORER,
 } from './impact-report'
 import { projectLayout } from './lineage-graph'
 import { openPane, projectRoot, runTool, within } from './lineage'
@@ -217,14 +218,17 @@ async function finishTask($: EngineInterface, t: Task) {
   if (seq !== finishSeq) return
   const view = summaryOf(changes, traces, report)
   await update($, summaryAtom, () => view)
-  $.ui.log(summaryLines(view).join('\n'))
+  // One line: a log line draws a newline as a replacement glyph.
+  $.ui.log(summaryLines(view).map(line => line.trim()).join(' · '))
 }
 
 /** Which opener family this machine has: macOS, Linux, WSL (Linux under Windows), or Windows itself. */
 async function platformOf($: EngineInterface): Promise<Platform> {
-  const uname = await $.process.run(['uname', '-s'], { timeoutMs: 5_000 }).catch(() => null)
+  // -r too: a WSL kernel's release names Microsoft, with no environment variable needed.
+  const uname = await $.process.run(['uname', '-sr'], { timeoutMs: 5_000 }).catch(() => null)
   if (!uname || uname.exitCode !== 0) return 'windows'
   if (/darwin/i.test(uname.stdout)) return 'mac'
+  if (/microsoft/i.test(uname.stdout)) return 'wsl'
   if (await $.env.get('WSL_DISTRO_NAME').catch(() => undefined)) return 'wsl'
   return /microsoft/i.test(await $.fs.read('/proc/version').catch(() => '')) ? 'wsl' : 'linux'
 }
@@ -232,17 +236,17 @@ async function platformOf($: EngineInterface): Promise<Platform> {
 /** Opens the report in the person's browser; false when no opener worked. */
 export async function openReport($: EngineInterface, path: string): Promise<boolean> {
   const platform = await platformOf($)
-  let opener = openerFor(platform, path)
+  let wsl = {}
   if (platform === 'wsl') {
-    // wslview when installed, else Windows' own explorer.exe on the Windows form of the path.
-    const viewed = await $.process.run(['wslview', path], { timeoutMs: 15_000 }).catch(() => null)
-    if (viewed?.exitCode === 0) return true
     const windows = await $.process.run(['wslpath', '-w', path], { timeoutMs: 5_000 }).catch(() => null)
-    opener = openerFor('wsl', path, { wslview: false, windowsPath: windows?.exitCode === 0 ? windows.stdout.trim() : null })
+    wsl = { windowsPath: windows?.exitCode === 0 ? windows.stdout.trim() || null : null, explorerAtC: await $.fs.exists(WINDOWS_EXPLORER).catch(() => false) }
   }
-  if (!opener) return false
-  const result = await $.process.run(opener.argv, { timeoutMs: 15_000 }).catch(() => null)
-  return !!result && opener.okExits.includes(result.exitCode)
+  // The first that starts and exits as it does on success; one that cannot start, or fails, gives way to the next.
+  for (const opener of openersFor(platform, path, wsl)) {
+    const result = await $.process.run(opener.argv, { timeoutMs: 15_000 }).catch(() => null)
+    if (result && opener.okExits.includes(result.exitCode)) return true
+  }
+  return false
 }
 
 async function openAndSay($: EngineInterface, path: string): Promise<boolean> {

From 8265bcc1a5cf1780ae4d0555e9d29fc772518ad2 Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Thu, 5 Nov 2026 21:15:47 +0800
Subject: [PATCH 05/21] fix: the per-edit note gives Claude the column answer's
 numbers, and logs only to debug

With a column answer, Claude's note has the reach, may-carry, cleared and model-level counts the summary shows; older builds keep the column reach. Per-edit lines leave the transcript.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YNQjkaiykbC1WtASw6Yegs
---
 plugins/altimate-code/hooks/impact-report.ts | 14 +++++
 plugins/altimate-code/hooks/lineage.test.tsx | 54 +++++++++++++++--
 plugins/altimate-code/hooks/lineage.tsx      | 61 +++++++++++++++-----
 3 files changed, 110 insertions(+), 19 deletions(-)

diff --git a/plugins/altimate-code/hooks/impact-report.ts b/plugins/altimate-code/hooks/impact-report.ts
index 3066485..3a751cc 100644
--- a/plugins/altimate-code/hooks/impact-report.ts
+++ b/plugins/altimate-code/hooks/impact-report.ts
@@ -126,6 +126,20 @@ export function reachOf(answer: ColumnAnswer): Reach {
   }
 }
 
+/** The downstream models that carry the value, each with the columns it lands in and its exposures, nearest first. */
+export function carriersOf(answer: ColumnAnswer): { name: string; columns: string[]; exposures: string[] }[] {
+  const byModel = new Map<number, { name: string; columns: string[]; exposures: string[]; hop: number }>()
+  for (const col of answer.columns) {
+    if (!(col.hop > 0)) continue
+    const node = answer.nodes[col.model]
+    const entry = byModel.get(col.model) ?? { name: String(node?.name ?? node?.id ?? col.model), columns: [], exposures: Array.isArray(node?.exposures) ? node!.exposures!.map(String) : [], hop: col.hop }
+    if (!entry.columns.includes(String(col.column))) entry.columns.push(String(col.column))
+    entry.hop = Math.min(entry.hop, col.hop)
+    byModel.set(col.model, entry)
+  }
+  return [...byModel.values()].sort((a, b) => a.hop - b.hop || a.name.localeCompare(b.name)).map(({ hop: _hop, ...rest }) => rest)
+}
+
 /** The traced answers for one changed column: downstream and upstream, each null when it failed. */
 export type ColumnTrace = { model: string; column: string | null; down: ColumnAnswer | null; up: ColumnAnswer | null; modelLevel: number | null; failed: boolean }
 
diff --git a/plugins/altimate-code/hooks/lineage.test.tsx b/plugins/altimate-code/hooks/lineage.test.tsx
index 31a9fc5..600a4a6 100644
--- a/plugins/altimate-code/hooks/lineage.test.tsx
+++ b/plugins/altimate-code/hooks/lineage.test.tsx
@@ -69,6 +69,7 @@ async function start($: any, on: any, options: Options = {}) {
   // The per-edit impact note: logged for the record, never a toast (the person sees the end-of-task summary).
   const notes: string[] = []
   const logs: string[] = []
+  const debug: string[] = []
   const lists: string[] = []
   on('command.register', () => ({ value: { command: 'lineage' } }))
   // A turn's start and end beneath the plugin: the engine's answer is the model's text.
@@ -82,9 +83,10 @@ async function start($: any, on: any, options: Options = {}) {
     toasts.push(e.text)
     return { value: undefined }
   })
-  on('ui.log', (_: unknown, e: { text: string }) => {
-    logs.push(e.text)
-    if (e.text.startsWith('◆ impact-first · ') && !e.text.startsWith('◆ impact-first · impact_analysis(')) notes.push(e.text)
+  // The transcript's lines, and the debug log's apart.
+  on('ui.log', (_: unknown, e: { text: string; to?: string }) => {
+    ;(e.to === 'debug' ? debug : logs).push(e.text)
+    if (e.to === 'debug' && e.text.startsWith('◆ impact-first · ')) notes.push(e.text)
     return { value: undefined }
   })
   on('ui.render', ($$: any, e: any) => {
@@ -191,7 +193,7 @@ async function start($: any, on: any, options: Options = {}) {
   })
   await $.session.start({ cwd: ROOT, surface: 'terminal', isInteractive: true })
   await clock.settle()
-  return { clock, calls, toasts, notes, logs, lists }
+  return { clock, calls, toasts, notes, logs, debug, lists }
 }
 
 test('reading a model points the pane at it: the manifest graph, then its columns from dbt_lineage', async ($, on) => {
@@ -213,7 +215,7 @@ test('reading a model points the pane at it: the manifest graph, then its column
 })
 
 test('an edit naming a column is held until its reach is known, then the reach goes to Claude and the log, not the person', async ($, on) => {
-  const { clock, calls, toasts, notes, logs } = await start($, on)
+  const { clock, calls, toasts, notes, logs, debug } = await start($, on)
   const edit = { tool: 'Edit' as const, file_path: FILE, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) - sum(refunds) as revenue' }
   const result: any = await $.tool.call(edit)
   await clock.settle()
@@ -224,7 +226,9 @@ test('an edit naming a column is held until its reach is known, then the reach g
   expect(toasts).toEqual([])
   expect(result.context?.[0]).toContain('read by 2 downstream models: fct_revenue_daily (revenue), rpt_finance_weekly (revenue)')
   expect(result.context?.[0]).toContain('dashboards on them: "Exec Revenue"')
-  expect(logs).toContain("impact-first · added to Claude's context: lineage for fct_orders.revenue")
+  expect(debug).toContain("impact-first · added to Claude's context: lineage for fct_orders.revenue")
+  // Nothing per edit reaches the transcript: the person's one line is the end-of-task summary.
+  expect(logs.filter(line => line.includes('impact-first'))).toEqual([])
 
   // The band waits for the end of the task (task-impact.tsx): nothing per edit.
   const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
@@ -237,6 +241,44 @@ test('an edit naming a column is held until its reach is known, then the reach g
   expect(again.context ?? []).toEqual([])
 })
 
+test('with a column answer, the note Claude gets has the numbers the end-of-task summary shows', async ($, on) => {
+  // The same call carries the older column reach too: the column answer wins.
+  const answer = {
+    version: 1,
+    focus: { model: 'model.shop.fct_orders', column: 'revenue' },
+    direction: 'downstream',
+    counts: { columns: 3, models: 2, hops: 2, contracts: 0, ends: 2, may_carry_models: 4, cleared_models: 1, model_level: 6 },
+    nodes: [
+      { id: 'model.shop.fct_orders', name: 'fct_orders', exposures: [] },
+      { id: 'model.shop.fct_revenue_daily', name: 'fct_revenue_daily', exposures: ['exec_revenue'] },
+      { id: 'model.shop.rpt_finance_weekly', name: 'rpt_finance_weekly', exposures: [] },
+      { id: 'model.shop.rpt_broken', name: 'rpt_broken', exposures: [] },
+    ],
+    columns: [
+      { model: 0, column: 'revenue', hop: 0, how: null, how_from: null },
+      { model: 1, column: 'revenue', hop: 1, end: false, how: '=', how_from: 'engine' },
+      { model: 1, column: 'daily_revenue', hop: 1, end: true, how: '\u03a3', how_from: 'engine' },
+      { model: 2, column: 'weekly_revenue', hop: 2, end: true, how: '\u03a3', how_from: 'engine' },
+    ],
+    edges: [[0, 1, '='], [0, 2, '\u03a3'], [1, 3, '\u03a3']],
+    also_reads: [],
+    unresolved: [{ model: 3, reason: 'parse error' }],
+    cleared: [{ id: 'model.shop.dim_dates', name: 'dim_dates' }],
+    truncated: false,
+  }
+  const { clock, notes } = await start($, on, { reach: { ...REACH, column_answer: answer } })
+  const result: any = await $.tool.call({ tool: 'Edit', file_path: FILE, old_string: 'x as revenue', new_string: 'y as revenue' })
+  await clock.settle()
+  const note = result.context?.[0] as string
+  expect(note).toContain('- revenue: its value reaches 3 columns in 2 downstream models (2 end columns): fct_revenue_daily (revenue, daily_revenue), rpt_finance_weekly (weekly_revenue)')
+  expect(note).toContain('  dashboards on them: exec_revenue')
+  expect(note).toContain('  4 more models may carry it (they read it outside the select, or sit below a model that could not be read); 1 other downstream model does not carry it; 6 downstream models at model level')
+  expect(note).toContain('  lower bound: 1 model could not be read: rpt_broken ("parse error")')
+  // The older reach numbers are not given alongside.
+  expect(note).not.toContain('read by 2 downstream models')
+  expect(notes[0]).toBe('◆ impact-first · fct_orders.revenue reaches 3 columns in 2 models, 4 may carry it · exec_revenue')
+})
+
 test('[c] picks a column and shows its reach; [d] unfolds downstream; a model in the graph is followed on press', async ($, on) => {
   const { clock, calls } = await start($, on)
   await $.tool.call({ tool: 'Read', file_path: FILE })
diff --git a/plugins/altimate-code/hooks/lineage.tsx b/plugins/altimate-code/hooks/lineage.tsx
index b1b607d..a78e0fa 100644
--- a/plugins/altimate-code/hooks/lineage.tsx
+++ b/plugins/altimate-code/hooks/lineage.tsx
@@ -33,6 +33,7 @@ import {
   upstreamArt,
   warehouseEdges,
 } from './lineage-graph'
+import { answerOf, carriersOf, type ColumnAnswer, reachOf } from './impact-report'
 import { taskBeforeTool, taskTurnComplete, taskTurnStart } from './task-impact'
 
 const PANE = 'altimate-lineage'
@@ -889,6 +890,7 @@ async function impactFirst($: EngineInterface, e: any, file: string, deadline: n
   const touched = everyTouched.slice(0, MAX_EDIT_COLUMNS)
 
   let reach: ColumnReachView | null = null
+  const answered: { column: string; answer: ColumnAnswer }[] = []
   const traced: string[] = []
   // Touched columns whose check failed or ran out of time: what they reach is unknown.
   // Columns beyond the cap are never traced either.
@@ -907,24 +909,41 @@ async function impactFirst($: EngineInterface, e: any, file: string, deadline: n
         return within($, left, shared(`impact\u0000${manifest}\u0000${stat.mtimeMs}\u0000${id}\u0000${col}`, () => runTool($, 'impact_analysis', args, false, deadline)))
       }),
     )
-    const reaches = results.map((result, i) => (result?.ok ? reachFromMetadata(result.metadata, node.name, touched[i]!) : null))
-    reaches.forEach((one, i) => (one ? traced : unchecked).push(touched[i]!))
-    reach = mergeReach(reaches.filter((one): one is ColumnReachView => !!one))
+    // The column answer, as the end-of-task summary reads it, so Claude and the person see one set of
+    // numbers; the older column reach only from an altimate-code that sends no column answer.
+    const answers = results.map(result => (result?.ok ? answerOf(result.metadata) : null))
+    if (answers.some(Boolean)) {
+      answers.forEach((one, i) => {
+        ;(one ? traced : unchecked).push(touched[i]!)
+        if (one) answered.push({ column: touched[i]!, answer: one })
+      })
+    } else {
+      const reaches = results.map((result, i) => (result?.ok ? reachFromMetadata(result.metadata, node.name, touched[i]!) : null))
+      reaches.forEach((one, i) => (one ? traced : unchecked).push(touched[i]!))
+      reach = mergeReach(reaches.filter((one): one is ColumnReachView => !!one))
+    }
     const ms = Math.round((await $.clock.now()) - began)
-    if (reach) $.ui.log(`impact-first · impact_analysis(${node.name}.${traced.join(', ')}) · ${elapsed(ms)}`)
+    if (traced.length) $.ui.log(`impact-first · impact_analysis(${node.name}.${traced.join(', ')}) · ${elapsed(ms)}`, { to: 'debug' })
   }
   const column = traced.length ? traced.join(', ') : null
 
-  const target = column && reach ? `${node.name}.${column}` : node.name
+  const target = column && (reach || answered.length) ? `${node.name}.${column}` : node.name
   const plural = (n: number, word: string) => `${n} ${word}${n === 1 ? '' : 's'}`
   // What the engine could not settle keeps the count a lower bound, never a confident zero.
   const unsettled = reach ? reach.uncertain.length + reach.untraced.length + (reach.truncated ? 1 : 0) + unchecked.length : 0
   const atLeast = unsettled > 0 ? 'at least ' : ''
   // Dashboards on models that may read the column count too: a rename breaks a filter for certain.
-  const dashboards = reach ? [...reach.exposures, ...reach.uncertainExposures] : counts.exposures
+  const carried = answered.map(one => ({ ...one, reach: reachOf(one.answer), carriers: carriersOf(one.answer) }))
+  const dashboards = reach
+    ? [...reach.exposures, ...reach.uncertainExposures]
+    : carried.length
+      ? [...new Set(carried.flatMap(one => one.carriers.flatMap(model => model.exposures)))]
+      : counts.exposures
   const toast = reach
     ? `${target} is read by ${atLeast}${plural(reach.models.length, 'model')} and ${reach.exposuresError ? 'at least ' : ''}${plural(dashboards.length, 'dashboard')}`
-    : `${target} feeds ${graph.truncated ? 'at least ' : ''}${plural(downstream, 'model')} and ${plural(dashboards.length, 'dashboard')}`
+    : carried.length
+      ? carried.map(one => `${node.name}.${one.column} reaches ${plural(one.reach.columns, 'column')} in ${plural(one.reach.models, 'model')}, ${one.reach.mayCarry} may carry it`).join('; ')
+      : `${target} feeds ${graph.truncated ? 'at least ' : ''}${plural(downstream, 'model')} and ${plural(dashboards.length, 'dashboard')}`
   const toastText = `◆ impact-first · ${toast}${dashboards.length ? ` · ${dashboards.slice(0, 3).join(' · ')}` : ''}`.replace(CONTROL, ' ').slice(0, 300)
 
   // Names and labels come from the project's files, which anyone who wrote the repo controls: each is
@@ -940,6 +959,21 @@ async function impactFirst($: EngineInterface, e: any, file: string, deadline: n
     if (reach.uncertain.length) lines.push(`- may also read it: ${capped(reach.uncertain.map(one => `${quoted(one.name)} (${quoted(one.reason)})`), 10)}`)
     if (reach.untraced.length) lines.push(`- could not be traced: ${capped(reach.untraced.map(one => `${quoted(one.name)} (${quoted(one.reason)})`), 10)}`)
   }
+  for (const one of carried) {
+    const r = one.reach
+    const named = one.carriers.map(model => `${quoted(model.name)} (${listed(model.columns, 8)})`)
+    lines.push(`- ${quoted(one.column)}: its value reaches ${plural(r.columns, 'column')} in ${plural(r.models, 'downstream model')} (${plural(r.ends, 'end column')})${named.length ? `: ${capped(named, 15)}` : ''}`)
+    const exposures = [...new Set(one.carriers.flatMap(model => model.exposures))]
+    if (exposures.length) lines.push(`  dashboards on them: ${listed(exposures)}`)
+    lines.push(
+      `  ${plural(r.mayCarry, 'more model')} may carry it (they read it outside the select, or sit below a model that could not be read); ${r.cleared === null ? 'the other downstream models do' : `${plural(r.cleared, 'other downstream model')} ${r.cleared === 1 ? 'does' : 'do'}`} not carry it${r.modelLevel === null ? '' : `; ${plural(r.modelLevel, 'downstream model')} at model level`}`,
+    )
+    const unresolved = one.answer.unresolved ?? []
+    if (unresolved.length || r.truncated) {
+      const why = unresolved.map(entry => `${quoted(String(one.answer.nodes[entry.model]?.name ?? entry.model))} (${quoted(String(entry.reason ?? 'not read'))})`)
+      lines.push(`  lower bound: ${plural(unresolved.length, 'model')} could not be read${why.length ? `: ${capped(why, 10)}` : ''}${r.truncated ? '; the trace stopped at its limit' : ''}`)
+    }
+  }
   lines.push(
     `- ${quoted(node.name)} feeds ${graph.truncated ? 'at least ' : ''}${plural(downstream, 'downstream model')} in all (${counts.direct} direct, ${counts.transitive} transitive), ${plural(counts.tests, 'test')}${counts.exposures.length ? ` and ${plural(counts.exposures.length, 'exposure')} (${listed(counts.exposures)})` : ''}.`,
   )
@@ -954,14 +988,14 @@ async function impactFirst($: EngineInterface, e: any, file: string, deadline: n
     context: `${body.length > MAX_NOTE ? `${cut(body, MAX_NOTE)}...` : body}\n${close}`,
     view: {
       model: node.name,
-      column: reach ? column : null,
+      column: reach || carried.length ? column : null,
       severity: counts.severity,
       direct: counts.direct,
       transitive: counts.transitive,
       tests: counts.tests,
       exposures: dashboards,
-      readers: reach ? reach.models.length : null,
-      unsettled,
+      readers: reach ? reach.models.length : carried.length ? new Set(carried.flatMap(one => one.carriers.map(model => model.name))).size : null,
+      unsettled: unsettled + carried.reduce((n, one) => n + one.reach.unresolved + one.reach.mayCarry, 0),
       ...(reach?.exposuresError && { dashboardsUnsettled: true }),
       truncated: !!graph.truncated,
     },
@@ -1141,8 +1175,9 @@ export function registerLineage(on: On) {
     // Out of time before even the model-level lookup finished: say so, rather than nothing.
     // The person sees the end-of-task summary (task-impact.tsx), not a note per edit: these lines go
     // to the log, and the note itself to Claude's context below.
-    if (lookup && !note && !finished && progress.project) $.ui.log('◆ impact-first · the lineage lookup did not finish in time; the edit went ahead without it')
-    if (note) $.ui.log(note.toast)
+    // The debug log only: the person's one line is the end-of-task summary.
+    if (lookup && !note && !finished && progress.project) $.ui.log('◆ impact-first · the lineage lookup did not finish in time; the edit went ahead without it', { to: 'debug' })
+    if (note) $.ui.log(note.toast, { to: 'debug' })
     const result = await next(e)
     if (result.deny || result.isError) return result
     // After the edit lands: a .sql file or dbt_project.yml changed, so the SQL-file graphs are stale.
@@ -1195,7 +1230,7 @@ export function registerLineage(on: On) {
     if (note) {
       if (!contextGiven.has(note.key)) {
         contextGiven.add(note.key)
-        $.ui.log(`impact-first · added to Claude's context: lineage for ${note.view.column ? `${note.view.model}.${note.view.column}` : note.view.model}`)
+        $.ui.log(`impact-first · added to Claude's context: lineage for ${note.view.column ? `${note.view.model}.${note.view.column}` : note.view.model}`, { to: 'debug' })
         return { ...result, context: [...(result.context ?? []), note.context] } as typeof result
       }
     }

From 26a7a94a887c755ee177cf2bc7bc27c60f7ebbdf Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Fri, 6 Nov 2026 13:30:12 +0800
Subject: [PATCH 06/21] feat: the lineage pane opens only when asked

Reads, edits and answers still move what it shows, so `/lineage` or Open lineage opens it on the latest model. A session that never asks sees no pane at any width.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YNQjkaiykbC1WtASw6Yegs
---
 plugins/altimate-code/CHANGELOG.md           |  1 +
 plugins/altimate-code/README.md              |  2 +-
 plugins/altimate-code/hooks/lineage.test.tsx | 30 ++++++++++++++++++--
 plugins/altimate-code/hooks/lineage.tsx      | 13 ++-------
 4 files changed, 33 insertions(+), 13 deletions(-)

diff --git a/plugins/altimate-code/CHANGELOG.md b/plugins/altimate-code/CHANGELOG.md
index 87c0c7e..e363245 100644
--- a/plugins/altimate-code/CHANGELOG.md
+++ b/plugins/altimate-code/CHANGELOG.md
@@ -9,6 +9,7 @@ All notable changes to this plugin will be documented in this file.
 
 ### Changed
 - The per-edit impact note no longer shows as a toast and band; it still goes to Claude's context with the edit's result.
+- The lineage pane no longer opens by itself at any width. `/lineage` and **Open lineage** open it, on the model it has been following.
 
 ## [1.4.0] — 2026-10-28
 
diff --git a/plugins/altimate-code/README.md b/plugins/altimate-code/README.md
index 27d1254..caf2664 100644
--- a/plugins/altimate-code/README.md
+++ b/plugins/altimate-code/README.md
@@ -100,7 +100,7 @@ The side pane and band need a Claude Code build with hooks modules and `altimate
 
 ## Lineage beside the chat
 
-The plugin's lineage pane follows the dbt model Claude reads or edits (by Read, Edit, a shell command that names or finds its `.sql` file, or a `dbt_lineage` call), read from `target/manifest.json` with no model calls. A project with no manifest still gets its graph, read from the models' `ref()` and `source()` calls; columns, dashboards and column reach then need `dbt parse` or `dbt compile`. From a monorepo's root, `/lineage <model>` finds the dbt project below it that has the model:
+The plugin's lineage pane opens when you ask for it, with `/lineage` or the summary's **Open lineage**, never by itself: a sidebar doesn't suit a narrow terminal or several side by side. It follows the dbt model Claude reads or edits (by Read, Edit, a shell command that names or finds its `.sql` file, or a `dbt_lineage` call), open or not, so it opens on the latest one. It reads `target/manifest.json` with no model calls. A project with no manifest still gets its graph, read from the models' `ref()` and `source()` calls; columns, dashboards and column reach then need `dbt parse` or `dbt compile`. From a monorepo's root, `/lineage <model>` finds the dbt project below it that has the model:
 
 - **The graph.** The model's whole lineage as boxes and arrows, like dbt-lineage-viewer: every level upstream on the left and downstream on the right, every model, every name in full, dashboards (exposures) marked ◆. Nothing is folded or cut: the pane is a window onto the drawing. Scroll it up and down with the mouse, touchpad or arrow keys, pan it with `h` and `l` (or ◀ ▶), and `f` brings the model back to the middle. Links between models on the same level, or that skip a level, are not drawn. Press a model to follow it. With a column picked, the models and dashboards that read it are highlighted and the rest dimmed.
 - **Views for big projects.** `v` cycles the graph, **ends only** (the sources and dashboards the model sits between; "via N" counts the models between them on the shortest path), **folders** (sources, staging, intermediate, marts and dashboards as one box each, with counts, in dbt layer order: a source-to-mart chain on one screen) and the text **list** of upstream and downstream. A pane narrower than 48 columns shows the list. The pane keeps up to 500 models upstream, and through altimate-code (a manifest over 4 MiB) up to 500 downstream too; past that the header says which side was cut.
diff --git a/plugins/altimate-code/hooks/lineage.test.tsx b/plugins/altimate-code/hooks/lineage.test.tsx
index 600a4a6..53b2fdf 100644
--- a/plugins/altimate-code/hooks/lineage.test.tsx
+++ b/plugins/altimate-code/hooks/lineage.test.tsx
@@ -71,6 +71,7 @@ async function start($: any, on: any, options: Options = {}) {
   const logs: string[] = []
   const debug: string[] = []
   const lists: string[] = []
+  const opens: string[] = []
   on('command.register', () => ({ value: { command: 'lineage' } }))
   // A turn's start and end beneath the plugin: the engine's answer is the model's text.
   on('turn.start', (_: unknown, e: { turnId: string }) => ({ turnId: e.turnId }))
@@ -78,7 +79,10 @@ async function start($: any, on: any, options: Options = {}) {
   on('turn.complete', (_: unknown, e: { answer: string }) => ({ text: e.answer }))
   on('session.start', (_: unknown, e: { cwd: string }) => ({ cwd: e.cwd }))
   on('session.root', () => ({ value: ROOT }))
-  on('ui.open', () => ({ value: {} }))
+  on('ui.open', (_: unknown, e: { id: string }) => {
+    opens.push(e.id)
+    return { value: {} }
+  })
   on('ui.toast', (_: unknown, e: { text: string }) => {
     toasts.push(e.text)
     return { value: undefined }
@@ -193,7 +197,7 @@ async function start($: any, on: any, options: Options = {}) {
   })
   await $.session.start({ cwd: ROOT, surface: 'terminal', isInteractive: true })
   await clock.settle()
-  return { clock, calls, toasts, notes, logs, debug, lists }
+  return { clock, calls, toasts, notes, logs, debug, lists, opens }
 }
 
 test('reading a model points the pane at it: the manifest graph, then its columns from dbt_lineage', async ($, on) => {
@@ -214,6 +218,28 @@ test('reading a model points the pane at it: the manifest graph, then its column
   await ui.unmount()
 })
 
+test('the pane never opens by itself: reads, edits, shell commands and answers only move what it shows', async ($, on) => {
+  const { clock, opens } = await start($, on)
+  await $.tool.call({ tool: 'Read', file_path: FILE })
+  await clock.settle()
+  await $.tool.call({ tool: 'Edit', file_path: FILE, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
+  await clock.settle()
+  await $.tool.call({ tool: 'Bash', command: `cat ${FILE}` })
+  await clock.settle()
+  await $.turn.start({ text: 'which model?', turnId: 't2' })
+  await $.turn.complete({ answer: 'Look at `fct_orders`.', durationMs: 5, isAborted: false, reason: 'answer', turnId: 't2' } as any)
+  await clock.settle()
+  expect(opens).toEqual([])
+
+  // It stays one command away, on the model it followed.
+  await $.command.run({ command: 'lineage', args: '' } as any)
+  await clock.settle()
+  expect(opens).toEqual(['altimate-lineage'])
+  const ui = await $.ui.mount({ ...PANE, surface: 'terminal' })
+  expect(await ui.find({ type: 'Text', text: /lineage · fct_orders/ })).toBeDefined()
+  await ui.unmount()
+})
+
 test('an edit naming a column is held until its reach is known, then the reach goes to Claude and the log, not the person', async ($, on) => {
   const { clock, calls, toasts, notes, logs, debug } = await start($, on)
   const edit = { tool: 'Edit' as const, file_path: FILE, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) - sum(refunds) as revenue' }
diff --git a/plugins/altimate-code/hooks/lineage.tsx b/plugins/altimate-code/hooks/lineage.tsx
index a78e0fa..ae588f3 100644
--- a/plugins/altimate-code/hooks/lineage.tsx
+++ b/plugins/altimate-code/hooks/lineage.tsx
@@ -76,8 +76,6 @@ const loadingAtom = atom({ plugin: 'altimate-code', key: 'lineageLoading' } as c
 let manifestCache: { path: string; mtimeMs: number; graph: LineageGraph } | null = null
 // Graphs altimate-code returned for a manifest over 4 MiB, by manifest, revision and model.
 const toolsCache = new Map<string, { graph: LineageGraph; id: string; columns: ColumnLineage | null } | null>()
-// Per conversation: reset on session start and end (a /clear ends one).
-let paneOpened = false
 /** The latest follow: an older one still reading its manifest must not write over it. */
 // Follows run concurrently. Each takes a number when it starts; one that finds its model claims the
 // pane unless a newer one already has. A follow that fails claims nothing, so it cancels nobody.
@@ -677,10 +675,8 @@ async function followOnce($: EngineInterface, input: FollowInput): Promise<boole
     await update($, columnAtom, prev => (superseded() ? prev : column ?? null))
     await update($, reachAtom, prev => (superseded() ? prev : null))
   }
-  if (input.open || (!paneOpened && input.auto)) {
-    paneOpened = true
-    await $.ui.open({ id: PANE, title: PANE_TITLE, ...PANE_SIZE, ...(input.open ? { focus: true as const } : {}), closeOnEscape: true }).catch(() => {})
-  }
+  // Only when asked: a pane that opens by itself takes a narrow terminal's width.
+  if (input.open) await $.ui.open({ id: PANE, title: PANE_TITLE, ...PANE_SIZE, focus: true, closeOnEscape: true }).catch(() => {})
   const focus: LineageFocus = { model: id, root, manifest, via, readMs, mtimeMs, stamp: began }
   // Columns handed in by a tool call may be another project's model of the same name: keep them only
   // for this model (by unique_id when the answer gives one, else by name).
@@ -792,7 +788,6 @@ async function loadWarehouse($: EngineInterface) {
 }
 
 export async function openPane($: EngineInterface) {
-  paneOpened = true
   await $.ui.open({ id: PANE, title: PANE_TITLE, ...PANE_SIZE, focus: true, closeOnEscape: true })
 }
 
@@ -1029,8 +1024,7 @@ function parsedLineage(text: string | undefined): ColumnLineage | null {
 
 /** Registers /lineage; called from the plugin's one session.start hook. */
 export async function startLineage($: EngineInterface) {
-  // A new session opens the pane on its first follow again and owes Claude the context again.
-  paneOpened = false
+  // A new session owes Claude the context again.
   drawnCache = null
   contextGiven.clear()
   newConversation()
@@ -1074,7 +1068,6 @@ function drawRow(ui: Ui, $: EngineInterface, graph: LineageGraph, segments: Segm
 export function registerLineage(on: On) {
   // A new user turn gets the lineage note again (its context may have been compacted since), once.
   on('session.end', async ($, e, next) => {
-    paneOpened = false
     drawnCache = null
     contextGiven.clear()
     newConversation()

From 1e4adcb84bee61113a2635a7cac23c8c3fbc10fb Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Fri, 6 Nov 2026 14:08:29 +0800
Subject: [PATCH 07/21] fix: a cut-off altimate-code answer is a failure, not
 "no such model"

Invalid JSON with exit 0 counted as ok with no metadata, so the graph lookup cached "no model" for the session and the edit's impact note silently went missing. It now reports a failure and asks again next time.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YNQjkaiykbC1WtASw6Yegs
---
 plugins/altimate-code/hooks/lineage.test.tsx | 21 +++++++++++++++++++-
 plugins/altimate-code/hooks/lineage.tsx      |  3 +++
 2 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/plugins/altimate-code/hooks/lineage.test.tsx b/plugins/altimate-code/hooks/lineage.test.tsx
index 53b2fdf..306b1d6 100644
--- a/plugins/altimate-code/hooks/lineage.test.tsx
+++ b/plugins/altimate-code/hooks/lineage.test.tsx
@@ -55,7 +55,7 @@ const REACH = {
   },
 }
 
-type Options = { mcp?: boolean; warehouse?: boolean; structured?: boolean; size?: number; mtime?: () => number; reach?: Record<string, unknown>; capped?: boolean; lineageText?: string; toolResult?: (e: { tool: string }) => unknown; failColumn?: string; holdFirstManifestRead?: Promise<void>; holdReach?: { column: string; until: Promise<void> }; modelLineage?: Record<string, unknown>; cliTooLarge?: boolean; cliFailure?: boolean; sqlFiles?: Record<string, string>; holdFirstSqlRead?: Promise<void>; holdManifestStat?: { at: number; until: Promise<void> }; noRootProject?: boolean; mcpHang?: string }
+type Options = { mcp?: boolean; warehouse?: boolean; structured?: boolean; size?: number; mtime?: () => number; reach?: Record<string, unknown>; capped?: boolean; lineageText?: string; toolResult?: (e: { tool: string }) => unknown; failColumn?: string; holdFirstManifestRead?: Promise<void>; holdReach?: { column: string; until: Promise<void> }; modelLineage?: Record<string, unknown>; cliTooLarge?: boolean; cliCutOff?: () => boolean; cliFailure?: boolean; sqlFiles?: Record<string, string>; holdFirstSqlRead?: Promise<void>; holdManifestStat?: { at: number; until: Promise<void> }; noRootProject?: boolean; mcpHang?: string }
 
 /**
  * A dbt project at /repo, the plugin's MCP server (or the CLI when it is not connected), and the
@@ -182,6 +182,7 @@ async function start($: any, on: any, options: Options = {}) {
     calls.push(`cli:${tool}${args.include_graph ? ':graph' : ''}`)
     if (options.cliFailure) return { value: { exitCode: 1, stdout: JSON.stringify({ status: 'error', output: 'the dbt project could not start', metadata: {} }), stderr: '' } }
     if (options.cliTooLarge) return { value: { exitCode: 0, stdout: '{"status":"ok","out', stderr: '', isStdoutTruncated: true } }
+    if (options.cliCutOff?.()) return { value: { exitCode: 0, stdout: '{"status":"ok","out', stderr: '' } }
     // altimate-code's dbt_lineage with include_graph returns the subgraph the pane would build itself.
     const graph = args.include_graph ? { graph: subgraph(buildGraph(MANIFEST), 'model.shop.fct_orders') } : {}
     const body =
@@ -635,6 +636,24 @@ test("an answer from altimate-code too large to read says so, rather than that t
   await ui.unmount()
 })
 
+test('an answer cut off on its way is a failure, not "no such model": it is not remembered, and the next look asks again', async ($, on) => {
+  let cut = true
+  const { clock, calls } = await start($, on, { size: 6 * 1024 * 1024, cliCutOff: () => cut })
+  await $.tool.call({ tool: 'Read', file_path: FILE })
+  await clock.settle()
+  const ui = await $.ui.mount({ ...PANE, surface: 'terminal' })
+  expect(await ui.find({ type: 'Text', text: /altimate-code failed: dbt_lineage's answer could not be read/ })).toBeDefined()
+  await ui.unmount()
+  cut = false
+  const before = calls.filter(one => one === 'cli:dbt_lineage:graph').length
+  await $.tool.call({ tool: 'Read', file_path: FILE })
+  await clock.settle()
+  expect(calls.filter(one => one === 'cli:dbt_lineage:graph').length).toBe(before + 1)
+  const again = await $.ui.mount({ ...PANE, surface: 'terminal' })
+  expect(await again.find({ type: 'Text', text: /lineage · fct_orders/ })).toBeDefined()
+  await again.unmount()
+})
+
 test("altimate-code's own failure on a large manifest is shown as a failure, not as no such model", async ($, on) => {
   const { clock } = await start($, on, { size: 6 * 1024 * 1024, cliFailure: true })
   await $.tool.call({ tool: 'Read', file_path: FILE })
diff --git a/plugins/altimate-code/hooks/lineage.tsx b/plugins/altimate-code/hooks/lineage.tsx
index ae588f3..54554dd 100644
--- a/plugins/altimate-code/hooks/lineage.tsx
+++ b/plugins/altimate-code/hooks/lineage.tsx
@@ -444,6 +444,9 @@ export async function runTool($: EngineInterface, name: string, args: Record<str
     return { metadata: null as any, text: `${name}'s answer was larger than the 4 MiB a plugin can read`, ok: false }
   }
   const data = parseJson<{ status?: string; output?: string; metadata?: unknown }>(result.stdout)
+  // An answer that is not JSON (an altimate-code that exits before a pipe drains cuts it off) is a failure
+  // to report and ask again, not "no such model".
+  if (result.exitCode === 0 && !data) return { metadata: null as any, text: `${name}'s answer could not be read`, ok: false }
   return { metadata: (data?.metadata ?? null) as any, text: data?.output ?? '', ok: result.exitCode === 0 && data?.status !== 'error' }
 }
 

From b25ec9b393828ac3f8dc60026d8ade5c2ab4fd49 Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Fri, 6 Nov 2026 14:09:03 +0800
Subject: [PATCH 08/21] feat: report built on demand, leading with what changed
 and who consumes it

The task end traces downstream for the band only. Open report or `/lineage-report` traces upstream and writes the page from what the task froze. It opens in plain words, lists dbt exposures or says none are declared, and keeps the levels and paths below.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YNQjkaiykbC1WtASw6Yegs
---
 plugins/altimate-code/CHANGELOG.md            |   6 +-
 plugins/altimate-code/README.md               |   3 +-
 .../altimate-code/hooks/impact-report.test.ts | 121 +++++++++-
 plugins/altimate-code/hooks/impact-report.ts  | 185 ++++++++++++--
 .../altimate-code/hooks/task-impact.test.tsx  | 221 ++++++++++++++---
 plugins/altimate-code/hooks/task-impact.tsx   | 225 +++++++++++++-----
 plugins/altimate-code/types/index.d.ts        |   6 +-
 7 files changed, 645 insertions(+), 122 deletions(-)

diff --git a/plugins/altimate-code/CHANGELOG.md b/plugins/altimate-code/CHANGELOG.md
index e363245..aa184d5 100644
--- a/plugins/altimate-code/CHANGELOG.md
+++ b/plugins/altimate-code/CHANGELOG.md
@@ -5,12 +5,16 @@ All notable changes to this plugin will be documented in this file.
 ## [Unreleased]
 
 ### Added
-- End-of-task column impact: after a task that changed a dbt model, a band sums up each changed column's downstream reach from `impact_analysis`, and **Open report** or `/lineage-report` opens an offline HTML report with upstream and downstream lineage, two levels by default, and click-to-highlight paths. The task's start copies `target/manifest.json` aside, so the answer reflects the SQL before the task.
+- End-of-task column impact: after a task that changed a dbt model, a band sums up each changed column's downstream reach from `impact_analysis`. The task's start copies `target/manifest.json` aside, so the answer reflects the SQL before the task.
+- An offline HTML report, built when **Open report** or `/lineage-report` asks for it: what changed and what to expect downstream in plain words, who consumes it from dbt exposures, then upstream and downstream lineage, two levels by default, and click-to-highlight paths.
 
 ### Changed
 - The per-edit impact note no longer shows as a toast and band; it still goes to Claude's context with the edit's result.
 - The lineage pane no longer opens by itself at any width. `/lineage` and **Open lineage** open it, on the model it has been following.
 
+### Fixed
+- An altimate-code answer that arrives cut off is a failure that gets asked again, not "no such model" remembered for the session.
+
 ## [1.4.0] — 2026-10-28
 
 ### Added
diff --git a/plugins/altimate-code/README.md b/plugins/altimate-code/README.md
index caf2664..f2a964f 100644
--- a/plugins/altimate-code/README.md
+++ b/plugins/altimate-code/README.md
@@ -108,7 +108,8 @@ The plugin's lineage pane opens when you ask for it, with `/lineage` or the summ
 - **Columns.** Each output column with its source columns and how it is derived, from altimate-code's `dbt_lineage`, read from the compiled manifest (`dbt compile`). The plugin's calls are read-only, so altimate-code never starts the project's dbt adapter for them.
 - **Column reach.** `c` picks a column; the pane shows the downstream models whose SQL reads it and the dashboards on them, from `impact_analysis` (it traces each downstream model's compiled SQL, renames included). Models that name the column only in a filter or join, or that could not be traced (no compiled SQL), are listed apart, and the count is then a lower bound.
 - **Impact first.** Before an edit to a model's SQL lands, the plugin checks what reads the model and the reach of every column the edit touches (up to three, merged), and adds it to Claude's context with the edit's result. You see the summary at the end of the task, not a note per edit.
-- **End-of-task summary.** When a task (one prompt and Claude's work on it) changed a model, by an edit or a shell command git sees, a band above the prompt says what changed and how far it reaches: each changed column (up to three per model) with how it is derived, the columns, models and end columns downstream that carry its value, the models that may carry it and those cleared, next to the model-level count, and a line when some models could not be read. The trace reads a copy of `target/manifest.json` taken when the task started (`target/.altimate-lineage/manifest-before.json`), so a recompile mid-task does not change the answer. **Open report** (or `/lineage-report`) opens a full offline HTML report in the browser (`target/.altimate-lineage/report.html`): the change before and after, two levels upstream and downstream (more on request), and a click on any column lights up its path.
+- **End-of-task summary.** When a task (one prompt and Claude's work on it) changed a model, by an edit or a shell command git sees, a band above the prompt says what changed and how far it reaches: each changed column (up to three per model) with the columns, models and end columns downstream that carry its value, the models that may carry it and those cleared, next to the model-level count, and a line when some models could not be read. The trace reads a copy of `target/manifest.json` taken when the task started, so a recompile mid-task does not change the answer. These lookups go through the CLI, so they raise no permission prompt.
+- **The report, on demand.** **Open report** or `/lineage-report` builds an offline HTML report of the last task that changed a model and opens it in the browser (`target/.altimate-lineage/report.html`). It leads with what changed, before and after, what to expect downstream in plain words, and who consumes it: the dbt exposures on the model or downstream, grouped by whether they read a model the value reaches, and a plain statement when the project declares none. Only declared exposures appear: other BI tools and backend services do not. Under that are two levels upstream and downstream (more on request), and a click on any column lights up its path. Nothing is written until you ask. What it reads was kept when the task ended (`task-manifest.json`, `last-task.json`), so asking later, after other turns or a restart, still describes that task, and it says if a file has changed since. A later task that changes a model replaces it. The band's button goes when the next turn starts; `/lineage-report` keeps working.
 - **Warehouse lineage.** When a connected MCP server offers Altimate's `table_lineage` (Snowflake) or `databricks_table_lineage`, the pane adds what the warehouse's query history shows for the model's table. The plugin calls a tool of that name on whichever connected server offers it, itself and without a permission prompt, and sends it the model's `database.schema.table`. It does so only when you ask for the model (`/lineage`, a press in the pane, or `r`), never when the pane follows one of Claude's reads.
 - **Claude's own lineage calls.** A `dbt_lineage` result is drawn as a list of edges colored by how each column is derived; ctrl+o keeps the original output under it.
 
diff --git a/plugins/altimate-code/hooks/impact-report.test.ts b/plugins/altimate-code/hooks/impact-report.test.ts
index 3b5b1c7..ad41e33 100644
--- a/plugins/altimate-code/hooks/impact-report.test.ts
+++ b/plugins/altimate-code/hooks/impact-report.test.ts
@@ -5,8 +5,12 @@ import {
   changedColumns,
   type ColumnAnswer,
   type ColumnTrace,
+  consumersOf,
   DEFAULT_LEVELS,
+  fingerprint,
   focusOf,
+  impactWords,
+  mergeConsumers,
   type ModelChange,
   openersFor,
   reachOf,
@@ -85,6 +89,9 @@ export const CHANGE: ModelChange = {
   columns: [{ name: 'revenue', before: 'sum(amount) as revenue', after: 'sum(amount) - sum(refunds) as revenue' }],
 }
 const TRACE: ColumnTrace = { model: 'fct_orders', column: 'revenue', down: DOWN, up: UP, modelLevel: 6, failed: false }
+const TASK = { finishedAt: '2026-01-01 00:00 UTC', builtAt: '2026-01-01 00:05 UTC', manifest: 'the manifest as it was when the task started', movedOn: [] as string[] }
+/** Words as the page reads them, with names in backticks. */
+const plain = (lines: (string | { code: string })[][]) => lines.map(line => line.map(one => (typeof one === 'string' ? one : `\`${one.code}\``)).join(''))
 
 /** The data a report embeds, read back out of its page. */
 export function embedded(html: string): any {
@@ -127,22 +134,16 @@ describe('the answer', () => {
 })
 
 describe('the summary', () => {
-  test('names each changed column with its how and its reach, and says the reach is a lower bound', () => {
-    const lines = summaryLines(summaryOf([CHANGE], [TRACE], '/repo/target/.altimate-lineage/report.html'))
+  test('names each changed column with its reach, and says the reach is a lower bound', () => {
+    const lines = summaryLines(summaryOf([CHANGE], [{ ...TRACE, up: null }], null))
     expect(lines).toEqual([
       '◆ Lineage after this task · 1 model changed',
       'fct_orders · 6 downstream models at model level',
-      '  revenue Σ  reaches 4 columns in 3 models (2 ends) · 1 may carry it · 2 cleared',
+      '  revenue  reaches 4 columns in 3 models (2 ends) · 1 may carry it · 2 cleared',
       '⚠ Lower bound: 1 model could not be read',
     ])
   })
 
-  test('a how inferred from matching names says so', () => {
-    const up = { ...UP, edges: [[1, 0, '=', 'name']] as ColumnAnswer['edges'] }
-    const lines = summaryLines(summaryOf([CHANGE], [{ ...TRACE, up }], null))
-    expect(lines[2]).toBe('  revenue = (by name)  reaches 4 columns in 3 models (2 ends) · 1 may carry it · 2 cleared')
-  })
-
   test('a model with no changed output column shows its model-level count alone', () => {
     const change = { ...CHANGE, columns: [] }
     const lines = summaryLines(summaryOf([change], [{ model: 'fct_orders', column: null, down: null, up: null, modelLevel: 6, failed: false }], null))
@@ -150,7 +151,105 @@ describe('the summary', () => {
   })
 })
 
+describe('what to expect downstream, in plain words', () => {
+  test('says what the value reaches, what may change, what should not, what to watch and how sure it is', () => {
+    expect(plain(impactWords('fct_orders', 'revenue', TRACE))).toEqual([
+      '`fct_orders` has 6 models downstream. The value of `revenue` flows into 3 of them, in 4 columns. Expect those to change with it: `fct_revenue_daily`, `rpt_finance` and `rpt_board`.',
+      "1 more may change: it uses the value in a way the trace can't follow (a filter or a join, say), its SQL couldn't be read, or it reads from a model like that.",
+      "2 shouldn't change: they're downstream of the model, but the value doesn't reach them.",
+      'One model it reaches enforces a contract, so a type change can fail the build there: `fct_revenue_daily`.',
+      'Tests on the models it reaches: 2.',
+      "1 model couldn't be read, so the real numbers can only be higher.",
+    ])
+  })
+
+  test('caps the names, says when the changed model has a contract, and when everything was read', () => {
+    const nodes = Array.from({ length: 7 }, (_, i) => ({ id: `model.s.m${i}`, name: `m${i}`, contract: i === 0, tests: 0 }))
+    const down: ColumnAnswer = {
+      ...DOWN,
+      nodes,
+      columns: [{ model: 0, column: 'x', hop: 0 }, ...nodes.slice(1).map((_, i) => ({ model: i + 1, column: 'x', hop: 1 }))],
+      counts: { columns: 6, models: 6, ends: 6, may_carry_models: 0, cleared_models: 0, model_level: 6 },
+      also_reads: [],
+      unresolved: [],
+    }
+    expect(plain(impactWords('m0', 'x', { ...TRACE, model: 'm0', column: 'x', down, modelLevel: 6 }))).toEqual([
+      '`m0` has 6 models downstream. The value of `x` flows into 6 of them, in 6 columns. Expect those to change with it: `m1`, `m2`, `m3`, `m4`, `m5` and 1 more.',
+      '`m0` enforces a contract, so a type change can fail its build.',
+      'Every downstream model was read.',
+    ])
+  })
+
+  test('a model with no changed column has its count alone; a failed trace says so; nothing downstream says so', () => {
+    expect(plain(impactWords('m', null, { model: 'm', column: null, down: null, up: null, modelLevel: 6, failed: false }))).toEqual([
+      "`m` has 6 models downstream. No output column changed (a filter or a join, say), so this can't say which of them are affected.",
+    ])
+    expect(plain(impactWords('m', 'c', { model: 'm', column: 'c', down: null, up: null, modelLevel: 6, failed: true }))).toEqual(['`m` has 6 models downstream. The column `c` could not be traced.'])
+    expect(plain(impactWords('m', null, { model: 'm', column: null, down: null, up: null, modelLevel: 0, failed: false }))).toEqual(['Nothing sits downstream of `m`. '])
+  })
+})
+
+describe('consumers', () => {
+  const answerWith = (consumers: unknown) => ({ column_answer: { ...DOWN, consumers }, exposures_declared: 9 })
+  const exposure = (name: string, tier: string, via: string[], more = {}) => ({ unique_id: `exposure.s.${name}`, name, label: name, type: 'dashboard', tier, via, ...more })
+
+  test('a column answer gives the tiers; a model-only result gives the list, untiered, and the declared count', () => {
+    const tiered = consumersOf(answerWith({ declared: 2, exposures: [exposure('board', 'carries', ['rpt_board'], { url: 'https://bi.example.com/1', owner: 'Data' })] }))
+    expect(tiered).toEqual({
+      declared: 2,
+      error: null,
+      list: [{ id: 'exposure.s.board', label: 'board', type: 'dashboard', url: 'https://bi.example.com/1', owner: 'Data', tier: 'carries', via: ['rpt_board'], columns: [] }],
+    })
+    const modelOnly = consumersOf({ exposures_declared: 1, exposures: [{ unique_id: 'exposure.s.a', name: 'a', label: 'A', type: 'notebook' }] })
+    expect(modelOnly.declared).toBe(1)
+    expect(modelOnly.list[0]).toMatchObject({ label: 'A', tier: null, via: [] })
+  })
+
+  test('none declared and exposures that could not be read stay apart, and an older answer is unknown', () => {
+    expect(consumersOf({ exposures_declared: 0, exposures: [] })).toEqual({ declared: 0, error: null, list: [] })
+    expect(consumersOf({ exposures: [], exposures_error: 'bad manifest' })).toEqual({ declared: null, error: 'bad manifest', list: [] })
+    expect(consumersOf(null)).toEqual({ declared: null, error: null, list: [] })
+  })
+
+  test('only a web address becomes a link', () => {
+    const list = consumersOf({ exposures: [{ name: 'x', url: 'javascript:alert(1)' }, { name: 'y', url: 'HTTP://bi.example.com' }] }).list
+    expect(list.map(one => one.url)).toEqual([null, 'HTTP://bi.example.com'])
+  })
+
+  test('across columns an exposure is listed once, in its closest tier, naming the columns', () => {
+    const trace = (column: string, tier: string, name = 'board') => ({
+      ...TRACE,
+      column,
+      consumers: consumersOf(answerWith({ declared: 3, exposures: [exposure(name, tier, ['m'])] })),
+    })
+    const merged = mergeConsumers([trace('a', 'may_carry'), trace('b', 'carries'), trace('c', 'cleared'), trace('d', 'cleared', 'other')])
+    expect(merged.declared).toBe(3)
+    expect(merged.list.map(one => [one.label, one.tier, one.columns])).toEqual([
+      ['board', 'carries', ['fct_orders.a', 'fct_orders.b', 'fct_orders.c']],
+      ['other', 'cleared', ['fct_orders.d']],
+    ])
+  })
+
+  test('the report carries them and says what it leaves out', () => {
+    const none = reportHtml(reportData([CHANGE], [{ ...TRACE, consumers: consumersOf({ exposures_declared: 0, exposures: [] }) }], TASK))
+    expect(embedded(none).consumers).toEqual({ declared: 0, error: null, list: [] })
+    expect(none).toContain('This dbt project declares no exposures')
+    expect(none).toContain('Anything not declared, such as other BI tools or backend services, is not listed.')
+  })
+})
+
 describe('the report', () => {
+  test('leads with what changed and what to expect, and keeps the levels and paths underneath', () => {
+    const html = reportHtml(reportData([{ ...CHANGE, ended: fingerprint('x') }], [TRACE], { ...TASK, movedOn: ['models/fct_orders.sql'] }))
+    const order = ['What this task changed', 'wrap.appendChild(impactPanel())', 'wrap.appendChild(consumersPanel())', 'Column by column', "section(f,i,'up')", "section(f,i,'down')"].map(one => html.indexOf(one, html.indexOf('function render(){')))
+    expect(order.every(one => one >= 0)).toBe(true)
+    expect([...order].sort((a, b) => a - b)).toEqual(order)
+    const data = embedded(html)
+    expect(data).toMatchObject({ finishedAt: TASK.finishedAt, builtAt: TASK.builtAt, movedOn: ['models/fct_orders.sql'] })
+    expect(data.focuses[0].impact.length).toBeGreaterThan(2)
+    expect(html).toContain('This report describes the task, not the files as they are now.')
+  })
+
   test('groups downstream by hop then model, with the how per column, ends and contracts', () => {
     const down = sectionOf(DOWN)
     expect(down.hops.map(one => one.hop)).toEqual([1, 2, 3])
@@ -169,7 +268,7 @@ describe('the report', () => {
   })
 
   test('embeds both directions with edges keyed by model and column, folds, and two levels by default', () => {
-    const html = reportHtml(reportData([CHANGE], [TRACE], '2026-01-01 00:00 UTC', 'the manifest as it was when the task started'))
+    const html = reportHtml(reportData([CHANGE], [TRACE], TASK))
     expect(html).toContain('data-levels="2"')
     const data = embedded(html)
     expect(data.defaultLevels).toBe(DEFAULT_LEVELS)
@@ -191,7 +290,7 @@ describe('the report', () => {
 
   test('is one offline file: no external resource, and project text cannot close its script', () => {
     const hostile = { ...CHANGE, model: 'x</script><script>alert(1)</script>' }
-    const html = reportHtml(reportData([hostile], [{ ...TRACE, model: hostile.model }], 'now', 'm'))
+    const html = reportHtml(reportData([hostile], [{ ...TRACE, model: hostile.model }], TASK))
     expect(html).not.toMatch(/(src|href)="(https?:)?\/\//)
     expect(html).not.toContain('<script>alert(1)')
     expect(html.match(/<\/script>/g)!.length).toBe(2)
diff --git a/plugins/altimate-code/hooks/impact-report.ts b/plugins/altimate-code/hooks/impact-report.ts
index 3a751cc..2b16189 100644
--- a/plugins/altimate-code/hooks/impact-report.ts
+++ b/plugins/altimate-code/hooks/impact-report.ts
@@ -21,17 +21,38 @@ export type ColumnAnswer = {
   unresolved?: { model: number; reason?: string; downstream?: number }[]
   /** Models at the model level that do not carry the value: off the path, so not in `nodes`. */
   cleared?: { id?: string; name?: string }[]
+  /** Exposures on the model or downstream, by what they read; `declared` counts the whole project's. */
+  consumers?: { declared?: number; exposures?: RawExposure[] }
   flags?: { model: number; flag: string }[]
   truncated?: boolean
   next?: unknown
 }
 
+type RawExposure = { unique_id?: string; name?: string; label?: string; type?: string; url?: string; owner?: string; tier?: string; via?: string[] }
+
 /** A model file the task changed, with the columns it changed (at most three). */
 export type ModelChange = {
   model: string
   file: string
   root: string
   columns: { name: string; before: string | null; after: string | null }[]
+  /** The file's fingerprint as the task ended, to tell whether it changed since. */
+  ended?: string
+}
+
+export type ConsumerTier = 'carries' | 'may_carry' | 'cleared'
+/** An exposure: `tier` says how the models it reads relate to the value; null when only a model was traced. */
+export type Consumer = { id: string; label: string; type: string; url: string | null; owner: string | null; tier: ConsumerTier | null; via: string[]; columns: string[] }
+/** `declared` is what the whole project declares; null when the answer did not say. */
+export type ReportConsumers = { declared: number | null; error: string | null; list: Consumer[] }
+/** Running text, with names set apart. */
+export type Words = (string | { code: string })[]
+
+/** A cheap fingerprint of a file's text. */
+export function fingerprint(text: string): string {
+  let hash = 0x811c9dc5
+  for (let i = 0; i < text.length; i++) hash = Math.imul(hash ^ text.charCodeAt(i), 0x01000193)
+  return `${(hash >>> 0).toString(16)}:${text.length}`
 }
 
 export const MAX_TASK_COLUMNS = 3
@@ -140,8 +161,62 @@ export function carriersOf(answer: ColumnAnswer): { name: string; columns: strin
   return [...byModel.values()].sort((a, b) => a.hop - b.hop || a.name.localeCompare(b.name)).map(({ hop: _hop, ...rest }) => rest)
 }
 
-/** The traced answers for one changed column: downstream and upstream, each null when it failed. */
-export type ColumnTrace = { model: string; column: string | null; down: ColumnAnswer | null; up: ColumnAnswer | null; modelLevel: number | null; failed: boolean }
+/** What one impact_analysis result says about exposures, tiered when it carries a column answer. */
+export function consumersOf(metadata: unknown): ReportConsumers {
+  const m = metadata as any
+  const answer = answerOf(m)
+  const tiered = answer?.consumers?.exposures
+  const raw: RawExposure[] = Array.isArray(tiered) ? tiered : Array.isArray(m?.exposures) ? m.exposures : []
+  return {
+    declared: num(answer?.consumers?.declared) ?? num(m?.exposures_declared),
+    error: typeof m?.exposures_error === 'string' ? m.exposures_error : null,
+    list: raw.map(one => ({
+      id: String(one.unique_id ?? one.name ?? one.label ?? '?'),
+      label: String(one.label ?? one.name ?? one.unique_id ?? '?'),
+      type: String(one.type ?? 'exposure'),
+      url: typeof one.url === 'string' && /^https?:\/\//i.test(one.url) ? one.url : null,
+      owner: typeof one.owner === 'string' ? one.owner : null,
+      tier: one.tier === 'carries' || one.tier === 'may_carry' || one.tier === 'cleared' ? one.tier : null,
+      via: Array.isArray(one.via) ? one.via.map(String) : [],
+      columns: [],
+    })),
+  }
+}
+
+const TIER_ORDER: (ConsumerTier | null)[] = ['carries', 'may_carry', 'cleared', null]
+
+/** One list across every traced column: an exposure once, in its closest tier, naming the columns behind it. */
+export function mergeConsumers(traces: ColumnTrace[]): ReportConsumers {
+  const merged = new Map<string, Consumer>()
+  for (const trace of traces) {
+    for (const one of trace.consumers?.list ?? []) {
+      const known = merged.get(one.id)
+      const column = trace.column ? `${trace.model}.${trace.column}` : null
+      if (!known || TIER_ORDER.indexOf(one.tier) < TIER_ORDER.indexOf(known.tier)) {
+        merged.set(one.id, { ...one, columns: [...new Set([...(known?.columns ?? []), ...(column ? [column] : [])])] })
+      } else if (column && !known.columns.includes(column)) {
+        known.columns.push(column)
+      }
+    }
+  }
+  const declared = traces.map(one => one.consumers?.declared ?? null).filter((one): one is number => one !== null)
+  return {
+    declared: declared.length ? Math.max(...declared) : null,
+    error: traces.map(one => one.consumers?.error ?? null).find(Boolean) ?? null,
+    list: [...merged.values()].sort((a, b) => TIER_ORDER.indexOf(a.tier) - TIER_ORDER.indexOf(b.tier) || a.label.localeCompare(b.label)),
+  }
+}
+
+/** The traced answers for one changed column: downstream and upstream, each null when not asked or failed. */
+export type ColumnTrace = {
+  model: string
+  column: string | null
+  down: ColumnAnswer | null
+  up: ColumnAnswer | null
+  modelLevel: number | null
+  failed: boolean
+  consumers?: ReportConsumers
+}
 
 /** The band's view of a finished task. */
 export function summaryOf(changes: ModelChange[], traces: ColumnTrace[], report: string | null): TaskSummaryView {
@@ -156,8 +231,7 @@ export function summaryOf(changes: ModelChange[], traces: ColumnTrace[], report:
         const reach = one.down ? reachOf(one.down) : null
         for (const entry of one.down?.unresolved ?? []) unresolved.add(one.down!.nodes[entry.model]?.id ?? one.down!.nodes[entry.model]?.name ?? String(entry.model))
         if (reach?.truncated) truncated = true
-        const how = focusHow(one.up)
-        return { name: one.column!, how: how?.glyph ?? null, byName: how?.byName ?? false, reach, failed: one.failed }
+        return { name: one.column!, reach, failed: one.failed }
       })
     return { name: change.model, modelLevel, columns }
   })
@@ -172,15 +246,14 @@ export function summaryLines(view: TaskSummaryView): string[] {
     lines.push(`${model.name}${model.modelLevel !== null ? ` · ${plural(model.modelLevel, 'downstream model')} at model level` : ''}`)
     if (model.columns.length === 0) lines.push('  no output column changed: the model-level count stands')
     for (const col of model.columns) {
-      const glyph = col.how ? `${col.how}${col.byName ? ' (by name)' : ''}` : '·'
-      if (view.state === 'tracing' && !col.reach) lines.push(`  ${col.name} ${glyph}  tracing…`)
-      else if (!col.reach) lines.push(`  ${col.name} ${glyph}  ${col.failed ? 'could not be traced' : 'no column answer'}`)
+      if (view.state === 'tracing' && !col.reach) lines.push(`  ${col.name}  tracing…`)
+      else if (!col.reach) lines.push(`  ${col.name}  ${col.failed ? 'could not be traced' : 'no column answer'}`)
       else {
         const r = col.reach
         const parts = [`reaches ${plural(r.columns, 'column')} in ${plural(r.models, 'model')} (${plural(r.ends, 'end')})`]
         parts.push(`${r.mayCarry} may carry it`)
         if (r.cleared !== null) parts.push(`${r.cleared} cleared`)
-        lines.push(`  ${col.name} ${glyph}  ${parts.join(' · ')}`)
+        lines.push(`  ${col.name}  ${parts.join(' · ')}`)
       }
     }
   }
@@ -220,6 +293,8 @@ export type ReportFocus = {
   after: string | null
   reach: Reach | null
   modelLevel: number | null
+  /** What to expect downstream, in plain words. */
+  impact: Words[]
   up: ReportSection
   down: ReportSection
   edges: [string, string, string][]
@@ -230,12 +305,18 @@ export type ReportFocus = {
 }
 export type ReportData = {
   title: string
-  generatedAt: string
+  finishedAt: string
+  builtAt: string
   manifest: string
+  /** Files that changed after the task ended. */
+  movedOn: string[]
   defaultLevels: number
   changes: { model: string; file: string; columns: ModelChange['columns'] }[]
   focuses: ReportFocus[]
+  consumers: ReportConsumers
 }
+/** When the task ended and the report was built, what was read, and what changed since. */
+export type ReportTask = { finishedAt: string; builtAt: string; manifest: string; movedOn: string[] }
 
 const keyOf = (answer: ColumnAnswer, index: number) => {
   const col = answer.columns[index]!
@@ -277,6 +358,48 @@ export function sectionOf(answer: ColumnAnswer | null, failed = false): ReportSe
   return { hops, truncated: answer.truncated === true, error: null }
 }
 
+const count = (n: number, word: string, many = `${word}s`) => `${n} ${n === 1 ? word : many}`
+
+function namesList(names: string[], max = 5): Words {
+  const shown = names.slice(0, max)
+  const out: Words = []
+  shown.forEach((name, i) => {
+    if (i > 0) out.push(i === shown.length - 1 && names.length <= max ? ' and ' : ', ')
+    out.push({ code: name })
+  })
+  if (names.length > max) out.push(` and ${names.length - max} more`)
+  return out
+}
+
+/** What to expect downstream of one changed column (or model), in plain words. */
+export function impactWords(model: string, column: string | null, trace: ColumnTrace | undefined): Words[] {
+  const down = trace?.down ?? null
+  const level = trace?.modelLevel ?? (down ? reachOf(down).modelLevel : null)
+  const downstream: Words = level === null ? [] : level === 0 ? ['Nothing sits downstream of ', { code: model }, '. '] : [{ code: model }, ` has ${count(level, 'model')} downstream. `]
+  if (!column) {
+    if (level === null) return [['The downstream count could not be read for ', { code: model }, '.']]
+    return [[...downstream, ...(level > 0 ? ["No output column changed (a filter or a join, say), so this can't say which of them are affected."] : [])]]
+  }
+  if (!down) return [[...downstream, 'The column ', { code: column }, ' could not be traced.']]
+  const r = reachOf(down)
+  const lines: Words[] = []
+  const value = [...new Set(down.columns.filter(one => one.hop > 0).map(one => one.model))].map(index => down.nodes[index]).filter(Boolean)
+  if (r.models > 0) lines.push([...downstream, 'The value of ', { code: column }, ` flows into ${r.models} of them, in ${count(r.columns, 'column')}. Expect those to change with it: `, ...namesList(carriersOf(down).map(one => one.name)), '.'])
+  else if (level !== 0) lines.push([...downstream, 'The value of ', { code: column }, " doesn't flow into any column of theirs."])
+  else lines.push(downstream)
+  if (r.mayCarry > 0) lines.push([`${r.mayCarry} more may change: ${r.mayCarry === 1 ? 'it uses' : 'they use'} the value in a way the trace can't follow (a filter or a join, say), ${r.mayCarry === 1 ? 'its' : 'their'} SQL couldn't be read, or ${r.mayCarry === 1 ? 'it reads' : 'they read'} from a model like that.`])
+  if (r.cleared) lines.push([`${r.cleared} shouldn't change: ${r.cleared === 1 ? "it's" : "they're"} downstream of the model, but the value doesn't reach ${r.cleared === 1 ? 'it' : 'them'}.`])
+  const self = down.nodes[down.columns.find(one => one.hop === 0)?.model ?? -1]
+  if (self?.contract) lines.push([{ code: model }, ' enforces a contract, so a type change can fail its build.'])
+  const contracts = value.filter(one => one!.contract).map(one => String(one!.name ?? one!.id))
+  if (contracts.length > 0) lines.push([`${contracts.length === 1 ? 'One model it reaches enforces' : `${contracts.length} models it reaches enforce`} a contract, so a type change can fail the build there: `, ...namesList(contracts), '.'])
+  const tests = value.reduce((sum, one) => sum + (num(one!.tests) ?? 0), 0)
+  if (tests > 0) lines.push([`Tests on the models it reaches: ${tests}.`])
+  const short = [r.unresolved ? `${count(r.unresolved, "model")} couldn't be read` : '', r.truncated ? 'the trace hit its limit' : ''].filter(Boolean).join(' and ')
+  lines.push([short ? `${short.charAt(0).toUpperCase()}${short.slice(1)}, so the real numbers can only be higher.` : 'Every downstream model was read.'])
+  return lines
+}
+
 /** The page's data for one changed column (or one model, when no column changed). */
 export function focusOf(change: ModelChange, column: ModelChange['columns'][number] | null, trace: ColumnTrace | undefined): ReportFocus {
   const down = trace?.down ?? null
@@ -305,8 +428,9 @@ export function focusOf(change: ModelChange, column: ModelChange['columns'][numb
     after: column?.after ?? null,
     reach,
     modelLevel: trace?.modelLevel ?? reach?.modelLevel ?? null,
-    up: sectionOf(up, !!trace?.failed && !up && !!column),
-    down: sectionOf(down, !!trace?.failed && !down && !!column),
+    impact: impactWords(change.model, column?.name ?? null, trace),
+    up: sectionOf(up, !up && !!column),
+    down: sectionOf(down, !down && !!column),
     edges,
     alsoReads: (down?.also_reads ?? []).map(one => ({ name: nameOf(down!, one.model), columns: (one.columns ?? []).map(String), downstream: num(one.downstream) })),
     unresolved: (down?.unresolved ?? []).map(one => ({ name: nameOf(down!, one.model), reason: String(one.reason ?? 'not read'), downstream: num(one.downstream) })),
@@ -321,7 +445,7 @@ export function focusOf(change: ModelChange, column: ModelChange['columns'][numb
 }
 
 /** Everything the report draws, from the task's changes and their traces. */
-export function reportData(changes: ModelChange[], traces: ColumnTrace[], generatedAt: string, manifest: string): ReportData {
+export function reportData(changes: ModelChange[], traces: ColumnTrace[], task: ReportTask): ReportData {
   const focuses: ReportFocus[] = []
   for (const change of changes) {
     if (change.columns.length === 0) focuses.push(focusOf(change, null, traces.find(one => one.model === change.model && one.column === null)))
@@ -330,11 +454,11 @@ export function reportData(changes: ModelChange[], traces: ColumnTrace[], genera
   const names = changes.map(one => one.model)
   return {
     title: `Column impact · ${names.slice(0, 2).join(', ')}${names.length > 2 ? ` +${names.length - 2}` : ''}`,
-    generatedAt,
-    manifest,
+    ...task,
     defaultLevels: DEFAULT_LEVELS,
     changes: changes.map(one => ({ model: one.model, file: one.file, columns: one.columns })),
     focuses,
+    consumers: mergeConsumers(traces),
   }
 }
 
@@ -389,8 +513,8 @@ header.top{display:flex;flex-wrap:wrap;align-items:baseline;gap:6px 14px;margin-
 header.top h1{font-size:20px;margin:0;font-weight:650;letter-spacing:-.01em}
 header.top .when{color:var(--muted);font-size:12.5px}
 .panel{background:var(--panel);border:1px solid var(--line);border-radius:10px;box-shadow:var(--shadow)}
-.changes{padding:14px 16px;margin-bottom:14px}
-.changes h2,.section h2{font-size:12px;text-transform:uppercase;letter-spacing:.06em;color:var(--muted);margin:0 0 8px;font-weight:600}
+.changes,.impact,.consumers{padding:14px 16px;margin-bottom:14px}
+.changes h2,.impact h2,.consumers h2,.section h2{font-size:12px;text-transform:uppercase;letter-spacing:.06em;color:var(--muted);margin:0 0 8px;font-weight:600}
 .change-model{margin:8px 0 2px;font-weight:600;overflow-wrap:anywhere}
 .change-model .file{color:var(--faint);font-weight:400;margin-left:6px;font-size:12px}
 .diff{display:grid;grid-template-columns:auto 1fr;gap:3px 10px;margin:6px 0 10px;align-items:start}
@@ -400,6 +524,19 @@ header.top .when{color:var(--muted);font-size:12.5px}
 .diff .now{background:var(--add-bg);color:var(--add)}
 .diff .none{opacity:.7;font-style:italic}
 .diff .same{grid-column:2;color:var(--muted);font-size:12.5px}
+.impact h3{font-size:13px;font-weight:600;margin:10px 0 4px;overflow-wrap:anywhere}
+.impact ul{margin:0;padding-left:18px}
+.impact li{margin:5px 0}
+.impact code,.consumers code{overflow-wrap:anywhere}
+.consumers .tier{font-size:12.5px;font-weight:600;margin:10px 0 2px}
+.consumers ul{margin:0 0 4px;padding-left:18px}
+.consumers li{margin:3px 0;overflow-wrap:anywhere}
+.consumers .why{color:var(--muted)}
+.consumers .foot{color:var(--muted);font-size:12.5px;margin:10px 0 0}
+.consumers a{color:var(--accent)}
+.deep{margin:26px 0 12px;padding-top:16px;border-top:1px solid var(--line-strong)}
+.deep h2{font-size:15px;font-weight:650;margin:0 0 2px}
+.deep p{margin:0;color:var(--muted);font-size:13px}
 .tabs{display:flex;flex-wrap:wrap;gap:6px;margin:0 0 12px}
 .tab{appearance:none;border:1px solid var(--line-strong);background:var(--panel);color:var(--ink);border-radius:999px;padding:5px 12px;font:inherit;cursor:pointer}
 .tab[aria-selected=true]{background:var(--accent);border-color:var(--accent);color:#fff}
@@ -495,11 +632,25 @@ function section(f,i,dir){var sec=f[dir],lv=state.levels[i][dir],s=el('section',
 function stat(n,label,dim){var d=el('div','stat'+(dim?' dim':''));d.appendChild(el('b',null,n==null?'\\u2013':n));d.appendChild(el('span',null,label));return d}
 function fold(title,count,items){var d=el('details','panel fold');var s=el('summary',null,title+' ');s.appendChild(el('span',null,'('+(count==null?'not reported':count)+')'));d.appendChild(s);var ul=el('ul');items.forEach(function(it){ul.appendChild(it)});if(!items.length)ul.appendChild(el('li','why',count==null?'Not reported by this altimate-code build.':count?'Only the count is known.':'None.'));d.appendChild(ul);return d}
 function li(name,rest){var l=el('li');l.appendChild(el('span','mono',name));if(rest){l.appendChild(document.createTextNode(' '));l.appendChild(el('span','why',rest))}return l}
+function words(parent,line){line.forEach(function(w){if(typeof w==='string')parent.appendChild(document.createTextNode(w));else parent.appendChild(el('code',null,w.code))});return parent}
+function impactPanel(){var p=el('div','panel impact');p.appendChild(el('h2',null,'What to expect downstream'));DATA.focuses.forEach(function(g){if(DATA.focuses.length>1)p.appendChild(el('h3','mono',g.column?g.model+'.'+g.column:g.model));var ul=el('ul');g.impact.forEach(function(line){ul.appendChild(words(el('li'),line))});p.appendChild(ul)});return p}
+function consumerItem(c){var l=el('li');if(c.url){var a=el('a',null,c.label);a.href=c.url;a.rel='noopener noreferrer';a.target='_blank';l.appendChild(a)}else l.appendChild(document.createTextNode(c.label));var bits=[c.type];if(c.via.length)bits.push('reads '+c.via.join(', '));if(c.owner)bits.push('owner: '+c.owner);if(DATA.focuses.length>1&&c.columns.length)bits.push('for '+c.columns.join(', '));l.appendChild(el('span','why',' \\u00b7 '+bits.join(' \\u00b7 ')));return l}
+var TIERS=[['carries','Read a model the value reaches'],['may_carry','Read a model that may carry it'],['cleared',"Read only models the value doesn't reach"],[null,'Read this model or one downstream of it']];
+function consumersPanel(){var c=DATA.consumers,p=el('div','panel consumers');p.appendChild(el('h2',null,'Who consumes it'));
+  if(c.error)p.appendChild(el('div','empty','The project\\u2019s exposures could not be read: '+c.error));
+  else if(c.declared===null)p.appendChild(el('div','empty','This version of altimate-code does not report exposures, so consumers are unknown.'));
+  else if(c.declared===0)p.appendChild(el('div','empty','This dbt project declares no exposures, so no dashboards or other consumers can be named. That does not mean nothing reads these tables.'));
+  else if(!c.list.length)p.appendChild(el('div','empty','This dbt project declares '+plural(c.declared,'exposure')+', but none reads this model or anything downstream of it.'));
+  TIERS.forEach(function(t){var mine=c.list.filter(function(x){return x.tier===t[0]});if(!mine.length)return;p.appendChild(el('div','tier',t[1]+' ('+mine.length+')'));var ul=el('ul');mine.forEach(function(x){ul.appendChild(consumerItem(x))});p.appendChild(ul)});
+  p.appendChild(el('p','foot','From the exposures this dbt project declares'+(c.list.length?'. dbt records which models an exposure reads, not which columns, so each may or may not use this one':'')+'. Anything not declared, such as other BI tools or backend services, is not listed.'));return p}
 function render(){
   var f=DATA.focuses[state.focus],i=state.focus;app.textContent='';
   var bar=el('div','pathbar');bar.id='pathbar';var wrap=el('div','wrap');wrap.appendChild(bar);
-  var top=el('header','top');top.appendChild(el('h1',null,DATA.title));top.appendChild(el('span','when','Generated '+DATA.generatedAt+' \\u00b7 downstream read from '+DATA.manifest));wrap.appendChild(top);
+  var top=el('header','top');top.appendChild(el('h1',null,DATA.title));top.appendChild(el('span','when','Task finished '+DATA.finishedAt+' \\u00b7 report built '+DATA.builtAt+' \\u00b7 read from '+DATA.manifest));wrap.appendChild(top);
+  if(DATA.movedOn.length)wrap.appendChild(el('div','note warn','\\u26a0 Since this task ended, '+DATA.movedOn.join(', ')+(DATA.movedOn.length===1?' has':' have')+' changed. This report describes the task, not the files as they are now.'));
   var ch=el('div','panel changes');ch.appendChild(el('h2',null,'What this task changed'));DATA.changes.forEach(function(c){var m=el('div','change-model mono',c.model);m.appendChild(el('span','file',c.file));ch.appendChild(m);if(!c.columns.length){ch.appendChild(el('div','empty','No output column changed (a filter or a join): only the model-level count applies.'));return}var d=el('div','diff');c.columns.forEach(function(col){d.appendChild(el('div','col-name mono',col.name));var was=el('div','was mono'+(col.before?'':' none'),col.before||'(not in the model before)');var now=el('div','now mono'+(col.after?'':' none'),col.after||'(removed)');if(col.before&&col.after&&col.before===col.after){d.appendChild(el('div','same','Expression unchanged; the column is named on a changed line.'));d.appendChild(el('div'))}else{d.appendChild(was);d.appendChild(now)}});ch.appendChild(d)});wrap.appendChild(ch);
+  wrap.appendChild(impactPanel());wrap.appendChild(consumersPanel());
+  var deep=el('div','deep');deep.appendChild(el('h2',null,'Column by column'));deep.appendChild(el('p',null,'Two levels up and down, with more on request. Click any column to light up its path; nothing is hidden.'));wrap.appendChild(deep);
   if(DATA.focuses.length>1){var tabs=el('div','tabs');tabs.setAttribute('role','tablist');DATA.focuses.forEach(function(g,j){var t=el('button','tab',g.column?g.model+'.'+g.column:g.model+' (model)');t.type='button';t.setAttribute('role','tab');t.setAttribute('aria-selected',j===i?'true':'false');t.addEventListener('click',function(){state.focus=j;state.selected=null;render()});tabs.appendChild(t)});wrap.appendChild(tabs)}
   var r=f.reach,stats=el('div','stats');
   if(r){stats.appendChild(stat(r.columns,'columns downstream'));stats.appendChild(stat(r.models,'models carry it'));stats.appendChild(stat(r.ends,'end columns'));stats.appendChild(stat(r.mayCarry,'may carry it',!r.mayCarry));stats.appendChild(stat(r.cleared,'cleared',r.cleared==null))}
diff --git a/plugins/altimate-code/hooks/task-impact.test.tsx b/plugins/altimate-code/hooks/task-impact.test.tsx
index d252664..ca1378d 100644
--- a/plugins/altimate-code/hooks/task-impact.test.tsx
+++ b/plugins/altimate-code/hooks/task-impact.test.tsx
@@ -5,6 +5,8 @@ import { DOWN, UP, embedded } from './impact-report.test'
 const ROOT = '/repo'
 const MANIFEST = `${ROOT}/target/manifest.json`
 const SNAPSHOT = `${ROOT}/target/.altimate-lineage/manifest-before.json`
+const FROZEN = `${ROOT}/target/.altimate-lineage/task-manifest.json`
+const TASK_FILE = `${ROOT}/target/.altimate-lineage/last-task.json`
 const REPORT = `${ROOT}/target/.altimate-lineage/report.html`
 const MODEL = `${ROOT}/models/fct_orders.sql`
 const STAGING = `${ROOT}/models/stg_payments.sql`
@@ -32,6 +34,12 @@ type Options = {
   noManifest?: boolean
   /** Other paths that exist, such as Windows' explorer.exe under /mnt/c. */
   present?: string[]
+  /** target/manifest.json has gone since the start. */
+  manifestGone?: () => boolean
+  /** The CLI answers with an error. */
+  cliFails?: boolean
+  /** What impact_analysis adds to its answer. */
+  impact?: (args: Record<string, any>) => Record<string, unknown>
 }
 
 /**
@@ -51,13 +59,21 @@ async function start($: any, on: any, options: Options = {}) {
   const tools: Record<string, any>[] = []
   const writes = new Map<string, string>()
   const logs: string[] = []
+  const toasts: string[] = []
+  const copies = new Set<string>()
+  const dialogs: number[] = []
+  const mcpAsked: Record<string, any>[] = []
+  const toolsAtDialog = () => tools.length
   on('command.register', () => ({ value: { command: 'x' } }))
   on('turn.start', (_: unknown, e: { turnId: string }) => ({ turnId: e.turnId }))
   on('turn.complete', (_: unknown, e: { answer: string }) => ({ text: e.answer }))
   on('session.start', (_: unknown, e: { cwd: string }) => ({ cwd: e.cwd }))
   on('session.root', () => ({ value: ROOT }))
   on('ui.open', () => ({ value: {} }))
-  on('ui.toast', () => ({ value: undefined }))
+  on('ui.toast', (_: unknown, e: { text: string }) => {
+    toasts.push(e.text)
+    return { value: undefined }
+  })
   on('ui.log', (_: unknown, e: { text: string }) => {
     logs.push(e.text)
     return { value: undefined }
@@ -67,16 +83,26 @@ async function start($: any, on: any, options: Options = {}) {
     return <Box key="engine" />
   })
   on('fs.exists', (_: unknown, e: { path: string }) => ({
-    value: e.path in files || (e.path === MANIFEST && !options.noManifest) || writes.has(e.path) || !!options.present?.includes(e.path),
+    value: e.path in files || (e.path === MANIFEST && !options.noManifest && !options.manifestGone?.()) || writes.has(e.path) || copies.has(e.path) || !!options.present?.includes(e.path),
   }))
   on('fs.stat', (_: unknown, e: { path: string }) => {
     if (e.path === MANIFEST && options.noManifest) throw new Error('ENOENT')
     return { value: { kind: 'file', size: 50 * 1024 * 1024, mtimeMs: 1, isLink: false } }
   })
-  on('fs.list', () => ({ value: [] }))
+  // What sits directly in a folder of the held files: a manifest over 4 MiB leaves the names to the SQL files.
+  on('fs.list', (_: unknown, e: { path: string }) => {
+    const names = new Map<string, 'file' | 'dir'>()
+    for (const path of Object.keys(files)) {
+      if (!path.startsWith(`${e.path}/`)) continue
+      const [head, ...rest] = path.slice(e.path.length + 1).split('/')
+      names.set(head!, rest.length ? 'dir' : 'file')
+    }
+    return { value: [...names].map(([name, kind]) => ({ name, kind, size: 1, mtimeMs: 1, isLink: false })) }
+  })
   on('fs.read', (_: unknown, e: { path: string }) => {
     if (e.path === MANIFEST) throw new Error('over 4 MiB')
     if (e.path in files) return { value: files[e.path] }
+    if (writes.has(e.path)) return { value: writes.get(e.path) }
     throw new Error(`ENOENT ${e.path}`)
   })
   on('fs.write', (_: unknown, e: { path: string; text: string }) => {
@@ -85,23 +111,45 @@ async function start($: any, on: any, options: Options = {}) {
   })
   on('tool.list', () => ({ value: [] }))
   on('mcp.connect', () => ({ value: { isConnected: true, server: 'plugin:altimate-code:altimate-code' } }))
-  on('mcp.call', (_: unknown, e: { tool: string; args: Record<string, any> }) => {
-    if (e.tool !== 'impact_analysis') return { value: { content: [], isError: true } }
-    tools.push(e.args)
-    // impactFirst's own call (no direction) gets the older column reach shape.
-    const body = !e.args.direction
+  // impact_analysis's answer, over MCP or the CLI: impactFirst's own call (no direction) gets the older column reach shape.
+  const impactBody = (args: Record<string, any>) => {
+    tools.push(args)
+    const body = !args.direction
       ? { severity: 'LOW', direct_count: 4, transitive_count: 2, column_reach: { models: [], exposures: [] } }
-      : !e.args.column
+      : !args.column
         ? { severity: 'LOW', direct_count: 4, transitive_count: 2 }
-        : { severity: 'LOW', direct_count: 4, transitive_count: 2, column_answer: e.args.direction === 'upstream' ? UP : DOWN }
-    return { value: { content: [{ type: 'text', text: JSON.stringify({ ...body, report: 'Impact' }) }], isError: false } }
+        : { severity: 'LOW', direct_count: 4, transitive_count: 2, column_answer: args.direction === 'upstream' ? UP : DOWN }
+    return { ...body, ...options.impact?.(args) }
+  }
+  on('mcp.call', (_: unknown, e: { tool: string; args: Record<string, any> }) => {
+    if (e.tool !== 'impact_analysis') return { value: { content: [], isError: true } }
+    if (e.args.direction) mcpAsked.push(e.args)
+    return { value: { content: [{ type: 'text', text: JSON.stringify({ ...impactBody(e.args), report: 'Impact' }) }], isError: false } }
   })
   on('process.run', (_: unknown, e: { argv: readonly string[] }) => {
     const argv = [...e.argv]
     runs.push(argv)
     const ok = (stdout = '') => ({ value: { exitCode: 0, stdout, stderr: '' } })
     const [bin] = argv
-    if (bin === 'mkdir' || bin === 'cp') return ok()
+    if (bin === 'altimate') {
+      const args = JSON.parse(String(argv[argv.indexOf('--args') + 1] ?? '{}'))
+      if (options.cliFails) return { value: { exitCode: 1, stdout: JSON.stringify({ status: 'error', output: 'no', metadata: {} }), stderr: '' } }
+      return ok(JSON.stringify({ status: 'ok', output: 'Impact', metadata: impactBody(args) }))
+    }
+    if (bin === 'mkdir') return ok()
+    if (bin === 'cp') {
+      copies.add(argv[2]!)
+      return ok()
+    }
+    if (bin === 'mv') {
+      copies.delete(argv[2]!)
+      copies.add(argv[3]!)
+      return ok()
+    }
+    if (bin === 'rm') {
+      writes.delete(argv[2]!)
+      return ok()
+    }
     if (bin === 'git') {
       const sub = argv[3]
       if (sub === 'rev-parse') return ok(`${ROOT}\n`)
@@ -123,6 +171,7 @@ async function start($: any, on: any, options: Options = {}) {
   })
   // The tool beneath the plugin: an Edit applies to the files.
   on('tool.call', (_: unknown, e: any) => {
+    if (e.tool === 'ExitPlanMode') dialogs.push(toolsAtDialog())
     if (e.tool === 'Edit' && e.file_path in files) files[e.file_path] = files[e.file_path]!.replace(e.old_string, e.new_string)
     if (e.tool === 'Write') files[e.file_path] = e.content
     return { result: { ok: true } }
@@ -137,7 +186,7 @@ async function start($: any, on: any, options: Options = {}) {
     await $.turn.complete({ answer: 'Done.', durationMs: 5, isAborted: false, reason: 'answer', turnId: id } as any)
     await clock.settle()
   }
-  return { clock, files, runs, tools, writes, logs, turn }
+  return { clock, files, runs, tools, writes, logs, toasts, copies, dialogs, mcpAsked, turn }
 }
 
 const directional = (tools: Record<string, any>[]) => tools.filter(one => one.direction)
@@ -150,38 +199,140 @@ test('a task start copies the manifest aside, never reading it', async ($, on) =
   expect(runs.findIndex(one => one[0] === 'mkdir')).toBeLessThan(runs.findIndex(one => one[0] === 'cp'))
 })
 
-test('an edited model is traced both ways from the snapshot at the task end, and the band sums it up', async ($, on) => {
-  const { tools, writes, turn, clock, logs } = await start($, on)
+test('an edited model is traced downstream at the task end for the band; the report waits until it is asked for', async ($, on) => {
+  const { tools, writes, turn, clock, logs, mcpAsked } = await start($, on)
   await turn('t1', async () => {
     await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) - sum(refunds) as revenue' })
     // A second edit of the same file: the original stays the one from before the first.
     await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'order_id,', new_string: 'order_id ,' })
   })
-  expect(directional(tools)).toEqual([
-    { manifest_path: SNAPSHOT, model: 'fct_orders', column: 'revenue', change_type: 'modify', direction: 'downstream' },
-    { manifest_path: SNAPSHOT, model: 'fct_orders', column: 'revenue', change_type: 'modify', direction: 'upstream' },
-  ])
+  expect(directional(tools)).toEqual([{ manifest_path: FROZEN, model: 'fct_orders', column: 'revenue', change_type: 'modify', direction: 'downstream' }])
+  expect(writes.has(REPORT)).toBe(false)
   // One log line: the transcript draws a newline in a log as a replacement glyph.
-  expect(logs).toContain('◆ Lineage after this task · 1 model changed · fct_orders · 6 downstream models at model level · revenue Σ  reaches 4 columns in 3 models (2 ends) · 1 may carry it · 2 cleared · ⚠ Lower bound: 1 model could not be read')
+  expect(logs).toContain('◆ Lineage after this task · 1 model changed · fct_orders · 6 downstream models at model level · revenue  reaches 4 columns in 3 models (2 ends) · 1 may carry it · 2 cleared · ⚠ Lower bound: 1 model could not be read')
 
   const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
   expect(await band.find({ type: 'Text', text: '◆ Lineage after this task · 1 model changed' })).toBeDefined()
   expect(await band.find({ type: 'Text', text: 'fct_orders · 6 downstream models at model level' })).toBeDefined()
-  expect(await band.find({ type: 'Text', text: '  revenue Σ  reaches 4 columns in 3 models (2 ends) · 1 may carry it · 2 cleared' })).toBeDefined()
+  expect(await band.find({ type: 'Text', text: '  revenue  reaches 4 columns in 3 models (2 ends) · 1 may carry it · 2 cleared' })).toBeDefined()
   expect(await band.find({ type: 'Text', text: '⚠ Lower bound: 1 model could not be read' })).toBeDefined()
-  expect(await band.find({ key: 'lineage-report-open' })).toBeDefined()
   expect(await band.find({ key: 'lineage-open' })).toBeDefined()
-  await band.press({ key: 'lineage-summary-dismiss' })
-  await clock.settle()
-  expect(await band.find({ key: 'lineage-report-open' })).toBeUndefined()
-  await band.unmount()
 
+  // The press: upstream is asked for now, and the page written.
+  await band.press({ key: 'lineage-report-open' })
+  await clock.settle()
+  expect(directional(tools).map(one => one.direction)).toEqual(['downstream', 'upstream'])
+  expect(directional(tools)[1]!.manifest_path).toBe(FROZEN)
   const report = embedded(writes.get(REPORT)!)
   expect(report.changes).toEqual([
     { model: 'fct_orders', file: 'models/fct_orders.sql', columns: [{ name: 'revenue', before: 'sum(amount) as revenue', after: 'sum(amount) - sum(refunds) as revenue' }] },
   ])
   expect(report.focuses[0].down.hops.length).toBe(3)
   expect(report.focuses[0].up.hops.length).toBe(2)
+  expect(report.movedOn).toEqual([])
+
+  // A second ask rewrites the page from what it has, asking nothing again.
+  await band.press({ key: 'lineage-report-open' })
+  await clock.settle()
+  expect(directional(tools).length).toBe(2)
+  // Never over MCP, whose call can raise a permission dialog.
+  expect(mcpAsked).toEqual([])
+
+  await band.press({ key: 'lineage-summary-dismiss' })
+  await clock.settle()
+  expect(await band.find({ key: 'lineage-report-open' })).toBeUndefined()
+  await band.unmount()
+})
+
+test('once the session has moved on, /lineage-report still builds that task, from its own manifest, and says what changed since', async ($, on) => {
+  const { tools, writes, files, turn, clock, copies } = await start($, on, { openers: { 'xdg-open': 0 } })
+  await turn('t1', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
+  })
+  // A later turn changes no model: its own copy goes down, the task's stays, and the band is gone.
+  await turn('t2', async () => {
+    files[MODEL] = files[MODEL]!.replace('order_id,', 'order_id as id,')
+  })
+  expect(copies.has(SNAPSHOT)).toBe(true)
+  expect(copies.has(FROZEN)).toBe(true)
+  const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  expect(await band.find({ key: 'lineage-report-open' })).toBeUndefined()
+  await band.unmount()
+  const before = directional(tools).length
+  const out: any = await $.command.run({ command: 'lineage-report', args: '' } as any)
+  await clock.settle()
+  expect(out.text).toMatch(/^Opened the column impact report for the task that finished at .* UTC: /)
+  expect(directional(tools).slice(before).map(one => [one.direction, one.manifest_path])).toEqual([['upstream', FROZEN]])
+  const report = embedded(writes.get(REPORT)!)
+  expect(report.changes[0].columns[0].after).toBe('sum(amount) * 2 as revenue')
+  expect(report.movedOn).toEqual(['models/fct_orders.sql'])
+})
+
+test('a later task that changes a model takes over: its report, its manifest', async ($, on) => {
+  const { writes, tools, turn } = await start($, on, { openers: { 'xdg-open': 0 } })
+  await turn('t1', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
+  })
+  await $.command.run({ command: 'lineage-report', args: '' } as any)
+  expect(embedded(writes.get(REPORT)!).changes[0].model).toBe('fct_orders')
+  await turn('t2', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: STAGING, old_string: 'amount_cents / 100 as amount', new_string: 'amount_cents / 100.0 as amount' })
+  })
+  // The last report is gone until the new one is asked for.
+  expect(writes.has(REPORT)).toBe(false)
+  await $.command.run({ command: 'lineage-report', args: '' } as any)
+  expect(embedded(writes.get(REPORT)!).changes.map((one: any) => one.model)).toEqual(['stg_payments'])
+  expect(directional(tools).filter(one => one.model === 'stg_payments').every(one => one.manifest_path === FROZEN)).toBe(true)
+})
+
+test('after a restart, /lineage-report rebuilds the last task from what was saved, both ways', async ($, on) => {
+  const { tools, writes, files, turn, clock } = await start($, on, { openers: { 'xdg-open': 0 } })
+  await turn('t1', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
+  })
+  const saved = JSON.parse(writes.get(TASK_FILE)!)
+  expect(saved.changes[0]).toMatchObject({ model: 'fct_orders', file: 'models/fct_orders.sql' })
+  expect(saved.manifests).toEqual({ [ROOT]: FROZEN })
+  await $.session.start({ cwd: ROOT, surface: 'terminal', isInteractive: true })
+  await clock.settle()
+  const before = directional(tools).length
+  // A commit in between moves HEAD but not the task, and the file is as the task left it.
+  const out: any = await $.command.run({ command: 'lineage-report', args: '' } as any)
+  expect(directional(tools).slice(before).map(one => `${one.direction}:${one.manifest_path === FROZEN}`).sort()).toEqual(['downstream:true', 'upstream:true'])
+  expect(out.text).toContain(`: ${REPORT}`)
+  expect(embedded(writes.get(REPORT)!).movedOn).toEqual([])
+  expect(files[MODEL]).toContain('* 2 as revenue')
+})
+
+test("when the task's copy of the manifest is gone it reads the project's and says so; with neither it asks for a compile", async ($, on) => {
+  let gone = false
+  const { copies, writes, turn, toasts, clock } = await start($, on, { openers: { 'xdg-open': 0 }, manifestGone: () => gone })
+  await turn('t1', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
+  })
+  copies.delete(FROZEN)
+  await $.command.run({ command: 'lineage-report', args: '' } as any)
+  expect(embedded(writes.get(REPORT)!).manifest).toBe("target/manifest.json as it is now, as the copy from the task's start is gone")
+  gone = true
+  const out: any = await $.command.run({ command: 'lineage-report', args: '' } as any)
+  expect(out.text).toBe('The manifest this task was read from is gone. Run `dbt compile` and ask again.')
+  await clock.settle()
+  expect(toasts).toContain(out.text)
+})
+
+test('a failed upstream trace is asked again next time, and the band keeps its numbers', async ($, on) => {
+  let up = false
+  const { tools, writes, turn, clock } = await start($, on, { openers: { 'xdg-open': 0 }, impact: args => (args.direction === 'upstream' && !up ? { column_answer: null } : {}) })
+  await turn('t1', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
+  })
+  await $.command.run({ command: 'lineage-report', args: '' } as any)
+  expect(embedded(writes.get(REPORT)!).focuses[0].up.error).toBe('This direction could not be traced.')
+  up = true
+  await $.command.run({ command: 'lineage-report', args: '' } as any)
+  await clock.settle()
+  expect(embedded(writes.get(REPORT)!).focuses[0].up.error).toBeNull()
+  expect(directional(tools).map(one => one.direction)).toEqual(['downstream', 'upstream', 'downstream', 'upstream'])
 })
 
 test('model files changed outside the edit tools are found through git, and only what changed this task', async ($, on) => {
@@ -196,7 +347,7 @@ test('model files changed outside the edit tools are found through git, and only
     files[SNAPSHOT_SQL] = '{% snapshot orders_snap %}select id, upper(status) as status from orders{% endsnapshot %}'
     changed = ['models/fct_orders.sql', 'models/stg_payments.sql', 'macros/cents.sql', 'snapshots/orders_snap.sql']
   })
-  expect(directional(tools).map(one => `${one.model}.${one.column}:${one.direction}`)).toEqual(['stg_payments.amount:downstream', 'stg_payments.amount:upstream'])
+  expect(directional(tools).map(one => `${one.model}.${one.column}:${one.direction}`)).toEqual(['stg_payments.amount:downstream'])
 })
 
 test('a change to no output column falls back to the model-level count', async ($, on) => {
@@ -204,11 +355,12 @@ test('a change to no output column falls back to the model-level count', async (
   await turn('t1', async () => {
     await $.tool.call({ tool: 'Edit', file_path: STAGING, old_string: "status = 'ok'", new_string: "status in ('ok', 'settled')" })
   })
-  expect(directional(tools)).toEqual([{ manifest_path: SNAPSHOT, model: 'stg_payments', change_type: 'modify', direction: 'downstream' }])
+  expect(directional(tools)).toEqual([{ manifest_path: FROZEN, model: 'stg_payments', change_type: 'modify', direction: 'downstream' }])
   const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
   expect(await band.find({ type: 'Text', text: 'stg_payments · 6 downstream models at model level' })).toBeDefined()
   expect(await band.find({ type: 'Text', text: '  no output column changed: the model-level count stands' })).toBeDefined()
   await band.unmount()
+  await $.command.run({ command: 'lineage-report', args: '' } as any)
   expect(embedded(writes.get(REPORT)!).focuses[0]).toMatchObject({ model: 'stg_payments', column: null, modelLevel: 6 })
 })
 
@@ -218,7 +370,7 @@ test('a task that changes no model shows nothing, and the next task clears the l
     await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
   })
   await turn('t2', async () => {})
-  expect(directional(tools).length).toBe(2)
+  expect(directional(tools).length).toBe(1)
   const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
   expect(await band.find({ key: 'lineage-report-open' })).toBeUndefined()
   await band.unmount()
@@ -241,7 +393,8 @@ test('Open report on WSL falls back to explorer.exe, whose exit 1 is success; /l
   await band.unmount()
 
   const out: any = await $.command.run({ command: 'lineage-report', args: '' } as any)
-  expect(out.text).toBe(`Opened the column impact report: ${REPORT}`)
+  expect(out.text).toMatch(/^Opened the column impact report for the task that finished at .* UTC: /)
+  expect(out.text).toContain(REPORT)
 })
 
 test('on WSL with no wslview and no explorer.exe on PATH, Windows\' own explorer.exe opens the report', async ($, on) => {
@@ -255,7 +408,8 @@ test('on WSL with no wslview and no explorer.exe on PATH, Windows\' own explorer
   const win = '\\\\wsl.localhost\\dev\\repo\\target\\.altimate-lineage\\report.html'
   const tried = runs.filter(one => ['wslview', 'explorer.exe', '/mnt/c/Windows/explorer.exe', 'xdg-open'].includes(one[0]!))
   expect(tried).toEqual([['wslview', REPORT], ['explorer.exe', win], ['/mnt/c/Windows/explorer.exe', win]])
-  expect(out.text).toBe(`Opened the column impact report: ${REPORT}`)
+  expect(out.text).toMatch(/^Opened the column impact report for the task that finished at .* UTC: /)
+  expect(out.text).toContain(REPORT)
 })
 
 test('on WSL with no Windows opener at all, xdg-open is the last try', async ($, on) => {
@@ -266,7 +420,8 @@ test('on WSL with no Windows opener at all, xdg-open is the last try', async ($,
   const out: any = await $.command.run({ command: 'lineage-report', args: '' } as any)
   const tried = runs.filter(one => ['wslview', 'explorer.exe', '/mnt/c/Windows/explorer.exe', 'xdg-open'].includes(one[0]!)).map(one => one[0])
   expect(tried).toEqual(['wslview', 'explorer.exe', 'xdg-open'])
-  expect(out.text).toBe(`Opened the column impact report: ${REPORT}`)
+  expect(out.text).toMatch(/^Opened the column impact report for the task that finished at .* UTC: /)
+  expect(out.text).toContain(REPORT)
 })
 
 test('when no browser opens, the band shows the report path as a link', async ($, on) => {
@@ -286,7 +441,7 @@ test('when no browser opens, the band shows the report path as a link', async ($
 test('macOS opens with open; /lineage-report before any report says so', async ($, on) => {
   const { runs, turn } = await start($, on, { uname: 'Darwin', openers: { open: 0 } })
   const none: any = await $.command.run({ command: 'lineage-report', args: '' } as any)
-  expect(none.text).toBe('No column impact report yet: one is written when a task changes a dbt model.')
+  expect(none.text).toBe('No column impact report yet: one can be built after a task changes a dbt model.')
   await turn('t1', async () => {
     await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
   })
diff --git a/plugins/altimate-code/hooks/task-impact.tsx b/plugins/altimate-code/hooks/task-impact.tsx
index 8b910a1..79716f8 100644
--- a/plugins/altimate-code/hooks/task-impact.tsx
+++ b/plugins/altimate-code/hooks/task-impact.tsx
@@ -1,5 +1,5 @@
 // The end-of-task column impact: what a task changed in its dbt models, how far each changed column's
-// value reaches, as one summary in the band, and a full offline report that opens in the browser.
+// value reaches, as one summary in the band, and a full offline report built when asked for.
 import { atom, read, update } from 'claude-code'
 import type { EngineInterface, On, RenderElement } from 'claude-code'
 
@@ -9,6 +9,8 @@ import {
   answerOf,
   changedColumns,
   type ColumnTrace,
+  consumersOf,
+  fingerprint,
   type ModelChange,
   modelLevelOf,
   openersFor,
@@ -25,6 +27,11 @@ import { openPane, projectRoot, runTool, within } from './lineage'
 export const REPORT_COMMAND = 'lineage-report'
 // Under the project's target/, which dbt already keeps out of git.
 const LINEAGE_DIR = 'target/.altimate-lineage'
+// A task's copy of the manifest while it runs, and the last finished task's, kept for its report.
+const RUNNING_MANIFEST = 'manifest-before.json'
+const TASK_MANIFEST = 'task-manifest.json'
+// What a report needs of the last finished task, so one can be built after a restart too.
+const TASK_FILE = 'last-task.json'
 const EDIT_TOOLS = new Set(['Edit', 'Write', 'MultiEdit'])
 // The most changed models one task traces; the rest are named in the log.
 const MAX_MODELS = 5
@@ -43,9 +50,21 @@ type GitStart = { top: string; dirty: Map<string, string | null> }
 type RootState = { snapshot: string | null; layout: Layout; git: GitStart | null }
 type Task = { roots: Map<string, Promise<RootState>>; originals: Map<string, { root: string; text: string }> }
 
+/** The last task that changed a model: all a report needs, frozen as the task ended. */
+type Finished = {
+  finishedAt: number
+  changes: ModelChange[]
+  /** Each project's copy of the manifest from the task's start; null when there was none. */
+  manifests: Record<string, string | null>
+  /** The downstream answers, once asked for; a restart loses them. */
+  downs: Promise<ColumnTrace[]> | null
+  /** Both directions, once a report asked for them. */
+  full: Promise<ColumnTrace[]> | null
+}
+
 // The task under way: from a main-loop turn's start to its end.
 let task: Task | null = null
-let lastReport: string | null = null
+let finished: Finished | null = null
 let finishSeq = 0
 
 const newTask = (): Task => ({ roots: new Map(), originals: new Map() })
@@ -92,8 +111,8 @@ function prepareRoot($: EngineInterface, t: Task, root: string): Promise<RootSta
       // The manifest can be far over the 4 MiB a plugin reads, so it is copied, never read.
       const dir = `${root}/${LINEAGE_DIR}`
       const made = await $.process.run(['mkdir', '-p', dir], { timeoutMs: 5_000 }).catch(() => null)
-      const copied = made?.exitCode === 0 ? await $.process.run(['cp', manifest, `${dir}/manifest-before.json`], { timeoutMs: 20_000 }).catch(() => null) : null
-      if (copied?.exitCode === 0) snapshot = `${dir}/manifest-before.json`
+      const copied = made?.exitCode === 0 ? await $.process.run(['cp', manifest, `${dir}/${RUNNING_MANIFEST}`], { timeoutMs: 20_000 }).catch(() => null) : null
+      if (copied?.exitCode === 0) snapshot = `${dir}/${RUNNING_MANIFEST}`
     }
     const top = (await git($, ['-C', root, 'rev-parse', '--show-toplevel']))?.trim()
     let gitStart: GitStart | null = null
@@ -133,7 +152,7 @@ async function collectChanges($: EngineInterface, t: Task): Promise<ModelChange[
     if (state && !isModelFile(state.layout, relative(one.root, file))) continue
     const current = await $.fs.read(file).catch(() => '')
     if (current === one.original) continue
-    changes.push({ model: modelName(file), file: relative(one.root, file), root: one.root, columns: changedColumns(one.original, current) })
+    changes.push({ model: modelName(file), file: relative(one.root, file), root: one.root, columns: changedColumns(one.original, current), ended: fingerprint(current) })
   }
   if (changes.length > MAX_MODELS) $.ui.log(`lineage-summary · ${changes.length} models changed; tracing the first ${MAX_MODELS}`)
   return changes.slice(0, MAX_MODELS)
@@ -154,46 +173,79 @@ async function pool<T>(items: (() => Promise<T>)[], limit: number): Promise<T[]>
   return out
 }
 
-/** Downstream and upstream answers for each changed column; the model-level count for a model with none. */
-async function traceChanges($: EngineInterface, t: Task, changes: ModelChange[]): Promise<ColumnTrace[]> {
-  const ask = async (change: ModelChange, column: string | null, direction: 'downstream' | 'upstream') => {
-    const state = await t.roots.get(change.root)?.catch(() => null)
-    const manifest = state?.snapshot ?? `${change.root}/target/manifest.json`
-    // Known limit: the model goes by its file name, which misses a versioned model (x_v2.sql) or a file
-    // named apart from its model.
-    const args = { manifest_path: manifest, model: change.model, ...(column && { column }), change_type: 'modify', direction }
-    const result = await runTool($, 'impact_analysis', args).catch(() => null)
-    return result?.ok ? result.metadata : null
-  }
+/** The copy of the manifest a project's answers read: the task's own, else the project's as it is now. */
+const manifestOf = (done: Finished, root: string) => done.manifests[root] ?? `${root}/target/manifest.json`
+
+/** One impact_analysis call for a change; null when it failed. */
+async function ask($: EngineInterface, done: Finished, change: ModelChange, column: string | null, direction: 'downstream' | 'upstream') {
+  // Known limit: the model goes by its file name, which misses a versioned model (x_v2.sql) or a file
+  // named apart from its model.
+  const args = { manifest_path: manifestOf(done, change.root), model: change.model, ...(column && { column }), change_type: 'modify', direction }
+  // Through the CLI: nobody asked for these calls by name, and a call over MCP can raise a permission dialog.
+  const result = await runTool($, 'impact_analysis', args, true).catch(() => null)
+  return result?.ok ? result.metadata : null
+}
+
+/** What the band needs: each changed column's downstream answer, and the model-level count for a model with none. */
+async function traceDown($: EngineInterface, done: Finished): Promise<ColumnTrace[]> {
   const jobs: (() => Promise<ColumnTrace>)[] = []
-  for (const change of changes) {
+  for (const change of done.changes) {
     if (change.columns.length === 0) {
       jobs.push(async () => {
-        const meta = await ask(change, null, 'downstream')
-        return { model: change.model, column: null, down: null, up: null, modelLevel: modelLevelOf(meta), failed: meta === null }
+        const meta = await ask($, done, change, null, 'downstream')
+        return { model: change.model, column: null, down: null, up: null, modelLevel: modelLevelOf(meta), failed: meta === null, consumers: consumersOf(meta) }
       })
     }
     for (const col of change.columns) {
       jobs.push(async () => {
-        const [down, up] = await Promise.all([ask(change, col.name, 'downstream'), ask(change, col.name, 'upstream')])
-        const downAnswer = answerOf(down)
-        return { model: change.model, column: col.name, down: downAnswer, up: answerOf(up), modelLevel: modelLevelOf(down), failed: !downAnswer }
+        const meta = await ask($, done, change, col.name, 'downstream')
+        const down = answerOf(meta)
+        return { model: change.model, column: col.name, down, up: null, modelLevel: modelLevelOf(meta), failed: !down, consumers: consumersOf(meta) }
       })
     }
   }
-  return pool(jobs, PARALLEL / 2)
+  return pool(jobs, PARALLEL)
+}
+
+/** What a report adds: where each changed column comes from. */
+async function traceFull($: EngineInterface, done: Finished): Promise<ColumnTrace[]> {
+  const downs = await (done.downs ??= traceDown($, done))
+  const jobs = downs.map(trace => async () => {
+    if (!trace.column) return trace
+    const change = done.changes.find(one => one.model === trace.model)!
+    return { ...trace, up: answerOf(await ask($, done, change, trace.column, 'upstream')) }
+  })
+  return pool(jobs, PARALLEL)
 }
 
 const stamp = (ms: number) => new Date(ms).toISOString().slice(0, 16).replace('T', ' ') + ' UTC'
 
-/** At a task's end: what changed, traced, summed up in the band, and written as the report. */
+/** Moves each project's copy of the manifest out of the next task's way. */
+async function freezeManifests($: EngineInterface, t: Task, changes: ModelChange[]): Promise<Record<string, string | null>> {
+  const out: Record<string, string | null> = {}
+  for (const root of new Set(changes.map(one => one.root))) {
+    const state = await t.roots.get(root)?.catch(() => null)
+    if (!state?.snapshot) {
+      out[root] = null
+      continue
+    }
+    const frozen = `${root}/${LINEAGE_DIR}/${TASK_MANIFEST}`
+    const moved = await $.process.run(['mv', '-f', state.snapshot, frozen], { timeoutMs: 5_000 }).catch(() => null)
+    out[root] = moved?.exitCode === 0 ? frozen : state.snapshot
+  }
+  return out
+}
+
+const reportPathOf = (done: Finished) => `${done.changes[0]!.root}/${LINEAGE_DIR}/report.html`
+
+/** At a task's end: what changed, traced downstream and summed up in the band. The report waits until it is asked for. */
 async function finishTask($: EngineInterface, t: Task) {
   const seq = ++finishSeq
   const changes = await collectChanges($, t)
   if (changes.length === 0) return
   const tracing: TaskSummaryView = {
     state: 'tracing',
-    models: changes.map(one => ({ name: one.model, modelLevel: null, columns: one.columns.map(col => ({ name: col.name, how: null, reach: null, failed: false })) })),
+    models: changes.map(one => ({ name: one.model, modelLevel: null, columns: one.columns.map(col => ({ name: col.name, reach: null, failed: false })) })),
     unresolved: 0,
     truncated: false,
     report: null,
@@ -201,27 +253,85 @@ async function finishTask($: EngineInterface, t: Task) {
   }
   await update($, summaryAtom, () => tracing)
   await update($, hiddenAtom, () => false)
-  const traces = await traceChanges($, t, changes)
+  const done: Finished = { finishedAt: await $.clock.now(), changes, manifests: await freezeManifests($, t, changes), downs: null, full: null }
   const root = changes[0]!.root
-  const state = await t.roots.get(root)?.catch(() => null)
-  const data = reportData(changes, traces, stamp(await $.clock.now()), state?.snapshot ? 'the manifest as it was when the task started' : 'target/manifest.json')
-  const path = `${root}/${LINEAGE_DIR}/report.html`
-  let report: string | null = null
-  try {
-    await $.fs.write(path, reportHtml(data))
-    report = path
-    lastReport = path
-  } catch (error) {
-    $.ui.log(`lineage-summary · the report could not be written: ${String(error)}`)
-  }
+  // The last task's report is no longer the last task's.
+  await $.process.run(['rm', '-f', reportPathOf(done)], { timeoutMs: 5_000 }).catch(() => null)
+  finished = done
+  await $.fs
+    .write(`${root}/${LINEAGE_DIR}/${TASK_FILE}`, JSON.stringify({ version: 1, finishedAt: done.finishedAt, changes, manifests: done.manifests }))
+    .catch(error => $.ui.log(`lineage-summary · the task could not be saved: ${String(error)}`, { to: 'debug' }))
+  const traces = await (done.downs = traceDown($, done))
   // A newer task finished first: its summary stays.
   if (seq !== finishSeq) return
-  const view = summaryOf(changes, traces, report)
+  const view = summaryOf(changes, traces, null)
   await update($, summaryAtom, () => view)
   // One line: a log line draws a newline as a replacement glyph.
   $.ui.log(summaryLines(view).map(line => line.trim()).join(' · '))
 }
 
+/** The last task that changed a model: this session's, else the one a project's saved file names. */
+async function lastTask($: EngineInterface): Promise<Finished | null> {
+  if (finished) return finished
+  const own = await projectRoot($, await $.session.root().catch(() => '.'), false).catch(() => null)
+  if (!own) return null
+  const text = await $.fs.read(`${own}/${LINEAGE_DIR}/${TASK_FILE}`).catch(() => null)
+  if (!text) return null
+  try {
+    const saved = JSON.parse(text)
+    if (saved?.version !== 1 || !Array.isArray(saved.changes) || saved.changes.length === 0) return null
+    return (finished = { finishedAt: Number(saved.finishedAt), changes: saved.changes, manifests: saved.manifests ?? {}, downs: null, full: null })
+  } catch {
+    return null
+  }
+}
+
+/** The files a task changed that differ now from how it left them. */
+async function movedOn($: EngineInterface, done: Finished): Promise<string[]> {
+  const out: string[] = []
+  for (const change of done.changes) {
+    const now = await $.fs.read(`${change.root}/${change.file}`).catch(() => '')
+    if (change.ended && fingerprint(now) !== change.ended) out.push(change.file)
+  }
+  return out
+}
+
+/** Builds the report of a finished task; what it reads was frozen as the task ended, so later turns don't change it. */
+async function buildReport($: EngineInterface, done: Finished): Promise<{ path: string } | { error: string }> {
+  const missing: string[] = []
+  for (const [root, frozen] of Object.entries(done.manifests)) {
+    if (frozen && !(await $.fs.exists(frozen).catch(() => false))) {
+      // Its copy is gone (`dbt clean`, say): the project's manifest as it is now, or nothing.
+      done.manifests[root] = null
+      done.downs = null
+      done.full = null
+    }
+    if (!done.manifests[root] && !(await $.fs.exists(`${root}/target/manifest.json`).catch(() => false))) missing.push(root)
+  }
+  if (missing.length > 0) return { error: `The manifest this task was read from is gone. Run \`dbt compile\` and ask again.` }
+  const traces = await (done.full ??= traceFull($, done))
+  const allRead = traces.every(one => !one.column || (one.down && one.up))
+  // A failed direction is asked again next time.
+  if (!allRead) {
+    done.full = null
+    done.downs = null
+  }
+  const frozen = Object.values(done.manifests).every(Boolean)
+  const data = reportData(done.changes, traces, {
+    finishedAt: stamp(done.finishedAt),
+    builtAt: stamp(await $.clock.now()),
+    manifest: frozen ? 'the manifest as it was when the task started' : 'target/manifest.json as it is now, as the copy from the task\'s start is gone',
+    movedOn: await movedOn($, done),
+  })
+  const path = reportPathOf(done)
+  try {
+    await $.fs.write(path, reportHtml(data))
+    return { path }
+  } catch (error) {
+    return { error: `The report could not be written: ${String(error)}` }
+  }
+}
+
 /** Which opener family this machine has: macOS, Linux, WSL (Linux under Windows), or Windows itself. */
 async function platformOf($: EngineInterface): Promise<Platform> {
   // -r too: a WSL kernel's release names Microsoft, with no environment variable needed.
@@ -249,20 +359,30 @@ export async function openReport($: EngineInterface, path: string): Promise<bool
   return false
 }
 
-async function openAndSay($: EngineInterface, path: string): Promise<boolean> {
-  const opened = await openReport($, path)
-  if (!opened) await update($, summaryAtom, view => (view && view.report === path ? { ...view, openFailed: true } : view))
-  return opened
+/** Builds the last task's report and opens it, for the button and the command; what to say about it. */
+async function buildAndOpen($: EngineInterface): Promise<string> {
+  const done = await lastTask($)
+  if (!done) return 'No column impact report yet: one can be built after a task changes a dbt model.'
+  await update($, summaryAtom, view => (view ? { ...view, building: true, openFailed: false } : view))
+  const built = await buildReport($, done)
+  if ('error' in built) {
+    await update($, summaryAtom, view => (view ? { ...view, building: false } : view))
+    $.ui.toast(built.error)
+    return built.error
+  }
+  const opened = await openReport($, built.path)
+  await update($, summaryAtom, view => (view ? { ...view, building: false, report: built.path, openFailed: !opened } : view))
+  return opened ? `Opened the column impact report for the task that finished at ${stamp(done.finishedAt)}: ${built.path}` : `No browser could be opened. The report is at ${built.path}`
 }
 
 /** Registers /lineage-report; called from the plugin's one session.start hook. */
 export async function startTaskImpact($: EngineInterface) {
   task = null
-  lastReport = null
+  finished = null
   await update($, summaryAtom, () => null)
   await $.command.register({
     name: REPORT_COMMAND,
-    description: 'Open the last column impact report (what a task changed in dbt models and what it reaches) in the browser',
+    description: 'Build and open the column impact report of the last task that changed a dbt model: what changed and what it reaches',
   })
 }
 
@@ -288,13 +408,14 @@ export async function taskBand($: EngineInterface, ui: Ui): Promise<RenderElemen
           {line}
         </Text>
       ))}
+      {view.building ? <Text dimColor>Building the report…</Text> : null}
       {report && view.openFailed ? (
         <Text dimColor>
           No browser opened. Report: {Link ? <Link href={`file://${report}`}>{report}</Link> : report}
         </Text>
       ) : null}
       <Box>
-        {report ? <Button key="lineage-report-open" label="Open report" onPress={() => later($, () => openAndSay($, report))} /> : null}
+        {view.state === 'ready' ? <Button key="lineage-report-open" label="Open report" onPress={() => later($, async () => void (await buildAndOpen($)))} /> : null}
         <Button key="lineage-open" label="Open lineage" onPress={() => later($, () => openPane($))} />
         <Button key="lineage-summary-dismiss" label="Dismiss" onPress={() => update($, hiddenAtom, () => true)} />
       </Box>
@@ -335,17 +456,7 @@ export function taskTurnComplete($: EngineInterface, e: { agentId?: string }) {
   later($, () => finishTask($, done).catch(error => $.ui.log(`lineage-summary · failed: ${String(error)}`)))
 }
 
-/** /lineage-report: opens the last report. */
+/** /lineage-report: builds the last finished task's report and opens it. */
 export function registerTaskImpact(on: On) {
-  on('command.run', { command: REPORT_COMMAND }, async $ => {
-    let path = lastReport
-    if (!path) {
-      const own = await projectRoot($, await $.session.root().catch(() => '.'), false).catch(() => null)
-      const candidate = own ? `${own}/${LINEAGE_DIR}/report.html` : null
-      if (candidate && (await $.fs.exists(candidate).catch(() => false))) path = candidate
-    }
-    if (!path) return { text: 'No column impact report yet: one is written when a task changes a dbt model.' }
-    const opened = await openAndSay($, path)
-    return { text: opened ? `Opened the column impact report: ${path}` : `No browser could be opened. The report is at ${path}` }
-  })
+  on('command.run', { command: REPORT_COMMAND }, async $ => ({ text: await buildAndOpen($) }))
 }
diff --git a/plugins/altimate-code/types/index.d.ts b/plugins/altimate-code/types/index.d.ts
index 3800db5..bdaf02f 100644
--- a/plugins/altimate-code/types/index.d.ts
+++ b/plugins/altimate-code/types/index.d.ts
@@ -185,8 +185,7 @@ export type Reach = {
   truncated: boolean
 }
 
-/** `how`: how the column is made from what it reads, before the task; `byName` when that was inferred from matching names. */
-export type SummaryColumn = { name: string; how: string | null; byName?: boolean; reach: Reach | null; failed: boolean }
+export type SummaryColumn = { name: string; reach: Reach | null; failed: boolean }
 
 /** What the band shows after a task that changed models. */
 export type TaskSummaryView = {
@@ -195,7 +194,10 @@ export type TaskSummaryView = {
   /** Models whose SQL could not be read, across every column traced: the reach is a lower bound. */
   unresolved: number
   truncated: boolean
+  /** Where the report was written, once one was asked for. */
   report: string | null
+  /** Tracing upstream and writing the report, after a press. */
+  building?: boolean
   /** The report could not be opened: its path is shown as a link instead. */
   openFailed: boolean
 }

From b401148d00df06b70c21e363670ee4d6847ea7fc Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Fri, 6 Nov 2026 14:09:21 +0800
Subject: [PATCH 09/21] feat: the models a plan names, at the model level,
 before it is approved

When ExitPlanMode goes up, a line above the dialog gives each named model's downstream models, tests and exposures, and the band repeats it after. It holds nothing back and spends no model tokens. It goes by names in the plan's text.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YNQjkaiykbC1WtASw6Yegs
---
 plugins/altimate-code/CHANGELOG.md            |  1 +
 plugins/altimate-code/README.md               |  1 +
 .../altimate-code/hooks/impact-report.test.ts | 19 +++++
 plugins/altimate-code/hooks/impact-report.ts  | 23 +++++-
 plugins/altimate-code/hooks/lineage.tsx       |  2 +-
 .../altimate-code/hooks/task-impact.test.tsx  | 55 ++++++++++++++
 plugins/altimate-code/hooks/task-impact.tsx   | 72 ++++++++++++++++---
 plugins/altimate-code/types/index.d.ts        |  9 +++
 8 files changed, 169 insertions(+), 13 deletions(-)

diff --git a/plugins/altimate-code/CHANGELOG.md b/plugins/altimate-code/CHANGELOG.md
index aa184d5..a24b6ca 100644
--- a/plugins/altimate-code/CHANGELOG.md
+++ b/plugins/altimate-code/CHANGELOG.md
@@ -7,6 +7,7 @@ All notable changes to this plugin will be documented in this file.
 ### Added
 - End-of-task column impact: after a task that changed a dbt model, a band sums up each changed column's downstream reach from `impact_analysis`. The task's start copies `target/manifest.json` aside, so the answer reflects the SQL before the task.
 - An offline HTML report, built when **Open report** or `/lineage-report` asks for it: what changed and what to expect downstream in plain words, who consumes it from dbt exposures, then upstream and downstream lineage, two levels by default, and click-to-highlight paths.
+- When a plan goes up for approval, a line above the dialog gives the downstream models, tests and exposures of each model the plan names.
 
 ### Changed
 - The per-edit impact note no longer shows as a toast and band; it still goes to Claude's context with the edit's result.
diff --git a/plugins/altimate-code/README.md b/plugins/altimate-code/README.md
index f2a964f..a87474a 100644
--- a/plugins/altimate-code/README.md
+++ b/plugins/altimate-code/README.md
@@ -110,6 +110,7 @@ The plugin's lineage pane opens when you ask for it, with `/lineage` or the summ
 - **Impact first.** Before an edit to a model's SQL lands, the plugin checks what reads the model and the reach of every column the edit touches (up to three, merged), and adds it to Claude's context with the edit's result. You see the summary at the end of the task, not a note per edit.
 - **End-of-task summary.** When a task (one prompt and Claude's work on it) changed a model, by an edit or a shell command git sees, a band above the prompt says what changed and how far it reaches: each changed column (up to three per model) with the columns, models and end columns downstream that carry its value, the models that may carry it and those cleared, next to the model-level count, and a line when some models could not be read. The trace reads a copy of `target/manifest.json` taken when the task started, so a recompile mid-task does not change the answer. These lookups go through the CLI, so they raise no permission prompt.
 - **The report, on demand.** **Open report** or `/lineage-report` builds an offline HTML report of the last task that changed a model and opens it in the browser (`target/.altimate-lineage/report.html`). It leads with what changed, before and after, what to expect downstream in plain words, and who consumes it: the dbt exposures on the model or downstream, grouped by whether they read a model the value reaches, and a plain statement when the project declares none. Only declared exposures appear: other BI tools and backend services do not. Under that are two levels upstream and downstream (more on request), and a click on any column lights up its path. Nothing is written until you ask. What it reads was kept when the task ended (`task-manifest.json`, `last-task.json`), so asking later, after other turns or a restart, still describes that task, and it says if a file has changed since. A later task that changes a model replaces it. The band's button goes when the next turn starts; `/lineage-report` keeps working.
+- **Before a plan.** When Claude puts a plan up for approval, the plugin looks for the models the plan names and adds one line above the dialog with each one's downstream models, tests and exposures, at the model level. It holds nothing back and spends no model tokens. The band shows the same once the dialog closes, until the task's summary takes over. It goes by the names in the plan's text, so a model it mentions may not be one it changes, and "the staging models" finds nothing. Leaving plan mode with shift+tab shows nothing.
 - **Warehouse lineage.** When a connected MCP server offers Altimate's `table_lineage` (Snowflake) or `databricks_table_lineage`, the pane adds what the warehouse's query history shows for the model's table. The plugin calls a tool of that name on whichever connected server offers it, itself and without a permission prompt, and sends it the model's `database.schema.table`. It does so only when you ask for the model (`/lineage`, a press in the pane, or `r`), never when the pane follows one of Claude's reads.
 - **Claude's own lineage calls.** A `dbt_lineage` result is drawn as a list of edges colored by how each column is derived; ctrl+o keeps the original output under it.
 
diff --git a/plugins/altimate-code/hooks/impact-report.test.ts b/plugins/altimate-code/hooks/impact-report.test.ts
index ad41e33..3efe186 100644
--- a/plugins/altimate-code/hooks/impact-report.test.ts
+++ b/plugins/altimate-code/hooks/impact-report.test.ts
@@ -13,6 +13,7 @@ import {
   mergeConsumers,
   type ModelChange,
   openersFor,
+  planLines,
   reachOf,
   reportData,
   reportHtml,
@@ -238,6 +239,24 @@ describe('consumers', () => {
   })
 })
 
+describe('a plan', () => {
+  const model = { name: 'mrt_usage', modelLevel: 39, tests: 307, exposures: 0, declared: 0, failed: false }
+
+  test('names its models at the model level and says nothing has changed yet', () => {
+    expect(planLines({ state: 'ready', models: [model, { ...model, name: 'stg_a', modelLevel: 1, tests: 1, exposures: 2, declared: 4 }, { ...model, name: 'stg_b', modelLevel: null, tests: null, exposures: null, failed: true }], more: 2 })).toEqual([
+      '◆ Before this plan · it names 5 dbt models · model level, nothing has changed yet',
+      'mrt_usage · 39 downstream models · 307 tests · no exposures declared',
+      'stg_a · 1 downstream model · 1 test · 2 exposures',
+      'stg_b · could not be read',
+      '… and 2 more',
+    ])
+  })
+
+  test('while it looks them up, says so', () => {
+    expect(planLines({ state: 'tracing', models: [{ ...model, modelLevel: null, tests: null, exposures: null, declared: null }], more: 0 })[1]).toBe('mrt_usage · tracing…')
+  })
+})
+
 describe('the report', () => {
   test('leads with what changed and what to expect, and keeps the levels and paths underneath', () => {
     const html = reportHtml(reportData([{ ...CHANGE, ended: fingerprint('x') }], [TRACE], { ...TASK, movedOn: ['models/fct_orders.sql'] }))
diff --git a/plugins/altimate-code/hooks/impact-report.ts b/plugins/altimate-code/hooks/impact-report.ts
index 2b16189..805a82f 100644
--- a/plugins/altimate-code/hooks/impact-report.ts
+++ b/plugins/altimate-code/hooks/impact-report.ts
@@ -1,10 +1,10 @@
 // The end-of-task column impact: altimate-code's column answers read into a short summary for the band
 // and a self-contained HTML report. Pure functions only; the hooks live in task-impact.tsx.
 
-import type { Reach, TaskSummaryView } from '../types'
+import type { PlanImpactView, Reach, TaskSummaryView } from '../types'
 import { selectItems, touchedColumns } from './lineage-graph'
 
-export type { Reach, TaskSummaryView }
+export type { PlanImpactView, Reach, TaskSummaryView }
 
 /** One column answer from impact_analysis (`metadata.column_answer`, contract version 1). Any field may be absent. */
 export type ColumnAnswer = {
@@ -266,6 +266,25 @@ export function summaryLines(view: TaskSummaryView): string[] {
   return lines
 }
 
+/** The band's lines for a plan about to be approved or just approved: the models it names, at the model level. */
+export function planLines(view: PlanImpactView): string[] {
+  const plural = (n: number, word: string) => `${n} ${word}${n === 1 ? '' : 's'}`
+  const total = view.models.length + view.more
+  const lines = [`◆ Before this plan · it names ${plural(total, 'dbt model')} · model level, nothing has changed yet`]
+  for (const model of view.models) {
+    if (view.state === 'tracing' && model.modelLevel === null && !model.failed) lines.push(`${model.name} · tracing…`)
+    else if (model.failed) lines.push(`${model.name} · could not be read`)
+    else {
+      const parts = [`${plural(model.modelLevel ?? 0, 'downstream model')}`]
+      if (model.tests !== null) parts.push(plural(model.tests, 'test'))
+      if (model.exposures !== null) parts.push(model.exposures > 0 ? plural(model.exposures, 'exposure') : model.declared === 0 ? 'no exposures declared' : 'no exposures downstream')
+      lines.push(`${model.name} · ${parts.join(' · ')}`)
+    }
+  }
+  if (view.more > 0) lines.push(`… and ${view.more} more`)
+  return lines
+}
+
 // ---------------------------------------------------------------------------------------------------
 // The report: data the page draws from, then the page.
 
diff --git a/plugins/altimate-code/hooks/lineage.tsx b/plugins/altimate-code/hooks/lineage.tsx
index 54554dd..1f5e47c 100644
--- a/plugins/altimate-code/hooks/lineage.tsx
+++ b/plugins/altimate-code/hooks/lineage.tsx
@@ -236,7 +236,7 @@ async function projectWith($: EngineInterface, start: string, model: string, pre
  * backticks (a bare `orders` in prose is too often just a word). Read from the project shown, else the
  * session's.
  */
-async function modelsNamed($: EngineInterface, text: string, root: string, shownManifest?: string): Promise<AnswerModel[]> {
+export async function modelsNamed($: EngineInterface, text: string, root: string, shownManifest?: string): Promise<AnswerModel[]> {
   const manifest = shownManifest ?? `${root}/target/manifest.json`
   const fromManifest = await readGraph($, manifest).catch(() => null)
   // The manifest an entry keeps: the shown graph's (read here, or through altimate-code when over
diff --git a/plugins/altimate-code/hooks/task-impact.test.tsx b/plugins/altimate-code/hooks/task-impact.test.tsx
index ca1378d..ed498e2 100644
--- a/plugins/altimate-code/hooks/task-impact.test.tsx
+++ b/plugins/altimate-code/hooks/task-impact.test.tsx
@@ -320,6 +320,39 @@ test("when the task's copy of the manifest is gone it reads the project's and sa
   expect(toasts).toContain(out.text)
 })
 
+test('a plan going up for approval: the models it names, at the model level, without holding the dialog', async ($, on) => {
+  const impact = (args: Record<string, any>) => (args.column ? {} : { test_count: 12, exposures: [], exposures_declared: 0 })
+  const { tools, logs, dialogs, clock, turn, mcpAsked } = await start($, on, { impact })
+  await $.turn.start({ text: 'plan it', turnId: 'p1' })
+  await clock.settle()
+  const plan = 'Round revenue in `fct_orders` (models/fct_orders.sql); check `stg_payments` and nothing_like_a_model.'
+  await $.tool.call({ tool: 'ExitPlanMode', plan, planFilePath: '/plans/p.md' } as any)
+  // The dialog opened before any lookup ran.
+  expect(dialogs).toEqual([0])
+  await clock.settle()
+  expect(directional(tools).map(one => [one.model, one.column, one.manifest_path])).toEqual([
+    ['model.shop.fct_orders', undefined, MANIFEST],
+    ['model.shop.stg_payments', undefined, MANIFEST],
+  ])
+  expect(logs).toContain('◆ Before this plan · it names 2 dbt models · model level, nothing has changed yet · fct_orders · 6 downstream models · 12 tests · no exposures declared · stg_payments · 6 downstream models · 12 tests · no exposures declared')
+  const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  expect(await band.find({ type: 'Text', text: 'fct_orders · 6 downstream models · 12 tests · no exposures declared' })).toBeDefined()
+  expect(mcpAsked).toEqual([])
+  // No report for a plan: nothing has changed.
+  expect(await band.find({ key: 'lineage-report-open' })).toBeUndefined()
+  expect(await band.find({ key: 'lineage-open' })).toBeDefined()
+
+  // Approved, the task runs in the same turn: its summary takes the band.
+  await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'round(sum(amount), 2) as revenue' })
+  await clock.settle()
+  await $.turn.complete({ answer: 'Done.', durationMs: 5, isAborted: false, reason: 'answer', turnId: 'p1' } as any)
+  await clock.settle()
+  expect(await band.find({ type: 'Text', text: '◆ Lineage after this task · 1 model changed' })).toBeDefined()
+  expect(await band.find({ type: 'Text', text: /Before this plan/ })).toBeUndefined()
+  await band.unmount()
+  await turn('t2', async () => {})
+})
+
 test('a failed upstream trace is asked again next time, and the band keeps its numbers', async ($, on) => {
   let up = false
   const { tools, writes, turn, clock } = await start($, on, { openers: { 'xdg-open': 0 }, impact: args => (args.direction === 'upstream' && !up ? { column_answer: null } : {}) })
@@ -335,6 +368,28 @@ test('a failed upstream trace is asked again next time, and the band keeps its n
   expect(directional(tools).map(one => one.direction)).toEqual(['downstream', 'upstream', 'downstream', 'upstream'])
 })
 
+test('a plan that names no model, or a subagent\'s, shows nothing; a new turn clears a plan\'s band; a plan file is the fallback', async ($, on) => {
+  const { tools, logs, clock, files } = await start($, on)
+  await $.turn.start({ text: 'plan it', turnId: 'p1' })
+  await clock.settle()
+  await $.tool.call({ tool: 'ExitPlanMode', plan: 'Tidy up the README.', planFilePath: '/plans/p.md' } as any)
+  await clock.settle()
+  await $.tool.call({ tool: 'ExitPlanMode', plan: 'Change `fct_orders`.', planFilePath: '/plans/p.md', agentId: 'a1' } as any)
+  await clock.settle()
+  expect(directional(tools)).toEqual([])
+  expect(logs.filter(one => one.includes('Before this plan'))).toEqual([])
+
+  files['/plans/q.md'] = 'Change `fct_orders`.'
+  await $.tool.call({ tool: 'ExitPlanMode', planFilePath: '/plans/q.md' } as any)
+  await clock.settle()
+  const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  expect(await band.find({ type: 'Text', text: /Before this plan · it names 1 dbt model/ })).toBeDefined()
+  await $.turn.start({ text: 'never mind', turnId: 'p2' })
+  await clock.settle()
+  expect(await band.find({ type: 'Text', text: /Before this plan/ })).toBeUndefined()
+  await band.unmount()
+})
+
 test('model files changed outside the edit tools are found through git, and only what changed this task', async ($, on) => {
   let changed: string[] = ['models/fct_orders.sql']
   const opts = { gitChanged: () => changed, head: { 'models/stg_payments.sql': PAYMENTS_SQL, 'macros/cents.sql': 'x', 'snapshots/orders_snap.sql': 'x' } }
diff --git a/plugins/altimate-code/hooks/task-impact.tsx b/plugins/altimate-code/hooks/task-impact.tsx
index 79716f8..0d0696a 100644
--- a/plugins/altimate-code/hooks/task-impact.tsx
+++ b/plugins/altimate-code/hooks/task-impact.tsx
@@ -1,9 +1,10 @@
 // The end-of-task column impact: what a task changed in its dbt models, how far each changed column's
-// value reaches, as one summary in the band, and a full offline report built when asked for.
+// value reaches, as one summary in the band, and a full offline report built when asked for. When a plan
+// is put up for approval, the models it names, at the model level.
 import { atom, read, update } from 'claude-code'
 import type { EngineInterface, On, RenderElement } from 'claude-code'
 
-import type { TaskSummaryView } from '../types'
+import type { PlanImpactView, TaskSummaryView } from '../types'
 import { later } from './altimate-cli'
 import {
   answerOf,
@@ -15,6 +16,7 @@ import {
   modelLevelOf,
   openersFor,
   type Platform,
+  planLines,
   reportData,
   reportHtml,
   summaryLines,
@@ -22,7 +24,7 @@ import {
   WINDOWS_EXPLORER,
 } from './impact-report'
 import { projectLayout } from './lineage-graph'
-import { openPane, projectRoot, runTool, within } from './lineage'
+import { modelsNamed, openPane, projectRoot, runTool, within } from './lineage'
 
 export const REPORT_COMMAND = 'lineage-report'
 // Under the project's target/, which dbt already keeps out of git.
@@ -43,6 +45,7 @@ const PARALLEL = 4
 const MAX_BAND_LINES = 8
 
 const summaryAtom = atom({ plugin: 'altimate-code', key: 'lineageTaskSummary' } as const, null, { shape: 'lineage-task-summary-1' })
+const planAtom = atom({ plugin: 'altimate-code', key: 'lineagePlanImpact' } as const, null, { shape: 'lineage-plan-impact-1' })
 const hiddenAtom = atom({ plugin: 'altimate-code', key: 'isLineageSummaryHidden' } as const, false)
 
 type Layout = { models: string[] }
@@ -66,6 +69,7 @@ type Finished = {
 let task: Task | null = null
 let finished: Finished | null = null
 let finishSeq = 0
+let planSeq = 0
 
 const newTask = (): Task => ({ roots: new Map(), originals: new Map() })
 const relative = (root: string, path: string) => path.slice(root.length).replace(/^[\\/]+/, '').replace(/\\/g, '/')
@@ -252,6 +256,7 @@ async function finishTask($: EngineInterface, t: Task) {
     openFailed: false,
   }
   await update($, summaryAtom, () => tracing)
+  await update($, planAtom, () => null)
   await update($, hiddenAtom, () => false)
   const done: Finished = { finishedAt: await $.clock.now(), changes, manifests: await freezeManifests($, t, changes), downs: null, full: null }
   const root = changes[0]!.root
@@ -332,6 +337,47 @@ async function buildReport($: EngineInterface, done: Finished): Promise<{ path:
   }
 }
 
+/** The models a plan names and what sits downstream of each, for the person deciding on it. Holds nothing back. */
+async function planReady($: EngineInterface, e: { plan?: unknown; planFilePath?: unknown }) {
+  const seq = ++planSeq
+  // The engine hands the hook the plan's text, though the tool's input type leaves it out; its file is the fallback.
+  const text = typeof e.plan === 'string' && e.plan ? e.plan : await $.fs.read(String(e.planFilePath ?? '')).catch(() => '')
+  if (!text) return
+  const root = await projectRoot($, await $.session.root().catch(() => '.'), false).catch(() => null)
+  if (!root) return
+  const named = (await modelsNamed($, text, root)).filter(one => one.id.startsWith('model.'))
+  if (named.length === 0) return
+  const shown = named.slice(0, MAX_MODELS)
+  const models = shown.map(one => ({ name: one.name, modelLevel: null, tests: null, exposures: null, declared: null, failed: false }))
+  const more = named.length - shown.length
+  const tracing: PlanImpactView = { state: 'tracing', models, more }
+  await update($, planAtom, () => tracing)
+  await update($, hiddenAtom, () => false)
+  const looked = await pool(
+    shown.map(one => async () => {
+      const args = { manifest_path: `${root}/target/manifest.json`, model: one.id, change_type: 'modify', direction: 'downstream' }
+      // Through the CLI: over MCP this could raise a permission dialog on top of the plan's.
+      const result = await runTool($, 'impact_analysis', args, true).catch(() => null)
+      const meta = result?.ok ? (result.metadata as any) : null
+      const consumers = consumersOf(meta)
+      return {
+        name: one.name,
+        modelLevel: modelLevelOf(meta),
+        tests: typeof meta?.test_count === 'number' ? meta.test_count : null,
+        exposures: meta && !consumers.error ? consumers.list.length : null,
+        declared: consumers.declared,
+        failed: modelLevelOf(meta) === null,
+      }
+    }),
+    PARALLEL,
+  )
+  if (seq !== planSeq) return
+  const view: PlanImpactView = { state: 'ready', models: looked, more }
+  await update($, planAtom, () => view)
+  // In the transcript too: the band is not drawn while the approval dialog is up, and this line is.
+  $.ui.log(planLines(view).map(line => line.trim()).join(' · '))
+}
+
 /** Which opener family this machine has: macOS, Linux, WSL (Linux under Windows), or Windows itself. */
 async function platformOf($: EngineInterface): Promise<Platform> {
   // -r too: a WSL kernel's release names Microsoft, with no environment variable needed.
@@ -380,6 +426,7 @@ export async function startTaskImpact($: EngineInterface) {
   task = null
   finished = null
   await update($, summaryAtom, () => null)
+  await update($, planAtom, () => null)
   await $.command.register({
     name: REPORT_COMMAND,
     description: 'Build and open the column impact report of the last task that changed a dbt model: what changed and what it reaches',
@@ -388,14 +435,16 @@ export async function startTaskImpact($: EngineInterface) {
 
 type Ui = { Box: any; Button: any; Text: any; Link?: any }
 
-/** The summary of the last task that changed a model; drawn by the plugin's one band hook. */
+/** The summary of the last task that changed a model, or a plan's models; drawn by the plugin's one band hook. */
 export async function taskBand($: EngineInterface, ui: Ui): Promise<RenderElement | null> {
+  if (await read($, hiddenAtom)) return null
   const view = await read($, summaryAtom)
-  if (!view || (await read($, hiddenAtom))) return null
+  const plan = await read($, planAtom)
+  if (!view && !plan) return null
   const { Box, Button, Link, Text } = ui
-  const lines = summaryLines(view)
+  const lines = view ? summaryLines(view) : planLines(plan!)
   const shown = lines.length > MAX_BAND_LINES ? [...lines.slice(0, MAX_BAND_LINES - 1), `… ${lines.length - MAX_BAND_LINES + 1} more lines in the report`] : lines
-  const report = view.report
+  const report = view?.report ?? null
   return (
     <Box key="lineage-summary" flexDirection="column">
       {shown.map((line, i) => (
@@ -408,14 +457,14 @@ export async function taskBand($: EngineInterface, ui: Ui): Promise<RenderElemen
           {line}
         </Text>
       ))}
-      {view.building ? <Text dimColor>Building the report…</Text> : null}
-      {report && view.openFailed ? (
+      {view?.building ? <Text dimColor>Building the report…</Text> : null}
+      {report && view?.openFailed ? (
         <Text dimColor>
           No browser opened. Report: {Link ? <Link href={`file://${report}`}>{report}</Link> : report}
         </Text>
       ) : null}
       <Box>
-        {view.state === 'ready' ? <Button key="lineage-report-open" label="Open report" onPress={() => later($, async () => void (await buildAndOpen($)))} /> : null}
+        {view?.state === 'ready' ? <Button key="lineage-report-open" label="Open report" onPress={() => later($, async () => void (await buildAndOpen($)))} /> : null}
         <Button key="lineage-open" label="Open lineage" onPress={() => later($, () => openPane($))} />
         <Button key="lineage-summary-dismiss" label="Dismiss" onPress={() => update($, hiddenAtom, () => true)} />
       </Box>
@@ -431,12 +480,15 @@ export async function taskTurnStart($: EngineInterface) {
   const t = newTask()
   task = t
   await update($, summaryAtom, () => null)
+  await update($, planAtom, () => null)
   const own = await projectRoot($, await $.session.root().catch(() => '.'), false).catch(() => null)
   if (own) await within($, 20_000, prepareRoot($, t, own))
 }
 
 /** Before an edit lands: the model file's text as it was, the first time the task touches it. */
 export async function taskBeforeTool($: EngineInterface, e: any) {
+  // A plan is about to go up for approval: `next(e)` is what opens the dialog, and this does not hold it.
+  if (e.tool === 'ExitPlanMode' && !e.agentId) later($, () => planReady($, e).catch(error => $.ui.log(`lineage-summary · plan: ${String(error)}`, { to: 'debug' })))
   const file = EDIT_TOOLS.has(e.tool) && 'file_path' in e ? String(e.file_path) : null
   if (!file || !/\.sql$/i.test(file)) return
   const t = (task ??= newTask())
diff --git a/plugins/altimate-code/types/index.d.ts b/plugins/altimate-code/types/index.d.ts
index bdaf02f..574c411 100644
--- a/plugins/altimate-code/types/index.d.ts
+++ b/plugins/altimate-code/types/index.d.ts
@@ -202,6 +202,14 @@ export type TaskSummaryView = {
   openFailed: boolean
 }
 
+/** What the band shows for a plan: the models it names, at the model level. */
+export type PlanImpactView = {
+  state: 'tracing' | 'ready'
+  models: { name: string; modelLevel: number | null; tests: number | null; exposures: number | null; declared: number | null; failed: boolean }[]
+  /** Models the plan names past the ones looked up. */
+  more: number
+}
+
 declare module 'claude-code' {
   interface PluginState {
     'altimate-code': {
@@ -241,6 +249,7 @@ declare module 'claude-code' {
       lineageLoading: boolean
       /** The end-of-task column impact summary the band shows; null until a task changes a model. */
       lineageTaskSummary: Shaped<TaskSummaryView | null>
+      lineagePlanImpact: Shaped<PlanImpactView | null>
       isLineageSummaryHidden: boolean
     }
   }

From 86773830db956f15ac4e94b3b6cdfacc57e7d026 Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Fri, 6 Nov 2026 14:13:56 +0800
Subject: [PATCH 10/21] fix: the report's consumers note and path hint say what
 is true

"Nothing is hidden" sat beside a bar counting columns on hidden levels, and the note opened with "from the exposures" when there are none.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YNQjkaiykbC1WtASw6Yegs
---
 plugins/altimate-code/hooks/impact-report.test.ts | 2 +-
 plugins/altimate-code/hooks/impact-report.ts      | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/plugins/altimate-code/hooks/impact-report.test.ts b/plugins/altimate-code/hooks/impact-report.test.ts
index 3efe186..47b0ec9 100644
--- a/plugins/altimate-code/hooks/impact-report.test.ts
+++ b/plugins/altimate-code/hooks/impact-report.test.ts
@@ -235,7 +235,7 @@ describe('consumers', () => {
     const none = reportHtml(reportData([CHANGE], [{ ...TRACE, consumers: consumersOf({ exposures_declared: 0, exposures: [] }) }], TASK))
     expect(embedded(none).consumers).toEqual({ declared: 0, error: null, list: [] })
     expect(none).toContain('This dbt project declares no exposures')
-    expect(none).toContain('Anything not declared, such as other BI tools or backend services, is not listed.')
+    expect(none).toContain('Only exposures a dbt project declares can appear here: other BI tools and backend services do not.')
   })
 })
 
diff --git a/plugins/altimate-code/hooks/impact-report.ts b/plugins/altimate-code/hooks/impact-report.ts
index 805a82f..da8c2e5 100644
--- a/plugins/altimate-code/hooks/impact-report.ts
+++ b/plugins/altimate-code/hooks/impact-report.ts
@@ -661,7 +661,7 @@ function consumersPanel(){var c=DATA.consumers,p=el('div','panel consumers');p.a
   else if(c.declared===0)p.appendChild(el('div','empty','This dbt project declares no exposures, so no dashboards or other consumers can be named. That does not mean nothing reads these tables.'));
   else if(!c.list.length)p.appendChild(el('div','empty','This dbt project declares '+plural(c.declared,'exposure')+', but none reads this model or anything downstream of it.'));
   TIERS.forEach(function(t){var mine=c.list.filter(function(x){return x.tier===t[0]});if(!mine.length)return;p.appendChild(el('div','tier',t[1]+' ('+mine.length+')'));var ul=el('ul');mine.forEach(function(x){ul.appendChild(consumerItem(x))});p.appendChild(ul)});
-  p.appendChild(el('p','foot','From the exposures this dbt project declares'+(c.list.length?'. dbt records which models an exposure reads, not which columns, so each may or may not use this one':'')+'. Anything not declared, such as other BI tools or backend services, is not listed.'));return p}
+  p.appendChild(el('p','foot',(c.list.length?'dbt records which models an exposure reads, not which columns, so each may or may not use this one. ':'')+'Only exposures a dbt project declares can appear here: other BI tools and backend services do not.'));return p}
 function render(){
   var f=DATA.focuses[state.focus],i=state.focus;app.textContent='';
   var bar=el('div','pathbar');bar.id='pathbar';var wrap=el('div','wrap');wrap.appendChild(bar);
@@ -669,7 +669,7 @@ function render(){
   if(DATA.movedOn.length)wrap.appendChild(el('div','note warn','\\u26a0 Since this task ended, '+DATA.movedOn.join(', ')+(DATA.movedOn.length===1?' has':' have')+' changed. This report describes the task, not the files as they are now.'));
   var ch=el('div','panel changes');ch.appendChild(el('h2',null,'What this task changed'));DATA.changes.forEach(function(c){var m=el('div','change-model mono',c.model);m.appendChild(el('span','file',c.file));ch.appendChild(m);if(!c.columns.length){ch.appendChild(el('div','empty','No output column changed (a filter or a join): only the model-level count applies.'));return}var d=el('div','diff');c.columns.forEach(function(col){d.appendChild(el('div','col-name mono',col.name));var was=el('div','was mono'+(col.before?'':' none'),col.before||'(not in the model before)');var now=el('div','now mono'+(col.after?'':' none'),col.after||'(removed)');if(col.before&&col.after&&col.before===col.after){d.appendChild(el('div','same','Expression unchanged; the column is named on a changed line.'));d.appendChild(el('div'))}else{d.appendChild(was);d.appendChild(now)}});ch.appendChild(d)});wrap.appendChild(ch);
   wrap.appendChild(impactPanel());wrap.appendChild(consumersPanel());
-  var deep=el('div','deep');deep.appendChild(el('h2',null,'Column by column'));deep.appendChild(el('p',null,'Two levels up and down, with more on request. Click any column to light up its path; nothing is hidden.'));wrap.appendChild(deep);
+  var deep=el('div','deep');deep.appendChild(el('h2',null,'Column by column'));deep.appendChild(el('p',null,'Two levels up and down, with more on request. Click any column to light up its path; the rest dims and stays on the page.'));wrap.appendChild(deep);
   if(DATA.focuses.length>1){var tabs=el('div','tabs');tabs.setAttribute('role','tablist');DATA.focuses.forEach(function(g,j){var t=el('button','tab',g.column?g.model+'.'+g.column:g.model+' (model)');t.type='button';t.setAttribute('role','tab');t.setAttribute('aria-selected',j===i?'true':'false');t.addEventListener('click',function(){state.focus=j;state.selected=null;render()});tabs.appendChild(t)});wrap.appendChild(tabs)}
   var r=f.reach,stats=el('div','stats');
   if(r){stats.appendChild(stat(r.columns,'columns downstream'));stats.appendChild(stat(r.models,'models carry it'));stats.appendChild(stat(r.ends,'end columns'));stats.appendChild(stat(r.mayCarry,'may carry it',!r.mayCarry));stats.appendChild(stat(r.cleared,'cleared',r.cleared==null))}

From 31512d380192f23684e1f1f505c90acbb2d07bf6 Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Wed, 11 Nov 2026 13:57:18 +0800
Subject: [PATCH 11/21] feat: column graph beside the summary on the lineage
 report

- The report draws the column lineage as a graph: upstream left, downstream right, opened to fit, with zoom and pan.
- A column click lights its path; "more levels" adds one; a level over 12 models folds into one box.
- The page allows only its own inline script and style.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VEmKQwEiHMwQ7BdwgPo9sb
---
 .../altimate-code/hooks/impact-report.test.ts |   2 +-
 plugins/altimate-code/hooks/impact-report.ts  |  46 ++--
 .../altimate-code/hooks/report-graph.test.ts  | 115 ++++++++++
 plugins/altimate-code/hooks/report-graph.ts   | 208 ++++++++++++++++++
 4 files changed, 351 insertions(+), 20 deletions(-)
 create mode 100644 plugins/altimate-code/hooks/report-graph.test.ts
 create mode 100644 plugins/altimate-code/hooks/report-graph.ts

diff --git a/plugins/altimate-code/hooks/impact-report.test.ts b/plugins/altimate-code/hooks/impact-report.test.ts
index 47b0ec9..6e6e51c 100644
--- a/plugins/altimate-code/hooks/impact-report.test.ts
+++ b/plugins/altimate-code/hooks/impact-report.test.ts
@@ -260,7 +260,7 @@ describe('a plan', () => {
 describe('the report', () => {
   test('leads with what changed and what to expect, and keeps the levels and paths underneath', () => {
     const html = reportHtml(reportData([{ ...CHANGE, ended: fingerprint('x') }], [TRACE], { ...TASK, movedOn: ['models/fct_orders.sql'] }))
-    const order = ['What this task changed', 'wrap.appendChild(impactPanel())', 'wrap.appendChild(consumersPanel())', 'Column by column', "section(f,i,'up')", "section(f,i,'down')"].map(one => html.indexOf(one, html.indexOf('function render(){')))
+    const order = ['What this task changed', 'side.appendChild(impactPanel())', 'side.appendChild(consumersPanel())', 'Column by column', 'graph=graphPanel(f,i)', "section(f,i,'up')", "section(f,i,'down')"].map(one => html.indexOf(one, html.indexOf('function render(){')))
     expect(order.every(one => one >= 0)).toBe(true)
     expect([...order].sort((a, b) => a - b)).toEqual(order)
     const data = embedded(html)
diff --git a/plugins/altimate-code/hooks/impact-report.ts b/plugins/altimate-code/hooks/impact-report.ts
index da8c2e5..f389dfd 100644
--- a/plugins/altimate-code/hooks/impact-report.ts
+++ b/plugins/altimate-code/hooks/impact-report.ts
@@ -2,6 +2,7 @@
 // and a self-contained HTML report. Pure functions only; the hooks live in task-impact.tsx.
 
 import type { PlanImpactView, Reach, TaskSummaryView } from '../types'
+import { GRAPH_CSS, GRAPH_VIEW_JS, graphLayout } from './report-graph'
 import { selectItems, touchedColumns } from './lineage-graph'
 
 export type { PlanImpactView, Reach, TaskSummaryView }
@@ -494,9 +495,10 @@ export function reportHtml(data: ReportData): string {
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <meta name="color-scheme" content="light dark">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data:">
 <link rel="icon" href="data:,">
 <title>${escapeHtml(data.title)}</title>
-<style>${REPORT_CSS}</style>
+<style>${REPORT_CSS}${GRAPH_CSS}</style>
 </head>
 <body>
 <div id="app" data-levels="${data.defaultLevels}"></div>
@@ -636,8 +638,8 @@ var DATA=JSON.parse(document.getElementById('report-data').textContent);
 var app=document.getElementById('app');
 var GLYPH={'=':'same','~':'ren','\\u0192':'calc','\\u03a3':'agg','?':'unk'};
 var HOW={'=':'same value','~':'renamed','\\u0192':'calculated','\\u03a3':'aggregated','?':'unknown'};
-var state={focus:0,levels:[],selected:null};
-DATA.focuses.forEach(function(){state.levels.push({up:DATA.defaultLevels,down:DATA.defaultLevels})});
+var state={focus:0,levels:[],expanded:[],views:[],list:false,selected:null};
+DATA.focuses.forEach(function(){state.levels.push({up:DATA.defaultLevels,down:DATA.defaultLevels});state.expanded.push({});state.views.push(null)});
 function el(tag,cls,text){var n=document.createElement(tag);if(cls)n.className=cls;if(text!=null)n.textContent=String(text);return n}
 function plural(n,w){return n+' '+w+(n===1?'':'s')}
 function glyph(g,byName){var s=el('span','g '+(GLYPH[g]||'unk')+(byName?' byname':''),g||'?');s.title=(HOW[g]||'unknown')+(byName?' (matched by name, not traced through SQL)':'');return s}
@@ -667,31 +669,37 @@ function render(){
   var bar=el('div','pathbar');bar.id='pathbar';var wrap=el('div','wrap');wrap.appendChild(bar);
   var top=el('header','top');top.appendChild(el('h1',null,DATA.title));top.appendChild(el('span','when','Task finished '+DATA.finishedAt+' \\u00b7 report built '+DATA.builtAt+' \\u00b7 read from '+DATA.manifest));wrap.appendChild(top);
   if(DATA.movedOn.length)wrap.appendChild(el('div','note warn','\\u26a0 Since this task ended, '+DATA.movedOn.join(', ')+(DATA.movedOn.length===1?' has':' have')+' changed. This report describes the task, not the files as they are now.'));
-  var ch=el('div','panel changes');ch.appendChild(el('h2',null,'What this task changed'));DATA.changes.forEach(function(c){var m=el('div','change-model mono',c.model);m.appendChild(el('span','file',c.file));ch.appendChild(m);if(!c.columns.length){ch.appendChild(el('div','empty','No output column changed (a filter or a join): only the model-level count applies.'));return}var d=el('div','diff');c.columns.forEach(function(col){d.appendChild(el('div','col-name mono',col.name));var was=el('div','was mono'+(col.before?'':' none'),col.before||'(not in the model before)');var now=el('div','now mono'+(col.after?'':' none'),col.after||'(removed)');if(col.before&&col.after&&col.before===col.after){d.appendChild(el('div','same','Expression unchanged; the column is named on a changed line.'));d.appendChild(el('div'))}else{d.appendChild(was);d.appendChild(now)}});ch.appendChild(d)});wrap.appendChild(ch);
-  wrap.appendChild(impactPanel());wrap.appendChild(consumersPanel());
-  var deep=el('div','deep');deep.appendChild(el('h2',null,'Column by column'));deep.appendChild(el('p',null,'Two levels up and down, with more on request. Click any column to light up its path; the rest dims and stays on the page.'));wrap.appendChild(deep);
-  if(DATA.focuses.length>1){var tabs=el('div','tabs');tabs.setAttribute('role','tablist');DATA.focuses.forEach(function(g,j){var t=el('button','tab',g.column?g.model+'.'+g.column:g.model+' (model)');t.type='button';t.setAttribute('role','tab');t.setAttribute('aria-selected',j===i?'true':'false');t.addEventListener('click',function(){state.focus=j;state.selected=null;render()});tabs.appendChild(t)});wrap.appendChild(tabs)}
+  var ch=el('div','panel changes');ch.appendChild(el('h2',null,'What this task changed'));DATA.changes.forEach(function(c){var m=el('div','change-model mono',c.model);m.appendChild(el('span','file',c.file));ch.appendChild(m);if(!c.columns.length){ch.appendChild(el('div','empty','No output column changed (a filter or a join): only the model-level count applies.'));return}var d=el('div','diff');c.columns.forEach(function(col){d.appendChild(el('div','col-name mono',col.name));var was=el('div','was mono'+(col.before?'':' none'),col.before||'(not in the model before)');var now=el('div','now mono'+(col.after?'':' none'),col.after||'(removed)');if(col.before&&col.after&&col.before===col.after){d.appendChild(el('div','same','Expression unchanged; the column is named on a changed line.'));d.appendChild(el('div'))}else{d.appendChild(was);d.appendChild(now)}});ch.appendChild(d)});
+  var page=el('div','page'),side=el('div','side'),main=el('div','main');page.appendChild(side);page.appendChild(main);
+  side.appendChild(ch);side.appendChild(impactPanel());side.appendChild(consumersPanel());
+  var deep=el('div','deep');deep.appendChild(el('h2',null,'Column by column'));deep.appendChild(el('p',null,'Two levels up and down, with more on request. Click any column to light up its path; the rest dims and stays on the page.'));main.appendChild(deep);
+  if(DATA.focuses.length>1){var tabs=el('div','tabs');tabs.setAttribute('role','tablist');DATA.focuses.forEach(function(g,j){var t=el('button','tab',g.column?g.model+'.'+g.column:g.model+' (model)');t.type='button';t.setAttribute('role','tab');t.setAttribute('aria-selected',j===i?'true':'false');t.addEventListener('click',function(){state.focus=j;state.selected=null;render()});tabs.appendChild(t)});main.appendChild(tabs)}
   var r=f.reach,stats=el('div','stats');
   if(r){stats.appendChild(stat(r.columns,'columns downstream'));stats.appendChild(stat(r.models,'models carry it'));stats.appendChild(stat(r.ends,'end columns'));stats.appendChild(stat(r.mayCarry,'may carry it',!r.mayCarry));stats.appendChild(stat(r.cleared,'cleared',r.cleared==null))}
-  stats.appendChild(stat(f.modelLevel,'downstream at model level',true));wrap.appendChild(stats);
-  if(r&&(r.unresolved||r.truncated))wrap.appendChild(el('div','note warn','\\u26a0 Lower bound: '+[r.unresolved?plural(r.unresolved,'model')+' could not be read':'',r.truncated?'the trace hit its limit':''].filter(Boolean).join('; ')+'. See \\u201cNot resolved\\u201d below.'));
-  else if(r)wrap.appendChild(el('div','note ok','\\u2713 Every downstream model was read.'));
-  var inp=[];if(f.inputs.engine)inp.push('engine '+f.inputs.engine);inp.push(f.inputs.catalog?'with catalog types':'no catalog: types from the manifest');if(f.inputs.olderThanSql)inp.push('the manifest is older than the SQL');wrap.appendChild(el('div','inputs',inp.join(' \\u00b7 ')));
-  var lg=el('div','legend');['=','~','\\u0192','\\u03a3','?'].forEach(function(g){var s=el('span');s.appendChild(glyph(g,false));s.appendChild(document.createTextNode(HOW[g]));lg.appendChild(s)});var bn=el('span');bn.appendChild(glyph('=',true));bn.appendChild(document.createTextNode('matched by name'));lg.appendChild(bn);var cb=el('span');cb.appendChild(el('span','badge c','C'));cb.appendChild(document.createTextNode(' contract enforced'));lg.appendChild(cb);wrap.appendChild(lg);
-  wrap.appendChild(section(f,i,'up'));
-  var fc=el('div','panel focus');fc.appendChild(el('div','label','The changed column'));var ti=el('div','title');if(f.key){ti.appendChild(colButton({key:f.key,column:f.model+'.'+(f.column||''),glyph:f.glyph||'?',byName:f.byName,end:false,type:null}))}else ti.appendChild(el('span','mono',f.column?f.model+'.'+f.column:f.model));fc.appendChild(ti);var hw=f.glyph?HOW[f.glyph]||'unknown':'';fc.appendChild(el('div','empty',(hw?hw.charAt(0).toUpperCase()+hw.slice(1)+' from what it reads'+(f.byName?' (matched by name)':'')+'. ':'')+(f.key?'Click any column to light up its path.':'')));wrap.appendChild(fc);
-  wrap.appendChild(section(f,i,'down'));
+  stats.appendChild(stat(f.modelLevel,'downstream at model level',true));main.appendChild(stats);
+  if(r&&(r.unresolved||r.truncated))main.appendChild(el('div','note warn','\\u26a0 Lower bound: '+[r.unresolved?plural(r.unresolved,'model')+' could not be read':'',r.truncated?'the trace hit its limit':''].filter(Boolean).join('; ')+'. See \\u201cNot resolved\\u201d below.'));
+  else if(r)main.appendChild(el('div','note ok','\\u2713 Every downstream model was read.'));
+  var inp=[];if(f.inputs.engine)inp.push('engine '+f.inputs.engine);inp.push(f.inputs.catalog?'with catalog types':'no catalog: types from the manifest');if(f.inputs.olderThanSql)inp.push('the manifest is older than the SQL');main.appendChild(el('div','inputs',inp.join(' \\u00b7 ')));
+  var lg=el('div','legend');['=','~','\\u0192','\\u03a3','?'].forEach(function(g){var s=el('span');s.appendChild(glyph(g,false));s.appendChild(document.createTextNode(HOW[g]));lg.appendChild(s)});var bn=el('span');bn.appendChild(glyph('=',true));bn.appendChild(document.createTextNode('matched by name'));lg.appendChild(bn);var cb=el('span');cb.appendChild(el('span','badge c','C'));cb.appendChild(document.createTextNode(' contract enforced'));lg.appendChild(cb);main.appendChild(lg);
+  var graph=null;if(!state.list){graph=graphPanel(f,i);main.appendChild(graph)}else{var lb=el('div','g-bar list-bar');lb.appendChild(el('span','g-title','Column list'));var gb=el('button','g-btn','Graph');gb.type='button';gb.addEventListener('click',function(){state.list=false;render()});lb.appendChild(gb);main.appendChild(lb);
+  main.appendChild(section(f,i,'up'));
+  var fc=el('div','panel focus');fc.appendChild(el('div','label','The changed column'));var ti=el('div','title');if(f.key){ti.appendChild(colButton({key:f.key,column:f.model+'.'+(f.column||''),glyph:f.glyph||'?',byName:f.byName,end:false,type:null}))}else ti.appendChild(el('span','mono',f.column?f.model+'.'+f.column:f.model));fc.appendChild(ti);var hw=f.glyph?HOW[f.glyph]||'unknown':'';fc.appendChild(el('div','empty',(hw?hw.charAt(0).toUpperCase()+hw.slice(1)+' from what it reads'+(f.byName?' (matched by name)':'')+'. ':'')+(f.key?'Click any column to light up its path.':'')));main.appendChild(fc);
+  main.appendChild(section(f,i,'down'))}
+  wrap.appendChild(page);
   wrap.appendChild(fold('Also reads it, outside the select',f.alsoReads.length,f.alsoReads.map(function(a){return li(a.name,'reads '+a.columns.join(', ')+(a.downstream!=null?' \\u00b7 '+plural(a.downstream,'model')+' downstream of it':''))})));
   wrap.appendChild(fold('Not resolved',f.unresolved.length,f.unresolved.map(function(u){return li(u.name,u.reason+(u.downstream!=null?' \\u00b7 '+plural(u.downstream,'model')+' downstream of it':''))})));
   wrap.appendChild(fold('Cleared: downstream, but does not carry it',f.cleared.count,f.cleared.names.map(function(n){return li(n,'')})));
   if(f.inputs.workarounds.length)wrap.appendChild(fold('How the engine read the SQL',f.inputs.workarounds.length,f.inputs.workarounds.map(function(w){var l=el('li','why',w);return l})));
-  app.appendChild(wrap);applyHighlight();
+  app.appendChild(wrap);if(graph)graph.afterMount();applyHighlight();
 }
 function select(key){state.selected=state.selected===key?null:key;applyHighlight()}
-function applyHighlight(){var f=DATA.focuses[state.focus],bar=document.getElementById('pathbar');var cols=document.querySelectorAll('.col');if(!state.selected){document.body.classList.remove('hl');cols.forEach(function(c){c.classList.remove('on','sel')});document.querySelectorAll('.model').forEach(function(m){m.classList.remove('has-on')});return}
-  var p=pathOf(f,state.selected);document.body.classList.add('hl');cols.forEach(function(c){var on=!!p.all[c.dataset.key];c.classList.toggle('on',on);c.classList.toggle('sel',c.dataset.key===state.selected)});document.querySelectorAll('.model').forEach(function(m){m.classList.toggle('has-on',!!m.querySelector('.col.on'))});
+function applyHighlight(){var f=DATA.focuses[state.focus],bar=document.getElementById('pathbar');var cols=document.querySelectorAll('.col,.g-row');var edges=document.querySelectorAll('.g-edge');if(!state.selected){document.body.classList.remove('hl');cols.forEach(function(c){c.classList.remove('on','sel')});edges.forEach(function(e){e.classList.remove('on')});document.querySelectorAll('.model,.g-box').forEach(function(m){m.classList.remove('has-on')});bar.textContent='';return}
+  var p=pathOf(f,state.selected);document.body.classList.add('hl');cols.forEach(function(c){var on=!!p.all[c.dataset.key];c.classList.toggle('on',on);c.classList.toggle('sel',c.dataset.key===state.selected)});document.querySelectorAll('.model,.g-box').forEach(function(m){m.classList.toggle('has-on',!!m.querySelector('.col.on,.g-row.on'))});
+  edges.forEach(function(e){var on=(e.getAttribute('data-keys')||'').split(' ').some(function(k){var ab=k.split('>');return !!(p.all[ab[0]]&&p.all[ab[1]])});e.classList.toggle('on',on)});
   var shown={};cols.forEach(function(c){shown[c.dataset.key]=1});var hidden=Object.keys(p.all).filter(function(k){return!shown[k]}).length;
-  bar.textContent='';bar.appendChild(el('span',null,'Path of '+state.selected.split('|')[0].split('.').pop()+'.'+state.selected.split('|').pop()+': '+plural(p.up,'column')+' upstream, '+plural(p.down,'column')+' downstream'+(hidden?' \\u00b7 '+hidden+' more on hidden levels':'')));var clr=el('button',null,'Clear');clr.type='button';clr.addEventListener('click',function(){select(state.selected)});bar.appendChild(clr)}
+  bar.textContent='';bar.appendChild(el('span',null,'Path of '+state.selected.split('|')[0].split('.').pop()+'.'+state.selected.split('|').pop()+': '+plural(p.up,'column')+' upstream, '+plural(p.down,'column')+' downstream'+(hidden?' \\u00b7 '+hidden+' more on hidden levels or folded models':'')));var clr=el('button',null,'Clear');clr.type='button';clr.addEventListener('click',function(){select(state.selected)});bar.appendChild(clr)}
+${graphLayout.toString()}
+${GRAPH_VIEW_JS}
 document.addEventListener('keydown',function(e){if(e.key==='Escape'&&state.selected)select(state.selected)});
 render();
 })();
diff --git a/plugins/altimate-code/hooks/report-graph.test.ts b/plugins/altimate-code/hooks/report-graph.test.ts
new file mode 100644
index 0000000..90cb201
--- /dev/null
+++ b/plugins/altimate-code/hooks/report-graph.test.ts
@@ -0,0 +1,115 @@
+import { describe, expect, test } from 'claude-code/testing'
+import { graphLayout as layoutOf } from './report-graph'
+import { type ColumnAnswer, type ModelChange, reportData, reportHtml } from './impact-report'
+
+type Layout = {
+  boxes: { id: string; layer: number; x: number; y: number; h: number; name: string; title: string; collapsed?: boolean; count?: number; rows: { key: string }[] }[]
+  edges: { from: string; to: string; keys: string[][] }[]
+}
+const graphLayout = layoutOf as (focus: unknown, levels: { up: number; down: number }, expanded: Record<number, boolean>) => Layout
+
+const node = (name: string) => ({ id: `model.shop.${name}`, name, folder: 'marts', materialized: 'table', contract: false, tests: 0, exposures: [] })
+
+/** fct.revenue read by `first` models one hop down, each read by the model `second` names, if any. */
+function answer(first: string[], second: Record<string, string> = {}): ColumnAnswer {
+  const names = ['fct', ...first, ...Object.values(second)]
+  const nodes = names.map(node)
+  const columns: any[] = [{ model: 0, column: 'revenue', hop: 0 }]
+  const edges: any[] = []
+  first.forEach(name => {
+    columns.push({ model: names.indexOf(name), column: 'revenue', hop: 1 })
+    edges.push([0, columns.length - 1, '='])
+  })
+  for (const [from, to] of Object.entries(second)) {
+    columns.push({ model: names.indexOf(to), column: 'total', hop: 2, end: true })
+    edges.push([1 + first.indexOf(from), columns.length - 1, 'Σ'])
+  }
+  return {
+    version: 1,
+    focus: { model: 'model.shop.fct', column: 'revenue' },
+    direction: 'downstream',
+    counts: { columns: columns.length - 1, models: names.length - 1, hops: 2, contracts: 0, ends: 1, may_carry_models: 0, cleared_models: 0, model_level: names.length - 1 },
+    nodes,
+    columns,
+    edges,
+  } as ColumnAnswer
+}
+const UP = {
+  version: 1,
+  focus: { model: 'model.shop.fct', column: 'revenue' },
+  direction: 'upstream',
+  nodes: [node('fct'), node('stg_orders'), { ...node('orders'), id: 'source.shop.raw.orders' }],
+  columns: [
+    { model: 0, column: 'revenue', hop: 0 },
+    { model: 1, column: 'amount', hop: 1 },
+    { model: 2, column: 'amount_cents', hop: 2, end: true },
+  ],
+  edges: [
+    [1, 0, '~'],
+    [2, 1, 'ƒ'],
+  ],
+} as ColumnAnswer
+const CHANGE: ModelChange = { model: 'fct', file: 'models/fct.sql', root: '/repo', columns: [{ name: 'revenue', before: 'amount as revenue', after: 'amount * 1.1 as revenue' }] }
+const TASK = { finishedAt: '2026-01-01 00:00 UTC', builtAt: '2026-01-01 00:05 UTC', manifest: 'the manifest', movedOn: [] as string[] }
+const focusOf = (down: ColumnAnswer, up: ColumnAnswer | null = UP) =>
+  reportData([CHANGE], [{ model: 'fct', column: 'revenue', down, up, modelLevel: null, failed: false }], TASK).focuses[0]
+const layer = (lay: Layout, n: number) => lay.boxes.filter(box => box.layer === n)
+
+describe('report graph layout', () => {
+  test('upstream sits left of the changed column and downstream right, one layer per hop shown', () => {
+    const lay = graphLayout(focusOf(answer(['a', 'b'], { a: 'x' })), { up: 2, down: 2 }, {})
+    expect(layer(lay, 0).map(box => box.name)).toEqual(['fct'])
+    expect(layer(lay, 0)[0]!.x).toBe(0)
+    expect(layer(lay, 1).every(box => box.x > 0)).toBe(true)
+    expect(layer(lay, 2).every(box => box.x > layer(lay, 1)[0]!.x)).toBe(true)
+    expect(layer(lay, -1).map(box => box.name)).toEqual(['stg_orders'])
+    expect(layer(lay, -2).every(box => box.x < layer(lay, -1)[0]!.x)).toBe(true)
+    const fewer = graphLayout(focusOf(answer(['a', 'b'], { a: 'x' })), { up: 1, down: 1 }, {})
+    expect([...new Set(fewer.boxes.map(box => box.layer))].sort()).toEqual([-1, 0, 1])
+    expect(fewer.edges.map(edge => `${edge.from}>${edge.to}`).sort()).toEqual([
+      'model.shop.fct|revenue>model.shop.a|revenue',
+      'model.shop.fct|revenue>model.shop.b|revenue',
+      'model.shop.stg_orders|amount>model.shop.fct|revenue',
+    ])
+  })
+
+  test('a level of more than 12 models is one box, with one edge into it, until it is expanded', () => {
+    const many = Array.from({ length: 20 }, (_, i) => `m${String(i).padStart(2, '0')}`)
+    const focus = focusOf(answer(many))
+    const folded = graphLayout(focus, { up: 2, down: 2 }, {})
+    expect(layer(folded, 1).map(box => [box.name, box.collapsed, box.count])).toEqual([['+20 models', true, 20]])
+    const into = folded.edges.filter(edge => edge.from === 'model.shop.fct|revenue')
+    expect(into.length).toBe(1)
+    expect(into[0]!.keys.length).toBe(20)
+    const open = graphLayout(focus, { up: 2, down: 2 }, { 1: true })
+    expect(layer(open, 1).length).toBe(20)
+    expect(open.edges.filter(edge => edge.from === 'model.shop.fct|revenue').length).toBe(20)
+  })
+
+  test("orders a layer by where its edges come from, whatever the data's order", () => {
+    // a above b by name; z reads a and y reads b, so z sits above y although y comes first by name.
+    const down = answer(['a', 'b'], { a: 'z', b: 'y' })
+    const lay = graphLayout(focusOf(down), { up: 2, down: 2 }, {})
+    expect(layer(lay, 1).map(box => box.name)).toEqual(['a', 'b'])
+    expect(layer(lay, 2).map(box => box.name)).toEqual(['z', 'y'])
+    const shuffled = { ...down, nodes: [...down.nodes!].reverse(), columns: down.columns!.map(c => ({ ...c, model: down.nodes!.length - 1 - c.model })) }
+    expect(graphLayout(focusOf(shuffled as ColumnAnswer), { up: 2, down: 2 }, {})).toEqual(lay)
+  })
+
+  test('cuts a long model name and keeps the whole name in its title', () => {
+    const long = 'int_query_cost_attribution_by_warehouse_and_hour'
+    const box = layer(graphLayout(focusOf(answer([long])), { up: 0, down: 1 }, {}), 1)[0]!
+    expect(box.name).toBe(`${long.slice(0, 27)}…`)
+    expect(box.title.startsWith(long)).toBe(true)
+  })
+})
+
+describe('report page', () => {
+  test('allows only its own inline script and style, and carries the graph', () => {
+    const html = reportHtml(reportData([CHANGE], [{ model: 'fct', column: 'revenue', down: answer(['a']), up: UP, modelLevel: null, failed: false }], TASK))
+    expect(html).toContain(`<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data:">`)
+    expect(html).toContain('function graphLayout(')
+    expect(html).toContain('function graphPanel(')
+    expect(html).not.toMatch(/<script[^>]+src=|<link[^>]+stylesheet|@import|url\(http/)
+  })
+})
diff --git a/plugins/altimate-code/hooks/report-graph.ts b/plugins/altimate-code/hooks/report-graph.ts
new file mode 100644
index 0000000..0d26530
--- /dev/null
+++ b/plugins/altimate-code/hooks/report-graph.ts
@@ -0,0 +1,208 @@
+// The column graph on the lineage report page: a layered layout (one layer per hop, upstream on the
+// left, the changed column in the middle, downstream on the right) drawn as plain SVG, with zoom and
+// pan. Both run in the page, which stays one offline file. The layout is a pure function of the
+// report data, tested here and sent to the page as its own source, so the same data always draws
+// the same graph.
+
+/**
+ * `graphLayout(focus, levels, expanded)`: boxes, rows and edges with their coordinates.
+ * - `focus`: one ReportFocus; `levels`: `{ up, down }` hops to show; `expanded`: layers drawn in full.
+ * - A layer with more than 12 models is one box ("+N models") unless expanded.
+ * - Each layer is ordered by where its edges meet the layer before it (toward the changed column),
+ *   then by name, so edges cross less and the order never depends on the data's order.
+ *
+ * The page runs this function's own source (`graphLayout.toString()`), so it uses nothing from
+ * outside its body but the language's built-ins.
+ */
+export function graphLayout(f: any, levels: { up: number; down: number }, expanded: Record<number, boolean>): any {
+  var G = { boxW: 236, headH: 30, rowH: 20, pad: 8, gapX: 92, gapY: 14, maxModels: 12, maxName: 28, maxColumn: 24 }
+  var layers: any = {}, order: number[] = [0], boxes: any[] = [], at: any = {}, edges: any[] = [], seen: any = {}
+  function cut(s: unknown, n: number) { var t = String(s); return t.length > n ? t.slice(0, n - 1) + '…' : t }
+  function r1(n: number) { return Math.round(n * 10) / 10 }
+  var fk = f.key, fid = fk ? fk.slice(0, fk.lastIndexOf('|')) : f.model
+  layers[0] = [{ id: fid, name: f.model, folder: '', materialized: '', contract: false, tests: 0, exposures: [], flags: [], focus: true,
+    columns: fk ? [{ key: fk, column: f.column || '', glyph: f.glyph || '?', byName: !!f.byName, end: false, type: null, hop: 0 }] : [] }]
+  ;((f.up && f.up.hops) || []).forEach(function (h: any) { if (h.hop >= 1 && h.hop <= levels.up) { layers[-h.hop] = h.models; order.push(-h.hop) } })
+  ;((f.down && f.down.hops) || []).forEach(function (h: any) { if (h.hop >= 1 && h.hop <= levels.down) { layers[h.hop] = h.models; order.push(h.hop) } })
+  // Outward from the changed column: 0, 1, 2, ... then -1, -2, ...
+  order.sort(function (a, b) { return Number(a < 0) - Number(b < 0) || Math.abs(a) - Math.abs(b) })
+  var inn: any = {}, out: any = {}
+  ;(f.edges || []).forEach(function (e: any) { (inn[e[1]] = inn[e[1]] || []).push(e[0]); (out[e[0]] = out[e[0]] || []).push(e[1]) })
+  function bary(keys: string[], L: number) {
+    var ys: number[] = []
+    keys.forEach(function (k) { ((L > 0 ? inn[k] : out[k]) || []).forEach(function (o: string) { if (at[o]) ys.push(at[o].y) }) })
+    return ys.length ? ys.reduce(function (s, y) { return s + y }, 0) / ys.length : null
+  }
+  function cmp(a: any, b: any) {
+    if (a.b === null && b.b !== null) return 1
+    if (b.b === null && a.b !== null) return -1
+    return (a.b === null ? 0 : a.b - b.b) || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
+  }
+  order.forEach(function (L) {
+    var models: any[] = layers[L] || [], x = L * (G.boxW + G.gapX), items: any[]
+    if (L !== 0 && models.length > G.maxModels && !expanded[L]) {
+      var keys: string[] = []
+      models.forEach(function (m) { m.columns.forEach(function (c: any) { keys.push(c.key) }) })
+      items = [{ collapsed: true, id: '+' + L, name: '+' + models.length + ' models', count: models.length, columns: keys.length, keys: keys, b: bary(keys, L) }]
+    } else items = models.map(function (m) {
+      var rows = m.columns.map(function (c: any) { return { c: c, b: bary([c.key], L), name: String(c.column), id: c.key } }).sort(cmp)
+      return { model: m, id: m.id, name: String(m.name), rows: rows, b: bary(m.columns.map(function (c: any) { return c.key }), L) }
+    }).sort(cmp)
+    var hs = items.map(function (it) { return it.collapsed ? G.headH + 2 * G.rowH + G.pad : G.headH + Math.max(1, it.rows.length) * G.rowH + G.pad })
+    var total = hs.reduce(function (s, h) { return s + h }, 0) + G.gapY * Math.max(0, items.length - 1), y = -total / 2
+    items.forEach(function (it, j) {
+      var h: number = hs[j] as number, box: any = { id: L + ':' + it.id, layer: L, x: r1(x), y: r1(y), w: G.boxW, h: h }
+      if (it.collapsed) {
+        box.collapsed = true; box.name = it.name; box.count = it.count; box.rows = []
+        box.sub = it.columns + (it.columns === 1 ? ' column' : ' columns')
+        box.title = it.count + ' models, ' + box.sub + ': click to show them'
+        it.keys.forEach(function (k: string) { at[k] = { x1: r1(x), x2: r1(x + G.boxW), y: r1(y + h / 2), box: box.id, folded: true } })
+      } else {
+        var m = it.model
+        box.name = cut(m.name, G.maxName)
+        box.title = String(m.name) + (m.folder ? ' · ' + m.folder : '') + (m.materialized ? ' · ' + m.materialized : '')
+        box.focus = !!m.focus; box.contract = !!m.contract; box.tests = m.tests || 0; box.exposures = (m.exposures || []).length; box.flags = (m.flags || []).length
+        box.rows = it.rows.map(function (r: any, i: number) {
+          var ry = r1(y + G.headH + i * G.rowH + G.rowH / 2)
+          at[r.c.key] = { x1: r1(x), x2: r1(x + G.boxW), y: ry, box: box.id }
+          return { key: r.c.key, column: cut(r.c.column, G.maxColumn), title: String(r.c.column) + (r.c.type ? ' · ' + r.c.type : ''), glyph: r.c.glyph, byName: !!r.c.byName, end: !!r.c.end, y: ry }
+        })
+      }
+      boxes.push(box)
+      y += h + G.gapY
+    })
+  })
+  ;(f.edges || []).forEach(function (e: any) {
+    var a = at[e[0]], b = at[e[1]]
+    if (!a || !b || a.box === b.box) return
+    // Edges into or out of a folded box are drawn once per pair of ends.
+    var id = a.box + '>' + b.box + '|' + (a.folded ? '' : e[0]) + '|' + (b.folded ? '' : e[1])
+    if (seen[id]) { seen[id].keys.push([e[0], e[1]]); return }
+    var x1 = a.x2, x2 = b.x1, dx = x2 > x1 ? (x2 - x1) / 2 : G.gapX
+    var edge = { from: e[0], to: e[1], keys: [[e[0], e[1]]], glyph: e[2], d: 'M' + x1 + ' ' + a.y + 'C' + r1(x1 + dx) + ' ' + a.y + ' ' + r1(x2 - dx) + ' ' + b.y + ' ' + x2 + ' ' + b.y, mx: r1((x1 + x2) / 2), my: r1((a.y + b.y) / 2) }
+    seen[id] = edge
+    edges.push(edge)
+  })
+  var minX = 0, minY = 0, maxX = 0, maxY = 0
+  boxes.forEach(function (b) { minX = Math.min(minX, b.x); minY = Math.min(minY, b.y); maxX = Math.max(maxX, b.x + b.w); maxY = Math.max(maxY, b.y + b.h) })
+  var fb = boxes[0]
+  return { boxes: boxes, edges: edges, bounds: { x: minX, y: minY, w: maxX - minX, h: maxY - minY }, focus: fb ? { x: fb.x + fb.w / 2, y: fb.y + fb.h / 2 } : { x: 0, y: 0 } }
+}
+
+/**
+ * The graph panel: draws `graphLayout` as SVG, and handles zoom (wheel, pinch, buttons, + and -),
+ * pan (drag, arrow keys), fit (0, or the Fit button) and column clicks, which call the page's
+ * `select(key)`. Uses the page's `el`, `state`, `render` and `GLYPH`.
+ */
+export const GRAPH_VIEW_JS = `
+var SVG='http://www.w3.org/2000/svg';
+function sv(tag,attrs,text){var n=document.createElementNS(SVG,tag);for(var k in attrs)if(attrs[k]!=null)n.setAttribute(k,String(attrs[k]));if(text!=null)n.textContent=String(text);return n}
+function graphPanel(f,i){
+  var lv=state.levels[i],ex=state.expanded[i],lay=graphLayout(f,lv,ex);
+  var p=el('div','panel graph'),bar=el('div','g-bar');
+  function btn(label,title,fn){var b=el('button','g-btn',label);b.type='button';b.title=title;b.setAttribute('aria-label',title);b.addEventListener('click',fn);bar.appendChild(b);return b}
+  var hiddenUp=f.up.hops.filter(function(h){return h.hop>lv.up}).length,hiddenDown=f.down.hops.filter(function(h){return h.hop>lv.down}).length;
+  bar.appendChild(el('span','g-title',f.column?'Column graph':'Model graph'));
+  var tools=el('span','g-tools');bar.appendChild(tools);
+  function more(dir,hidden,label){if(!hidden)return;var b=btn(label+' ('+hidden+')',dir==='up'?'Show one more level upstream':'Show one more level downstream',function(){state.levels[i][dir]+=1;state.views[i]=null;render()});tools.appendChild(b)}
+  more('up',hiddenUp,'\\u2190 more levels');more('down',hiddenDown,'more levels \\u2192');
+  tools.appendChild(btn('\\u2212','Zoom out (-)',function(){zoomBy(1/1.25)}));
+  tools.appendChild(btn('+','Zoom in (+)',function(){zoomBy(1.25)}));
+  tools.appendChild(btn('Fit','Fit the graph to the panel (0)',function(){fit(true)}));
+  tools.appendChild(btn(state.list?'Graph':'List','Show the columns as '+(state.list?'a graph':'a list'),function(){state.list=!state.list;render()}));
+  p.appendChild(bar);
+  var svg=sv('svg',{'class':'g-svg',tabindex:0,role:'group','aria-label':'Column graph: drag or use the arrow keys to move, the wheel or + and - to zoom, 0 to fit'});
+  var vp=sv('g',{'class':'g-vp'}),gE=sv('g',{'class':'g-edges'}),gB=sv('g',{'class':'g-boxes'});vp.appendChild(gE);vp.appendChild(gB);svg.appendChild(vp);
+  lay.edges.forEach(function(e){var g=sv('g',{'class':'g-edge '+(GLYPH[e.glyph]||'unk'),'data-keys':e.keys.map(function(k){return k[0]+'>'+k[1]}).join(' ')});
+    g.appendChild(sv('path',{d:e.d}));var t=sv('text',{x:e.mx,y:e.my-4,'class':'g-elabel','text-anchor':'middle'},e.glyph||'?');g.appendChild(t);gE.appendChild(g)});
+  lay.boxes.forEach(function(b){
+    var g=sv('g',{'class':'g-box'+(b.focus?' focus':'')+(b.collapsed?' collapsed':''),transform:'translate('+b.x+','+b.y+')','data-box':b.id});
+    g.appendChild(sv('title',{},b.title));
+    g.appendChild(sv('rect',{width:b.w,height:b.h,rx:8,'class':'g-rect'}));
+    g.appendChild(sv('text',{x:10,y:19,'class':'g-name'},b.name));
+    var badge=[];if(b.contract)badge.push('C');if(b.exposures)badge.push('\\u25a3'+b.exposures);if(b.flags)badge.push('!');
+    if(badge.length)g.appendChild(sv('text',{x:b.w-10,y:19,'class':'g-badge','text-anchor':'end'},badge.join(' ')));
+    if(b.collapsed){g.appendChild(sv('text',{x:10,y:48,'class':'g-more'},b.sub+' \\u00b7 click to show them'));g.setAttribute('tabindex','0');g.setAttribute('role','button');
+      var open=function(){state.expanded[i][b.layer]=true;state.views[i]=null;render()};g.addEventListener('click',function(ev){if(moved)return;ev.stopPropagation();open()});g.addEventListener('keydown',function(ev){if(ev.key==='Enter'||ev.key===' '){ev.preventDefault();open()}})}
+    b.rows.forEach(function(r){
+      var row=sv('g',{'class':'g-row','data-key':r.key,tabindex:0,role:'button','aria-label':r.title+': light up its path',transform:'translate(0,'+(r.y-b.y-10)+')'});
+      row.appendChild(sv('title',{},r.title));
+      row.appendChild(sv('rect',{x:4,y:0,width:b.w-8,height:20,rx:4,'class':'g-hit'}));
+      row.appendChild(sv('text',{x:12,y:14,'class':'g-glyph '+(GLYPH[r.glyph]||'unk')+(r.byName?' byname':'')},r.glyph||'?'));
+      row.appendChild(sv('text',{x:28,y:14,'class':'g-col'},r.column));
+      if(r.end)row.appendChild(sv('text',{x:b.w-10,y:14,'class':'g-end','text-anchor':'end'},'end'));
+      row.addEventListener('click',function(ev){if(moved)return;ev.stopPropagation();select(r.key)});
+      row.addEventListener('keydown',function(ev){if(ev.key==='Enter'||ev.key===' '){ev.preventDefault();select(r.key)}});
+      g.appendChild(row)});
+    gB.appendChild(g)});
+  p.appendChild(svg);
+  var hint=el('div','g-hint','Drag to move \\u00b7 wheel or pinch to zoom \\u00b7 click a column to light up its path');p.appendChild(hint);
+  // Zoom and pan: one transform, kept per focus while levels change.
+  var v=state.views[i],moved=false;
+  function apply(){vp.setAttribute('transform','translate('+Math.round(v.x)+','+Math.round(v.y)+') scale('+Math.round(v.k*1000)/1000+')')}
+  function size(){var r=svg.getBoundingClientRect();return {w:r.width||800,h:r.height||500}}
+  function fit(force){var s=size(),bb=lay.bounds,k=Math.min(1,(s.w-32)/Math.max(1,bb.w),(s.h-32)/Math.max(1,bb.h));
+    if(k<0.35&&!force){k=0.35;v={k:k,x:s.w/2-lay.focus.x*k,y:s.h/2-lay.focus.y*k}}
+    else{k=Math.max(0.05,k);v={k:k,x:s.w/2-(bb.x+bb.w/2)*k,y:s.h/2-(bb.y+bb.h/2)*k}}
+    state.views[i]=v;apply()}
+  function zoomAt(k2,px,py){k2=Math.min(3,Math.max(0.05,k2));v.x=px-(px-v.x)*k2/v.k;v.y=py-(py-v.y)*k2/v.k;v.k=k2;apply()}
+  function zoomBy(m){var s=size();zoomAt(v.k*m,s.w/2,s.h/2)}
+  svg.addEventListener('wheel',function(ev){ev.preventDefault();var r=svg.getBoundingClientRect();zoomAt(v.k*Math.exp(-ev.deltaY*0.0015),ev.clientX-r.left,ev.clientY-r.top)},{passive:false});
+  var ptrs={},start=null;
+  svg.addEventListener('pointerdown',function(ev){ptrs[ev.pointerId]={x:ev.clientX,y:ev.clientY};moved=false;start={x:ev.clientX,y:ev.clientY,vx:v.x,vy:v.y};var ids=Object.keys(ptrs);if(ids.length===2){var a=ptrs[ids[0]],b=ptrs[ids[1]];start.d=Math.hypot(a.x-b.x,a.y-b.y);start.k=v.k}});
+  svg.addEventListener('pointermove',function(ev){if(!ptrs[ev.pointerId]||!start)return;ptrs[ev.pointerId]={x:ev.clientX,y:ev.clientY};var ids=Object.keys(ptrs);
+    if(ids.length===2&&start.d){var a=ptrs[ids[0]],b=ptrs[ids[1]],r=svg.getBoundingClientRect();moved=true;zoomAt(start.k*Math.hypot(a.x-b.x,a.y-b.y)/start.d,(a.x+b.x)/2-r.left,(a.y+b.y)/2-r.top);return}
+    var dx=ev.clientX-start.x,dy=ev.clientY-start.y;if(!moved&&Math.abs(dx)+Math.abs(dy)<5)return;
+    if(!moved){moved=true;try{svg.setPointerCapture(ev.pointerId)}catch(e){}}v.x=start.vx+dx;v.y=start.vy+dy;apply()});
+  function up(ev){delete ptrs[ev.pointerId];if(!Object.keys(ptrs).length)start=null;setTimeout(function(){moved=false},0)}
+  svg.addEventListener('pointerup',up);svg.addEventListener('pointercancel',up);
+  svg.addEventListener('keydown',function(ev){var step=48;
+    if(ev.key==='ArrowLeft'){v.x+=step}else if(ev.key==='ArrowRight'){v.x-=step}else if(ev.key==='ArrowUp'){v.y+=step}else if(ev.key==='ArrowDown'){v.y-=step}
+    else if(ev.key==='+'||ev.key==='='){zoomBy(1.25);ev.preventDefault();return}else if(ev.key==='-'||ev.key==='_'){zoomBy(1/1.25);ev.preventDefault();return}
+    else if(ev.key==='0'){fit(true);ev.preventDefault();return}else return;ev.preventDefault();apply()});
+  // Drawn after the panel is in the page, when its size is known.
+  p.afterMount=function(){if(v)apply();else fit(false)};
+  return p;
+}
+`
+
+export const GRAPH_CSS = `
+.wrap{max-width:1680px}
+.page{display:grid;gap:14px;grid-template-columns:minmax(0,1fr)}
+.side,.main{min-width:0}
+@media (min-width:1100px){.page{grid-template-columns:minmax(320px,400px) minmax(0,1fr);align-items:start}}
+.main .deep{margin:0 0 10px;padding-top:0;border-top:0}
+.list-bar{border:1px solid var(--line);border-radius:10px;margin:0 0 10px;background:var(--panel)}
+.graph{display:flex;flex-direction:column;min-height:480px;height:min(78vh,900px);overflow:hidden}
+.g-bar{display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;gap:6px 10px;padding:8px 10px;border-bottom:1px solid var(--line)}
+.g-title{font-size:12px;text-transform:uppercase;letter-spacing:.06em;color:var(--muted);font-weight:600}
+.g-tools{display:flex;flex-wrap:wrap;gap:6px}
+.g-btn{appearance:none;border:1px solid var(--line-strong);background:var(--panel);color:var(--ink);border-radius:6px;padding:3px 9px;font:inherit;font-size:12.5px;cursor:pointer;min-width:30px}
+.g-btn:hover{border-color:var(--accent)}
+.g-btn:focus-visible,.g-svg:focus-visible,.g-row:focus-visible,.g-box.collapsed:focus-visible{outline:2px solid var(--accent);outline-offset:1px}
+.g-svg{flex:1;width:100%;min-height:0;display:block;cursor:grab;touch-action:none;background:var(--bg)}
+.g-svg:active{cursor:grabbing}
+.g-hint{font-size:12px;color:var(--faint);padding:6px 10px;border-top:1px solid var(--line)}
+.g-rect{fill:var(--panel);stroke:var(--line-strong);stroke-width:1}
+.g-box.focus .g-rect{fill:var(--focus);stroke:var(--focus-line);stroke-width:1.5}
+.g-box.collapsed{cursor:pointer}
+.g-box.collapsed .g-rect{stroke-dasharray:5 4}
+.g-name{font:600 12.5px ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;fill:var(--ink)}
+.g-badge{font:600 11px -apple-system,"Segoe UI",Roboto,sans-serif;fill:var(--muted)}
+.g-more{font-size:12px;fill:var(--muted)}
+.g-row{cursor:pointer}
+.g-hit{fill:transparent}
+.g-row:hover .g-hit{fill:var(--accent-soft)}
+.g-col{font:12px ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;fill:var(--ink)}
+.g-end{font-size:10.5px;fill:var(--faint)}
+.g-glyph{font:700 12px ui-monospace,SFMono-Regular,Menlo,Consolas,monospace}
+.g-glyph.same{fill:var(--same)}.g-glyph.ren{fill:var(--ren)}.g-glyph.calc{fill:var(--calc)}.g-glyph.agg{fill:var(--agg)}.g-glyph.unk{fill:var(--unk)}
+.g-glyph.byname{opacity:.65}
+.g-edge path{fill:none;stroke:var(--line-strong);stroke-width:1.4}
+.g-edge.same path{stroke:var(--same)}.g-edge.ren path{stroke:var(--ren)}.g-edge.calc path{stroke:var(--calc)}.g-edge.agg path{stroke:var(--agg)}.g-edge.unk path{stroke:var(--unk);stroke-dasharray:4 3}
+.g-edge path{stroke-opacity:.55}
+.g-elabel{font:700 11px ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;fill:var(--muted);paint-order:stroke;stroke:var(--bg);stroke-width:3px}
+body.hl .g-edge{opacity:.12}body.hl .g-edge.on{opacity:1}body.hl .g-edge.on path{stroke-opacity:1;stroke-width:2.2}
+body.hl .g-row{opacity:.3}body.hl .g-row.on{opacity:1}body.hl .g-row.on .g-hit{fill:var(--accent-soft)}body.hl .g-row.sel .g-hit{fill:var(--focus)}
+body.hl .g-box{opacity:.55}body.hl .g-box.has-on,body.hl .g-box.focus{opacity:1}
+`

From ff5a49eaa9b253d05a29dd8b684d95c6ee3ea755 Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Wed, 11 Nov 2026 14:50:27 +0800
Subject: [PATCH 12/21] fix: dragging the column graph no longer selects its
 text

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VEmKQwEiHMwQ7BdwgPo9sb
---
 plugins/altimate-code/hooks/report-graph.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/plugins/altimate-code/hooks/report-graph.ts b/plugins/altimate-code/hooks/report-graph.ts
index 0d26530..e364919 100644
--- a/plugins/altimate-code/hooks/report-graph.ts
+++ b/plugins/altimate-code/hooks/report-graph.ts
@@ -180,7 +180,7 @@ export const GRAPH_CSS = `
 .g-btn{appearance:none;border:1px solid var(--line-strong);background:var(--panel);color:var(--ink);border-radius:6px;padding:3px 9px;font:inherit;font-size:12.5px;cursor:pointer;min-width:30px}
 .g-btn:hover{border-color:var(--accent)}
 .g-btn:focus-visible,.g-svg:focus-visible,.g-row:focus-visible,.g-box.collapsed:focus-visible{outline:2px solid var(--accent);outline-offset:1px}
-.g-svg{flex:1;width:100%;min-height:0;display:block;cursor:grab;touch-action:none;background:var(--bg)}
+.g-svg{flex:1;width:100%;min-height:0;display:block;cursor:grab;touch-action:none;background:var(--bg);-webkit-user-select:none;user-select:none}
 .g-svg:active{cursor:grabbing}
 .g-hint{font-size:12px;color:var(--faint);padding:6px 10px;border-top:1px solid var(--line)}
 .g-rect{fill:var(--panel);stroke:var(--line-strong);stroke-width:1}

From 478c178d9bd6968614afb20f581c89dc62cfc6f8 Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Wed, 11 Nov 2026 15:08:13 +0800
Subject: [PATCH 13/21] feat: the per-edit column lookup goes through the
 altimate CLI

- An edit's `impact_analysis` runs through the CLI, not MCP: no permission prompt in accept-edits mode, and a large answer arrives whole.
- The pane's column reach still tries MCP first; its saved-answer and hang tests move there.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VEmKQwEiHMwQ7BdwgPo9sb
---
 plugins/altimate-code/CHANGELOG.md            |  2 +
 plugins/altimate-code/hooks/lineage.test.tsx  | 79 +++++++++++--------
 plugins/altimate-code/hooks/lineage.tsx       |  3 +-
 .../altimate-code/hooks/task-impact.test.tsx  |  2 +-
 4 files changed, 53 insertions(+), 33 deletions(-)

diff --git a/plugins/altimate-code/CHANGELOG.md b/plugins/altimate-code/CHANGELOG.md
index 8f890ff..e7b9c62 100644
--- a/plugins/altimate-code/CHANGELOG.md
+++ b/plugins/altimate-code/CHANGELOG.md
@@ -8,9 +8,11 @@ All notable changes to this plugin will be documented in this file.
 - End-of-task column impact: after a task that changed a dbt model, a band sums up each changed column's downstream reach from `impact_analysis`. The task's start copies `target/manifest.json` aside, so the answer reflects the SQL before the task.
 - An offline HTML report, built when **Open report** or `/lineage-report` asks for it: what changed and what to expect downstream in plain words, who consumes it from dbt exposures, then upstream and downstream lineage, two levels by default, and click-to-highlight paths.
 - When a plan goes up for approval, a line above the dialog gives the downstream models, tests and exposures of each model the plan names.
+- The report draws the column lineage as a graph beside the summary: upstream on the left, downstream on the right, opened to fit, with zoom and pan. A click lights a column's path, "more levels" adds one, and a level of more than 12 models folds into one box. The page allows only its own inline script and style.
 
 ### Changed
 - The per-edit impact note no longer shows as a toast and band; it still goes to Claude's context with the edit's result. A lookup that missed its time or failed still shows a toast.
+- The per-edit column lookup goes through the altimate CLI instead of the MCP server, so it raises no permission prompt in accept-edits mode and a large column answer arrives whole.
 
 ## [1.5.0] — 2026-11-10
 
diff --git a/plugins/altimate-code/hooks/lineage.test.tsx b/plugins/altimate-code/hooks/lineage.test.tsx
index 38bbca6..938a74e 100644
--- a/plugins/altimate-code/hooks/lineage.test.tsx
+++ b/plugins/altimate-code/hooks/lineage.test.tsx
@@ -18,7 +18,7 @@ const PANE = {
 const BAND = {
   plugin: 'altimate-code',
   component: 'AbovePrompt',
-  props: { hasSurvey: false, isWorking: false, maxRows: 10, bodyColumns: 120, scroll: { offset: 0, bodyRows: 10 }, view: {} },
+  props: { hasSurvey: false, isCollapsed: false, isWorking: false, maxRows: 10, bodyColumns: 120, scroll: { offset: 0, bodyRows: 10 }, view: {} },
 } as const
 
 const LINEAGE = {
@@ -195,7 +195,13 @@ async function start($: any, on: any, options: Options = {}) {
     // The integrations half of the plugin asks the CLI for its status at session start.
     if (command !== 'tool') return { value: { exitCode: 1, stdout: '', stderr: 'not this test' } }
     const args = JSON.parse(String(e.argv[e.argv.indexOf('--args') + 1] ?? '{}'))
-    calls.push(`cli:${tool}${args.include_graph ? ':graph' : ''}`)
+    calls.push(`cli:${tool}${args.include_graph ? ':graph' : ''}${args.column ? `:${args.column}` : ''}`)
+    // A column that fails, or answers late, as the MCP server does in the tests below.
+    if (tool === 'impact_analysis' && args.column === options.failColumn) return { value: { exitCode: 1, stdout: JSON.stringify({ status: 'error', output: 'boom', metadata: {} }), stderr: '' } }
+    if (tool === 'impact_analysis' && options.holdReach && args.column === options.holdReach.column) {
+      await options.holdReach.until
+      return { value: { exitCode: 0, stdout: JSON.stringify({ status: 'ok', output: 'x', metadata: { severity: 'LOW', column_reach: { models: [{ name: 'stale_reader', columns: [] }], exposures: [] } } }), stderr: '' } }
+    }
     if (options.cliFailure) return { value: { exitCode: 1, stdout: JSON.stringify({ status: 'error', output: 'the dbt project could not start', metadata: {} }), stderr: '' } }
     if (options.cliTooLarge) return { value: { exitCode: 0, stdout: '{"status":"ok","out', stderr: '', isStdoutTruncated: true } }
     if (options.cliCutOff?.(tool)) return { value: { exitCode: options.cliCutOffExit ?? 0, stdout: '{"status":"ok","out', stderr: '' } }
@@ -269,7 +275,8 @@ test('an edit naming a column is held until its reach is known, then the reach g
   await clock.settle()
 
   // The reach is looked up before the edit runs.
-  expect(calls.indexOf('mcp:impact_analysis:revenue')).toBeLessThan(calls.indexOf('tool:Edit'))
+  expect(calls.indexOf('cli:impact_analysis:revenue')).toBeGreaterThan(-1)
+  expect(calls.indexOf('cli:impact_analysis:revenue')).toBeLessThan(calls.indexOf('tool:Edit'))
   expect(notes[0]).toBe('◆ impact-first · fct_orders.revenue is read by 2 models and 1 dashboard · Exec Revenue')
   expect(toasts).toEqual([])
   expect(result.context?.[0]).toContain('read by 2 downstream models: fct_revenue_daily (revenue), rpt_finance_weekly (revenue)')
@@ -583,7 +590,7 @@ test("an edit of a column the project doesn't declare is traced from the model's
   await clock.settle()
   // Its columns come through the CLI (no permission dialog), before the reach.
   expect(calls.indexOf('cli:dbt_lineage')).toBeGreaterThan(-1)
-  expect(calls.indexOf('cli:dbt_lineage')).toBeLessThan(calls.indexOf('mcp:impact_analysis:net_revenue'))
+  expect(calls.indexOf('cli:dbt_lineage')).toBeLessThan(calls.indexOf('cli:impact_analysis:net_revenue'))
   expect(notes.at(-1)).toMatch(/^◆ impact-first · fct_orders\.net_revenue is read by 2 models/)
   expect(result.context?.[0]).toContain('Altimate lineage for fct_orders.net_revenue')
   // The next edit of the same model uses the columns it already has.
@@ -597,26 +604,37 @@ test('an edit whose declared columns already show what it touches does not wait
   await $.tool.call({ tool: 'Edit', file_path: FILE, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) / 100 as revenue' })
   await clock.settle()
   // revenue is declared: traced at once, while the model's columns are fetched for later edits.
-  expect(calls.indexOf('mcp:impact_analysis:revenue')).toBeLessThan(calls.indexOf('tool:Edit'))
+  expect(calls.indexOf('cli:impact_analysis:revenue')).toBeGreaterThan(-1)
+  expect(calls.indexOf('cli:impact_analysis:revenue')).toBeLessThan(calls.indexOf('tool:Edit'))
   expect(notes[0]).toMatch(/^◆ impact-first · fct_orders\.revenue is read by 2 models/)
 })
 
-test("a column reach Claude Code saved to a file is read from it, with no CLI call", async ($, on) => {
-  const { clock, calls, notes } = await start($, on, { persisted: { readable: true } })
-  await $.tool.call({ tool: 'Edit', file_path: FILE, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) / 100 as revenue' })
+test("the pane's column reach Claude Code saved to a file is read from it, with no CLI call", async ($, on) => {
+  const { clock, calls, logs } = await start($, on, { persisted: { readable: true } })
+  await $.command.run({ command: 'lineage', args: 'fct_orders.revenue', origin: { kind: 'composer' }, presentation: { isFullscreen: false, columns: 120 } } as any)
   await clock.settle()
-  expect(notes[0]).toBe('◆ impact-first · fct_orders.revenue is read by 2 models and 1 dashboard · Exec Revenue')
-  expect(calls).not.toContain('cli:impact_analysis')
+  expect(calls).toContain('mcp:impact_analysis:revenue')
+  expect(calls).not.toContain('cli:impact_analysis:revenue')
+  expect(logs.some(line => line.includes('impact_analysis(fct_orders, column: revenue) · read by 2 models'))).toBe(true)
 })
 
-test('a saved long answer the plugin cannot read is asked of the CLI, not taken as no answer', async ($, on) => {
-  const { clock, calls, notes } = await start($, on, { persisted: { readable: false } })
+test("the pane's saved long answer the plugin cannot read is asked of the CLI, not taken as no answer", async ($, on) => {
+  const { clock, calls, logs } = await start($, on, { persisted: { readable: false } })
+  await $.command.run({ command: 'lineage', args: 'fct_orders.revenue', origin: { kind: 'composer' }, presentation: { isFullscreen: false, columns: 120 } } as any)
+  await clock.settle()
+  expect(calls.indexOf('mcp:impact_analysis:revenue')).toBeLessThan(calls.indexOf('cli:impact_analysis:revenue'))
+  expect(calls.indexOf('mcp:impact_analysis:revenue')).toBeGreaterThan(-1)
+  expect(logs.some(line => line.includes('impact_analysis(fct_orders, column: revenue) · read by 2 models'))).toBe(true)
+})
+
+test('an edit asks the CLI for its column trace, never MCP, even with the MCP server up', async ($, on) => {
+  const { clock, calls, notes } = await start($, on, { persisted: { readable: true } })
   await $.tool.call({ tool: 'Edit', file_path: FILE, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) / 100 as revenue' })
   await clock.settle()
-  expect(calls).toContain('cli:impact_analysis')
+  expect(calls).toContain('cli:impact_analysis:revenue')
+  expect(calls.filter(call => call.startsWith('mcp:impact_analysis'))).toEqual([])
   expect(notes[0]).toBe('◆ impact-first · fct_orders.revenue is read by 2 models and 1 dashboard · Exec Revenue')
 })
-
 test("a model's columns the CLI could not give are not asked again for the same manifest", async ($, on) => {
   // Denied edits: the pane follows no model, so nothing but the CLI could give the columns.
   const { clock, calls } = await start($, on, { cliFailure: true, toolResult: e => (e.tool === 'Edit' ? { deny: 'not now' } : undefined) })
@@ -644,7 +662,7 @@ test("a CLI column answer that fails late never replaces the columns the pane re
   // An edit of net_revenue (undeclared, known from the pane's read) is still traced.
   await $.tool.call({ tool: 'Edit', file_path: FILE, old_string: 'sum(amount) as net_revenue', new_string: 'sum(amount) - 1 as net_revenue' })
   await clock.settle()
-  expect(calls).toContain('mcp:impact_analysis:net_revenue')
+  expect(calls).toContain('cli:impact_analysis:net_revenue')
 })
 
 test('a graph found too big is not drawn again when the pane goes back to a width it had', async ($, on) => {
@@ -756,7 +774,7 @@ test('a result the MCP server left out for size is fetched again through the CLI
   await run('fct_orders.revenue')
   await clock.settle()
   expect(calls).toContain('mcp:impact_analysis:revenue')
-  expect(calls).toContain('cli:impact_analysis')
+  expect(calls).toContain('cli:impact_analysis:revenue')
   const ui = await $.ui.mount({ ...PANE, surface: 'terminal' })
   expect(await ui.find({ type: 'Text', text: /read by 2 models · 1 dashboard(?!s)/ })).toBeDefined()
   await ui.unmount()
@@ -818,8 +836,9 @@ test('an edit touching two columns traces both and reports their combined reach'
   const { clock, calls, notes } = await start($, on)
   await $.tool.call({ tool: 'Edit', file_path: FILE, old_string: 'i.revenue, i.order_id', new_string: 'coalesce(i.revenue, 0) as revenue, i.order_id + 0 as order_id' })
   await clock.settle()
-  expect(calls).toContain('mcp:impact_analysis:revenue')
-  expect(calls).toContain('mcp:impact_analysis:order_id')
+  expect(calls).toContain('cli:impact_analysis:revenue')
+  expect(calls).toContain('cli:impact_analysis:order_id')
+  expect(calls.filter(call => call.startsWith('mcp:impact_analysis'))).toEqual([])
   expect(notes[0]).toContain('fct_orders.')
   expect(notes[0]).toContain('is read by 2 models and 1 dashboard')
 })
@@ -850,7 +869,7 @@ test('columns beyond the cap are named as unchecked and make the count a lower b
     new_string: 'select order_id + 0 as order_id, revenue + 0 as revenue, gross_revenue + 0 as gross_revenue, status + 0 as status',
   })
   await clock.settle()
-  expect(calls.filter(call => call.startsWith('mcp:impact_analysis'))).toHaveLength(3)
+  expect(calls.filter(call => call.startsWith('cli:impact_analysis'))).toHaveLength(3)
   expect(notes[0]).toContain('is read by at least 2 models')
   expect(edit.context?.[0]).toMatch(/columns not checked \(over the limit or no answer in time\): \w+;/)
 })
@@ -1604,7 +1623,7 @@ test('no column trace starts once the hold has run out', async ($, on) => {
   await late
   release()
   await clock.settle()
-  expect(calls.filter(one => one.startsWith('mcp:impact_analysis'))).toEqual([])
+  expect(calls.filter(one => one.includes('impact_analysis'))).toEqual([])
 })
 
 test('two edits of one column while its trace runs share that trace', async ($, on) => {
@@ -1616,7 +1635,7 @@ test('two edits of one column while its trace runs share that trace', async ($,
   answer()
   await Promise.all([first, second])
   await both.clock.settle()
-  expect(both.calls.filter(one => one === 'mcp:impact_analysis:revenue')).toEqual(['mcp:impact_analysis:revenue'])
+  expect(both.calls.filter(one => one === 'cli:impact_analysis:revenue')).toEqual(['cli:impact_analysis:revenue'])
 })
 
 test('a model folder outside the project (`../..`) is never walked', async ($, on) => {
@@ -1693,15 +1712,13 @@ test('bare /lineage asks for warehouse lineage on the model shown', async ($, on
   expect(calls).toContain('mcp:table_lineage')
 })
 
-test('an MCP trace that never answers is given up on, so the next edit of that column traces again', async ($, on) => {
-  const { clock, calls } = await start($, on, { mcpHang: 'impact_analysis' })
-  const first = $.tool.call({ tool: 'Edit', file_path: FILE, old_string: 'x as revenue', new_string: 'y as revenue' })
-  await clock.advance(9_000)
-  await first
-  await clock.settle()
-  const second = $.tool.call({ tool: 'Edit', file_path: FILE, old_string: 'y as revenue', new_string: 'z as revenue' })
-  await clock.advance(9_000)
-  await second
+test("the pane's MCP column trace that never answers is given up on, and the CLI answers instead", async ($, on) => {
+  const { clock, calls, logs } = await start($, on, { mcpHang: 'impact_analysis' })
+  const asked = $.command.run({ command: 'lineage', args: 'fct_orders.revenue', origin: { kind: 'composer' }, presentation: { isFullscreen: false, columns: 120 } } as any)
+  await clock.advance(61_000)
+  await asked
   await clock.settle()
-  expect(calls.filter(one => one === 'mcp:impact_analysis:revenue')).toEqual(['mcp:impact_analysis:revenue', 'mcp:impact_analysis:revenue'])
+  expect(calls.indexOf('mcp:impact_analysis:revenue')).toBeGreaterThan(-1)
+  expect(calls.indexOf('mcp:impact_analysis:revenue')).toBeLessThan(calls.indexOf('cli:impact_analysis:revenue'))
+  expect(logs.some(line => line.includes('impact_analysis(fct_orders, column: revenue) · read by 2 models'))).toBe(true)
 })
diff --git a/plugins/altimate-code/hooks/lineage.tsx b/plugins/altimate-code/hooks/lineage.tsx
index 70b99c4..fca1ac5 100644
--- a/plugins/altimate-code/hooks/lineage.tsx
+++ b/plugins/altimate-code/hooks/lineage.tsx
@@ -1018,7 +1018,8 @@ async function impactFirst($: EngineInterface, e: any, file: string, deadline: n
         const left = Math.min(HOLD_MS, deadline - (await $.clock.now()))
         if (left <= 0) return null
         const args = { manifest_path: manifest, model: id, column: col, change_type: 'modify' }
-        return within($, left, shared(`impact\u0000${manifest}\u0000${stat.mtimeMs}\u0000${id}\u0000${col}`, () => runTool($, 'impact_analysis', args, false, deadline)))
+        // Through the CLI, not MCP: no permission prompt in accept-edits mode, and no size cap on the answer.
+        return within($, left, shared(`impact\u0000${manifest}\u0000${stat.mtimeMs}\u0000${id}\u0000${col}`, () => runTool($, 'impact_analysis', args, true, deadline)))
       }),
     )
     // The column answer, as the end-of-task summary reads it, so Claude and the person see one set of
diff --git a/plugins/altimate-code/hooks/task-impact.test.tsx b/plugins/altimate-code/hooks/task-impact.test.tsx
index ed498e2..cb3bda1 100644
--- a/plugins/altimate-code/hooks/task-impact.test.tsx
+++ b/plugins/altimate-code/hooks/task-impact.test.tsx
@@ -16,7 +16,7 @@ const SNAPSHOT_SQL = `${ROOT}/snapshots/orders_snap.sql`
 const BAND = {
   plugin: 'altimate-code',
   component: 'AbovePrompt',
-  props: { hasSurvey: false, isWorking: false, maxRows: 10, bodyColumns: 120, scroll: { offset: 0, bodyRows: 10 }, view: {} },
+  props: { hasSurvey: false, isCollapsed: false, isWorking: false, maxRows: 10, bodyColumns: 120, scroll: { offset: 0, bodyRows: 10 }, view: {} },
 } as const
 
 const ORDERS_SQL = 'select\n  order_id,\n  sum(amount) as revenue\nfrom {{ ref("int_orders") }}\ngroup by 1\n'

From 64d63e48fb9ba1c8684cbfaed00903008e17fec1 Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Wed, 11 Nov 2026 16:18:18 +0800
Subject: [PATCH 14/21] feat: usage events for the lineage report through
 altimate-code telemetry

- The summary shown, Open report, /lineage-report, and built, failed or no browser each send one `tool report-event` call: the step and the session id only.
- PRIVACY.md describes the report and its events.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VEmKQwEiHMwQ7BdwgPo9sb
---
 PRIVACY.md                                    | 14 ++++++++++
 plugins/altimate-code/CHANGELOG.md            |  1 +
 .../altimate-code/hooks/task-impact.test.tsx  | 24 +++++++++++++++++
 plugins/altimate-code/hooks/task-impact.tsx   | 26 ++++++++++++++++---
 4 files changed, 62 insertions(+), 3 deletions(-)

diff --git a/PRIVACY.md b/PRIVACY.md
index b35aadc..0fba74f 100644
--- a/PRIVACY.md
+++ b/PRIVACY.md
@@ -78,6 +78,18 @@ Turn off recording and drafting with `altimate learn disable` in the project, or
 
 The delegation path below runs only when the delegation skill or the `/altimate-code:altimate` command fires and invokes the locally installed altimate-code CLI.
 
+## The lineage report
+
+The column impact report is one HTML file that the plugin writes to the project's `target/.altimate-lineage/` and opens in your browser. The page loads nothing from the network: its content-security policy allows only its own inline script and style.
+
+To learn whether the report gets used, the plugin asks the local altimate-code CLI (`altimate-code tool report-event`) to send one usage event, `lineage_report`, at each of these steps:
+- the summary was shown;
+- **Open report** was pressed;
+- `/lineage-report` was run;
+- the report was built, failed to build, or found no browser.
+
+Each event carries the step and the Claude Code session id (`claude:<id>`) only: no model, column, file or project names. It goes through Altimate's usage telemetry, described in [Usage telemetry](#usage-telemetry), and that section's opt-out turns it off. With an altimate-code that predates the command, nothing is sent.
+
 ## Data flows when a task is delegated
 
 | Data | Where it goes | Retention |
@@ -128,6 +140,8 @@ The plugin and the altimate-code CLI are professional developer tools, not direc
 
 We will update this document in this repository and revise the effective date when our practices change. Material changes to Altimate-wide practices are governed by the master [Privacy Policy](https://www.altimate.ai/privacy).
 
+**Next release:** added [The lineage report](#the-lineage-report): the offline report page, and the usage events the altimate-code CLI sends for it.
+
 **November 10, 2026:** added [Workspace rules](#workspace-rules) (the workspace-rules hooks and `/altimate-code:rules` in plugin 1.5.0), and the rules telemetry the altimate-code CLI sends.
 
 ## Contact
diff --git a/plugins/altimate-code/CHANGELOG.md b/plugins/altimate-code/CHANGELOG.md
index e7b9c62..c43388f 100644
--- a/plugins/altimate-code/CHANGELOG.md
+++ b/plugins/altimate-code/CHANGELOG.md
@@ -8,6 +8,7 @@ All notable changes to this plugin will be documented in this file.
 - End-of-task column impact: after a task that changed a dbt model, a band sums up each changed column's downstream reach from `impact_analysis`. The task's start copies `target/manifest.json` aside, so the answer reflects the SQL before the task.
 - An offline HTML report, built when **Open report** or `/lineage-report` asks for it: what changed and what to expect downstream in plain words, who consumes it from dbt exposures, then upstream and downstream lineage, two levels by default, and click-to-highlight paths.
 - When a plan goes up for approval, a line above the dialog gives the downstream models, tests and exposures of each model the plan names.
+- Usage events for the report, through altimate-code's telemetry (`tool report-event`): the summary shown, **Open report** pressed, `/lineage-report` run, and the report built, failed or with no browser. The step and the session id only, off under the telemetry opt-out. See PRIVACY.md.
 - The report draws the column lineage as a graph beside the summary: upstream on the left, downstream on the right, opened to fit, with zoom and pan. A click lights a column's path, "more levels" adds one, and a level of more than 12 models folds into one box. The page allows only its own inline script and style.
 
 ### Changed
diff --git a/plugins/altimate-code/hooks/task-impact.test.tsx b/plugins/altimate-code/hooks/task-impact.test.tsx
index cb3bda1..3f043b9 100644
--- a/plugins/altimate-code/hooks/task-impact.test.tsx
+++ b/plugins/altimate-code/hooks/task-impact.test.tsx
@@ -126,11 +126,13 @@ async function start($: any, on: any, options: Options = {}) {
     if (e.args.direction) mcpAsked.push(e.args)
     return { value: { content: [{ type: 'text', text: JSON.stringify({ ...impactBody(e.args), report: 'Impact' }) }], isError: false } }
   })
+  on('session.id', () => ({ value: 'a1b2c3d4-0000-4000-8000-000000000001' }))
   on('process.run', (_: unknown, e: { argv: readonly string[] }) => {
     const argv = [...e.argv]
     runs.push(argv)
     const ok = (stdout = '') => ({ value: { exitCode: 0, stdout, stderr: '' } })
     const [bin] = argv
+    if (bin === 'altimate' && argv[2] === 'report-event') return ok()
     if (bin === 'altimate') {
       const args = JSON.parse(String(argv[argv.indexOf('--args') + 1] ?? '{}'))
       if (options.cliFails) return { value: { exitCode: 1, stdout: JSON.stringify({ status: 'error', output: 'no', metadata: {} }), stderr: '' } }
@@ -493,6 +495,28 @@ test('when no browser opens, the band shows the report path as a link', async ($
   await band.unmount()
 })
 
+test('each step of the report sends one usage event through the CLI, with the action and the session only', async ($, on) => {
+  const { runs, turn, clock } = await start($, on, { uname: 'Linux', openers: { 'xdg-open': 3 } })
+  await turn('t1', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
+  })
+  await clock.settle()
+  const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  await band.press({ key: 'lineage-report-open' })
+  await clock.settle()
+  await $.command.run({ command: 'lineage-report', args: '' } as any)
+  await clock.settle()
+  await band.unmount()
+  const events = runs.filter(argv => argv[2] === 'report-event')
+  expect(events.map(argv => argv[3]).sort()).toEqual(['command_run', 'no_browser', 'no_browser', 'open_pressed', 'summary_shown'])
+  for (const argv of events) {
+    expect(argv.slice(0, 3)).toEqual(['altimate', 'tool', 'report-event'])
+    expect(argv).toHaveLength(6)
+    expect(argv[4]).toBe('--session')
+    expect(argv[5]).toMatch(/^claude:[A-Za-z0-9_-]+$/)
+  }
+})
+
 test('macOS opens with open; /lineage-report before any report says so', async ($, on) => {
   const { runs, turn } = await start($, on, { uname: 'Darwin', openers: { open: 0 } })
   const none: any = await $.command.run({ command: 'lineage-report', args: '' } as any)
diff --git a/plugins/altimate-code/hooks/task-impact.tsx b/plugins/altimate-code/hooks/task-impact.tsx
index 0d0696a..3ddd98a 100644
--- a/plugins/altimate-code/hooks/task-impact.tsx
+++ b/plugins/altimate-code/hooks/task-impact.tsx
@@ -5,7 +5,7 @@ import { atom, read, update } from 'claude-code'
 import type { EngineInterface, On, RenderElement } from 'claude-code'
 
 import type { PlanImpactView, TaskSummaryView } from '../types'
-import { later } from './altimate-cli'
+import { later, runAltimate } from './altimate-cli'
 import {
   answerOf,
   changedColumns,
@@ -271,10 +271,25 @@ async function finishTask($: EngineInterface, t: Task) {
   if (seq !== finishSeq) return
   const view = summaryOf(changes, traces, null)
   await update($, summaryAtom, () => view)
+  reportEvent($, 'summary_shown')
   // One line: a log line draws a newline as a replacement glyph.
   $.ui.log(summaryLines(view).map(line => line.trim()).join(' · '))
 }
 
+export type ReportAction = 'summary_shown' | 'open_pressed' | 'command_run' | 'built' | 'build_failed' | 'no_browser'
+
+/**
+ * One usage event about the report, through altimate-code's telemetry (`tool report-event`), in the
+ * background. It carries the action and this session's id only, and the CLI drops it under the telemetry
+ * opt-out; an altimate-code without the command refuses it, and nothing else happens.
+ */
+export function reportEvent($: EngineInterface, action: ReportAction) {
+  later($, async () => {
+    const id = await $.session.id()
+    await runAltimate($, ['tool', 'report-event', action, '--session', `claude:${id}`], 15_000).catch(() => null)
+  })
+}
+
 /** The last task that changed a model: this session's, else the one a project's saved file names. */
 async function lastTask($: EngineInterface): Promise<Finished | null> {
   if (finished) return finished
@@ -412,11 +427,13 @@ async function buildAndOpen($: EngineInterface): Promise<string> {
   await update($, summaryAtom, view => (view ? { ...view, building: true, openFailed: false } : view))
   const built = await buildReport($, done)
   if ('error' in built) {
+    reportEvent($, 'build_failed')
     await update($, summaryAtom, view => (view ? { ...view, building: false } : view))
     $.ui.toast(built.error)
     return built.error
   }
   const opened = await openReport($, built.path)
+  reportEvent($, opened ? 'built' : 'no_browser')
   await update($, summaryAtom, view => (view ? { ...view, building: false, report: built.path, openFailed: !opened } : view))
   return opened ? `Opened the column impact report for the task that finished at ${stamp(done.finishedAt)}: ${built.path}` : `No browser could be opened. The report is at ${built.path}`
 }
@@ -464,7 +481,7 @@ export async function taskBand($: EngineInterface, ui: Ui): Promise<RenderElemen
         </Text>
       ) : null}
       <Box>
-        {view?.state === 'ready' ? <Button key="lineage-report-open" label="Open report" onPress={() => later($, async () => void (await buildAndOpen($)))} /> : null}
+        {view?.state === 'ready' ? <Button key="lineage-report-open" label="Open report" onPress={() => (reportEvent($, 'open_pressed'), later($, async () => void (await buildAndOpen($))))} /> : null}
         <Button key="lineage-open" label="Open lineage" onPress={() => later($, () => openPane($))} />
         <Button key="lineage-summary-dismiss" label="Dismiss" onPress={() => update($, hiddenAtom, () => true)} />
       </Box>
@@ -510,5 +527,8 @@ export function taskTurnComplete($: EngineInterface, e: { agentId?: string }) {
 
 /** /lineage-report: builds the last finished task's report and opens it. */
 export function registerTaskImpact(on: On) {
-  on('command.run', { command: REPORT_COMMAND }, async $ => ({ text: await buildAndOpen($) }))
+  on('command.run', { command: REPORT_COMMAND }, async $ => {
+    reportEvent($, 'command_run')
+    return { text: await buildAndOpen($) }
+  })
 }

From d1bea72ffc60319b50fc5e67773a1db178c77b7f Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Thu, 12 Nov 2026 00:46:24 +0800
Subject: [PATCH 15/21] feat: unlabelled edges where the engine can't tell how
 the value changes

The report's graph labels an edge only when the engine says how the value changes: same, renamed, calculated or aggregated. An unknown edge stays dashed with no label, and a note under the graph says what that means. The summary's numbers don't change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VEmKQwEiHMwQ7BdwgPo9sb
---
 plugins/altimate-code/CHANGELOG.md            |  2 +-
 .../altimate-code/hooks/report-graph.test.ts  | 19 ++++++++++++++++++-
 plugins/altimate-code/hooks/report-graph.ts   |  9 +++++++--
 3 files changed, 26 insertions(+), 4 deletions(-)

diff --git a/plugins/altimate-code/CHANGELOG.md b/plugins/altimate-code/CHANGELOG.md
index c43388f..bb34ce1 100644
--- a/plugins/altimate-code/CHANGELOG.md
+++ b/plugins/altimate-code/CHANGELOG.md
@@ -9,7 +9,7 @@ All notable changes to this plugin will be documented in this file.
 - An offline HTML report, built when **Open report** or `/lineage-report` asks for it: what changed and what to expect downstream in plain words, who consumes it from dbt exposures, then upstream and downstream lineage, two levels by default, and click-to-highlight paths.
 - When a plan goes up for approval, a line above the dialog gives the downstream models, tests and exposures of each model the plan names.
 - Usage events for the report, through altimate-code's telemetry (`tool report-event`): the summary shown, **Open report** pressed, `/lineage-report` run, and the report built, failed or with no browser. The step and the session id only, off under the telemetry opt-out. See PRIVACY.md.
-- The report draws the column lineage as a graph beside the summary: upstream on the left, downstream on the right, opened to fit, with zoom and pan. A click lights a column's path, "more levels" adds one, and a level of more than 12 models folds into one box. The page allows only its own inline script and style.
+- The report draws the column lineage as a graph beside the summary: upstream on the left, downstream on the right, opened to fit, with zoom and pan. A click lights a column's path, "more levels" adds one, and a level of more than 12 models folds into one box. The page allows only its own inline script and style. An edge carries a label only when the engine told how the value changes (same, renamed, calculated, aggregated); the rest are dashed and unlabelled, and a note under the graph says so.
 
 ### Changed
 - The per-edit impact note no longer shows as a toast and band; it still goes to Claude's context with the edit's result. A lookup that missed its time or failed still shows a toast.
diff --git a/plugins/altimate-code/hooks/report-graph.test.ts b/plugins/altimate-code/hooks/report-graph.test.ts
index 90cb201..42525c8 100644
--- a/plugins/altimate-code/hooks/report-graph.test.ts
+++ b/plugins/altimate-code/hooks/report-graph.test.ts
@@ -4,7 +4,7 @@ import { type ColumnAnswer, type ModelChange, reportData, reportHtml } from './i
 
 type Layout = {
   boxes: { id: string; layer: number; x: number; y: number; h: number; name: string; title: string; collapsed?: boolean; count?: number; rows: { key: string }[] }[]
-  edges: { from: string; to: string; keys: string[][] }[]
+  edges: { from: string; to: string; keys: string[][]; label: string | null }[]
 }
 const graphLayout = layoutOf as (focus: unknown, levels: { up: number; down: number }, expanded: Record<number, boolean>) => Layout
 
@@ -96,6 +96,17 @@ describe('report graph layout', () => {
     expect(graphLayout(focusOf(shuffled as ColumnAnswer), { up: 2, down: 2 }, {})).toEqual(lay)
   })
 
+  test("labels an edge with how the value changes, and leaves one the engine couldn't tell unlabelled", () => {
+    const down = answer(['a', 'b'], { a: 'x' })
+    down.edges = down.edges!.map((edge, i) => (i === 1 ? [edge[0], edge[1], '?'] : i === 2 ? [edge[0], edge[1]] : edge))
+    const up = { ...UP, edges: [[1, 0, '~'], [2, 1, 'ƒ']] } as ColumnAnswer
+    const labels = Object.fromEntries(graphLayout(focusOf(down, up), { up: 2, down: 2 }, {}).edges.map(edge => [`${edge.from.split('|')[0]!.split('.').pop()}>${edge.to.split('|')[0]!.split('.').pop()}`, edge.label]))
+    // a: same; b: unknown; x: no derivation given; upstream: renamed and calculated.
+    expect(labels).toEqual({ 'fct>a': '=', 'fct>b': null, 'a>x': null, 'stg_orders>fct': '~', 'orders>stg_orders': 'ƒ' })
+    const agg = answer(['a'], { a: 'x' })
+    expect(graphLayout(focusOf(agg), { up: 2, down: 2 }, {}).edges.find(edge => edge.to.startsWith('model.shop.x'))!.label).toBe('Σ')
+  })
+
   test('cuts a long model name and keeps the whole name in its title', () => {
     const long = 'int_query_cost_attribution_by_warehouse_and_hour'
     const box = layer(graphLayout(focusOf(answer([long])), { up: 0, down: 1 }, {}), 1)[0]!
@@ -112,4 +123,10 @@ describe('report page', () => {
     expect(html).toContain('function graphPanel(')
     expect(html).not.toMatch(/<script[^>]+src=|<link[^>]+stylesheet|@import|url\(http/)
   })
+
+  test('says what an unlabelled edge means, and draws a label only for an edge that has one', () => {
+    const html = reportHtml(reportData([CHANGE], [{ model: 'fct', column: 'revenue', down: answer(['a']), up: UP, modelLevel: null, failed: false }], TASK))
+    expect(html).toContain('Dashed, unlabelled: the engine couldn\u2019t tell how the value changes.')
+    expect(html).toContain("if(e.label)g.appendChild(sv('text'")
+  })
 })
diff --git a/plugins/altimate-code/hooks/report-graph.ts b/plugins/altimate-code/hooks/report-graph.ts
index e364919..e1e6bf4 100644
--- a/plugins/altimate-code/hooks/report-graph.ts
+++ b/plugins/altimate-code/hooks/report-graph.ts
@@ -10,6 +10,8 @@
  * - A layer with more than 12 models is one box ("+N models") unless expanded.
  * - Each layer is ordered by where its edges meet the layer before it (toward the changed column),
  *   then by name, so edges cross less and the order never depends on the data's order.
+ * - An edge's `label` is its derivation when the engine told it (same, renamed, calculated,
+ *   aggregated), else null: an unknown one is drawn without a label.
  *
  * The page runs this function's own source (`graphLayout.toString()`), so it uses nothing from
  * outside its body but the language's built-ins.
@@ -79,7 +81,8 @@ export function graphLayout(f: any, levels: { up: number; down: number }, expand
     var id = a.box + '>' + b.box + '|' + (a.folded ? '' : e[0]) + '|' + (b.folded ? '' : e[1])
     if (seen[id]) { seen[id].keys.push([e[0], e[1]]); return }
     var x1 = a.x2, x2 = b.x1, dx = x2 > x1 ? (x2 - x1) / 2 : G.gapX
-    var edge = { from: e[0], to: e[1], keys: [[e[0], e[1]]], glyph: e[2], d: 'M' + x1 + ' ' + a.y + 'C' + r1(x1 + dx) + ' ' + a.y + ' ' + r1(x2 - dx) + ' ' + b.y + ' ' + x2 + ' ' + b.y, mx: r1((x1 + x2) / 2), my: r1((a.y + b.y) / 2) }
+    var known = e[2] === '=' || e[2] === '~' || e[2] === '\u0192' || e[2] === '\u03a3'
+    var edge = { from: e[0], to: e[1], keys: [[e[0], e[1]]], glyph: e[2], label: known ? e[2] : null, d: 'M' + x1 + ' ' + a.y + 'C' + r1(x1 + dx) + ' ' + a.y + ' ' + r1(x2 - dx) + ' ' + b.y + ' ' + x2 + ' ' + b.y, mx: r1((x1 + x2) / 2), my: r1((a.y + b.y) / 2) }
     seen[id] = edge
     edges.push(edge)
   })
@@ -114,7 +117,7 @@ function graphPanel(f,i){
   var svg=sv('svg',{'class':'g-svg',tabindex:0,role:'group','aria-label':'Column graph: drag or use the arrow keys to move, the wheel or + and - to zoom, 0 to fit'});
   var vp=sv('g',{'class':'g-vp'}),gE=sv('g',{'class':'g-edges'}),gB=sv('g',{'class':'g-boxes'});vp.appendChild(gE);vp.appendChild(gB);svg.appendChild(vp);
   lay.edges.forEach(function(e){var g=sv('g',{'class':'g-edge '+(GLYPH[e.glyph]||'unk'),'data-keys':e.keys.map(function(k){return k[0]+'>'+k[1]}).join(' ')});
-    g.appendChild(sv('path',{d:e.d}));var t=sv('text',{x:e.mx,y:e.my-4,'class':'g-elabel','text-anchor':'middle'},e.glyph||'?');g.appendChild(t);gE.appendChild(g)});
+    g.appendChild(sv('path',{d:e.d}));if(e.label)g.appendChild(sv('text',{x:e.mx,y:e.my-4,'class':'g-elabel','text-anchor':'middle'},e.label));gE.appendChild(g)});
   lay.boxes.forEach(function(b){
     var g=sv('g',{'class':'g-box'+(b.focus?' focus':'')+(b.collapsed?' collapsed':''),transform:'translate('+b.x+','+b.y+')','data-box':b.id});
     g.appendChild(sv('title',{},b.title));
@@ -136,6 +139,7 @@ function graphPanel(f,i){
       g.appendChild(row)});
     gB.appendChild(g)});
   p.appendChild(svg);
+  if(lay.edges.some(function(e){return!e.label}))p.appendChild(el('div','g-note','Dashed, unlabelled: the engine couldn\u2019t tell how the value changes.'));
   var hint=el('div','g-hint','Drag to move \\u00b7 wheel or pinch to zoom \\u00b7 click a column to light up its path');p.appendChild(hint);
   // Zoom and pan: one transform, kept per focus while levels change.
   var v=state.views[i],moved=false;
@@ -201,6 +205,7 @@ export const GRAPH_CSS = `
 .g-edge path{fill:none;stroke:var(--line-strong);stroke-width:1.4}
 .g-edge.same path{stroke:var(--same)}.g-edge.ren path{stroke:var(--ren)}.g-edge.calc path{stroke:var(--calc)}.g-edge.agg path{stroke:var(--agg)}.g-edge.unk path{stroke:var(--unk);stroke-dasharray:4 3}
 .g-edge path{stroke-opacity:.55}
+.g-note{font-size:12px;color:var(--muted);padding:6px 12px 8px}
 .g-elabel{font:700 11px ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;fill:var(--muted);paint-order:stroke;stroke:var(--bg);stroke-width:3px}
 body.hl .g-edge{opacity:.12}body.hl .g-edge.on{opacity:1}body.hl .g-edge.on path{stroke-opacity:1;stroke-width:2.2}
 body.hl .g-row{opacity:.3}body.hl .g-row.on{opacity:1}body.hl .g-row.on .g-hit{fill:var(--accent-soft)}body.hl .g-row.sel .g-hit{fill:var(--focus)}

From 02a843db4161c57c90293e501a38a01133e8f5f2 Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Thu, 12 Nov 2026 01:07:04 +0800
Subject: [PATCH 16/21] feat: `/lineage-report <model>.<column>` opens the
 report for any column

With an argument, the command traces that column both ways in the project's manifest and opens a report that leads with where the column comes from. It doesn't depend on the last task and never replaces its report. An unknown model or column gets a plain error. Without an argument, nothing changes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VEmKQwEiHMwQ7BdwgPo9sb
---
 plugins/altimate-code/CHANGELOG.md            |  1 +
 .../altimate-code/hooks/impact-report.test.ts | 43 +++++++++++
 plugins/altimate-code/hooks/impact-report.ts  | 76 +++++++++++++++----
 .../altimate-code/hooks/task-impact.test.tsx  | 63 +++++++++++++++
 plugins/altimate-code/hooks/task-impact.tsx   | 70 ++++++++++++++++-
 5 files changed, 236 insertions(+), 17 deletions(-)

diff --git a/plugins/altimate-code/CHANGELOG.md b/plugins/altimate-code/CHANGELOG.md
index bb34ce1..7fb9c89 100644
--- a/plugins/altimate-code/CHANGELOG.md
+++ b/plugins/altimate-code/CHANGELOG.md
@@ -7,6 +7,7 @@ All notable changes to this plugin will be documented in this file.
 ### Added
 - End-of-task column impact: after a task that changed a dbt model, a band sums up each changed column's downstream reach from `impact_analysis`. The task's start copies `target/manifest.json` aside, so the answer reflects the SQL before the task.
 - An offline HTML report, built when **Open report** or `/lineage-report` asks for it: what changed and what to expect downstream in plain words, who consumes it from dbt exposures, then upstream and downstream lineage, two levels by default, and click-to-highlight paths.
+- `/lineage-report <model>.<column>` opens the same report for any column, with no task behind it: where the column comes from first, then where its value goes. It reads the project's manifest as it is now, writes its own file beside the task's report, and an unknown model or column gets a plain error.
 - When a plan goes up for approval, a line above the dialog gives the downstream models, tests and exposures of each model the plan names.
 - Usage events for the report, through altimate-code's telemetry (`tool report-event`): the summary shown, **Open report** pressed, `/lineage-report` run, and the report built, failed or with no browser. The step and the session id only, off under the telemetry opt-out. See PRIVACY.md.
 - The report draws the column lineage as a graph beside the summary: upstream on the left, downstream on the right, opened to fit, with zoom and pan. A click lights a column's path, "more levels" adds one, and a level of more than 12 models folds into one box. The page allows only its own inline script and style. An edge carries a label only when the engine told how the value changes (same, renamed, calculated, aggregated); the rest are dashed and unlabelled, and a note under the graph says so.
diff --git a/plugins/altimate-code/hooks/impact-report.test.ts b/plugins/altimate-code/hooks/impact-report.test.ts
index 6e6e51c..2f827aa 100644
--- a/plugins/altimate-code/hooks/impact-report.test.ts
+++ b/plugins/altimate-code/hooks/impact-report.test.ts
@@ -3,6 +3,7 @@ import { describe, expect, test } from 'claude-code/testing'
 import {
   answerOf,
   changedColumns,
+  columnReportData,
   type ColumnAnswer,
   type ColumnTrace,
   consumersOf,
@@ -20,6 +21,7 @@ import {
   sectionOf,
   summaryLines,
   summaryOf,
+  upstreamWords,
   WINDOWS_EXPLORER,
 } from './impact-report'
 
@@ -257,6 +259,47 @@ describe('a plan', () => {
   })
 })
 
+describe('a column looked up by name', () => {
+  test('says what it is made from one hop up, how far back it goes, where it starts and how sure that is', () => {
+    expect(plain(upstreamWords('fct_orders', 'revenue', UP))).toEqual([
+      '`revenue` in `fct_orders` is aggregated from 1 column one hop up: `int_orders.amount`.',
+      'Followed all the way back, it draws on 2 columns in 2 models, up to 2 hops away.',
+      'Where it starts: `orders`.',
+      'Every upstream model was read.',
+    ])
+    expect(plain(upstreamWords('fct_orders', 'revenue', { ...UP, unresolved: [{ model: 1, reason: 'unparsed' }], truncated: true })).pop()).toBe(
+      "1 model upstream couldn't be read and the trace hit its limit, so more may feed it.",
+    )
+    expect(plain(upstreamWords('fct_orders', 'revenue', null))).toEqual(['Where `fct_orders.revenue` comes from could not be traced.'])
+    expect(plain(upstreamWords('fct_orders', 'revenue', { ...UP, columns: [UP.columns[0]!], edges: [] }))).toEqual([
+      "`revenue` in `fct_orders` reads no column the trace could follow: a constant, say, or SQL the engine couldn't read.",
+    ])
+  })
+
+  test('says where its value goes without talk of a change or a contract', () => {
+    const words = plain(impactWords('fct_orders', 'revenue', TRACE, true))
+    expect(words[0]).toBe(
+      '`fct_orders` has 6 models downstream. The value of `revenue` flows into 3 of them, in 4 columns. A wrong value here shows up there too: `fct_revenue_daily`, `rpt_finance` and `rpt_board`.',
+    )
+    expect(words.some(line => /contract|Expect those|shouldn't change|may change/.test(line))).toBe(false)
+    expect(words).toContain("2 don't carry it: they're downstream of the model, but the value doesn't reach them.")
+  })
+
+  test('its report has no task: it leads with where the column comes from, then where it goes', () => {
+    const data = columnReportData('fct_orders', 'revenue', TRACE, { builtAt: TASK.builtAt, manifest: 'target/manifest.json as it is now' })
+    expect(data).toMatchObject({ title: 'Column lineage · fct_orders.revenue', lookup: { model: 'fct_orders', column: 'revenue' }, changes: [], finishedAt: '' })
+    expect(data.focuses[0]!.upstream).toEqual(upstreamWords('fct_orders', 'revenue', UP))
+    expect(data.focuses[0]!.before).toBeNull()
+    const html = reportHtml(data)
+    const at = (one: string) => html.indexOf(one, html.indexOf('function render(){'))
+    expect(html).toContain("side.appendChild(DATA.lookup?upstreamPanel():ch)")
+    expect(at("if(DATA.lookup){var uc=0")).toBeLessThan(at("if(r){stats.appendChild(stat(r.columns,'columns downstream'))"))
+    expect(html).toContain("'Where it comes from'")
+    expect(html).toContain("DATA.lookup?'Where it goes':'What to expect downstream'")
+    expect(reportData([CHANGE], [TRACE], TASK).lookup).toBeNull()
+  })
+})
+
 describe('the report', () => {
   test('leads with what changed and what to expect, and keeps the levels and paths underneath', () => {
     const html = reportHtml(reportData([{ ...CHANGE, ended: fingerprint('x') }], [TRACE], { ...TASK, movedOn: ['models/fct_orders.sql'] }))
diff --git a/plugins/altimate-code/hooks/impact-report.ts b/plugins/altimate-code/hooks/impact-report.ts
index f389dfd..a145f49 100644
--- a/plugins/altimate-code/hooks/impact-report.ts
+++ b/plugins/altimate-code/hooks/impact-report.ts
@@ -315,6 +315,8 @@ export type ReportFocus = {
   modelLevel: number | null
   /** What to expect downstream, in plain words. */
   impact: Words[]
+  /** Where the column comes from, in plain words: what a report on one column leads with. */
+  upstream: Words[]
   up: ReportSection
   down: ReportSection
   edges: [string, string, string][]
@@ -325,6 +327,8 @@ export type ReportFocus = {
 }
 export type ReportData = {
   title: string
+  /** The column a report on one column is about, asked for by name; null for a task's report. */
+  lookup: { model: string; column: string } | null
   finishedAt: string
   builtAt: string
   manifest: string
@@ -391,8 +395,11 @@ function namesList(names: string[], max = 5): Words {
   return out
 }
 
-/** What to expect downstream of one changed column (or model), in plain words. */
-export function impactWords(model: string, column: string | null, trace: ColumnTrace | undefined): Words[] {
+/**
+ * What to expect downstream of one changed column (or model), in plain words. For a column looked up by
+ * name (`lookup`), where its value goes: nothing changed, so no talk of change or of contracts.
+ */
+export function impactWords(model: string, column: string | null, trace: ColumnTrace | undefined, lookup = false): Words[] {
   const down = trace?.down ?? null
   const level = trace?.modelLevel ?? (down ? reachOf(down).modelLevel : null)
   const downstream: Words = level === null ? [] : level === 0 ? ['Nothing sits downstream of ', { code: model }, '. '] : [{ code: model }, ` has ${count(level, 'model')} downstream. `]
@@ -404,15 +411,15 @@ export function impactWords(model: string, column: string | null, trace: ColumnT
   const r = reachOf(down)
   const lines: Words[] = []
   const value = [...new Set(down.columns.filter(one => one.hop > 0).map(one => one.model))].map(index => down.nodes[index]).filter(Boolean)
-  if (r.models > 0) lines.push([...downstream, 'The value of ', { code: column }, ` flows into ${r.models} of them, in ${count(r.columns, 'column')}. Expect those to change with it: `, ...namesList(carriersOf(down).map(one => one.name)), '.'])
+  if (r.models > 0) lines.push([...downstream, 'The value of ', { code: column }, ` flows into ${r.models} of them, in ${count(r.columns, 'column')}. ${lookup ? 'A wrong value here shows up there too' : 'Expect those to change with it'}: `, ...namesList(carriersOf(down).map(one => one.name)), '.'])
   else if (level !== 0) lines.push([...downstream, 'The value of ', { code: column }, " doesn't flow into any column of theirs."])
   else lines.push(downstream)
-  if (r.mayCarry > 0) lines.push([`${r.mayCarry} more may change: ${r.mayCarry === 1 ? 'it uses' : 'they use'} the value in a way the trace can't follow (a filter or a join, say), ${r.mayCarry === 1 ? 'its' : 'their'} SQL couldn't be read, or ${r.mayCarry === 1 ? 'it reads' : 'they read'} from a model like that.`])
-  if (r.cleared) lines.push([`${r.cleared} shouldn't change: ${r.cleared === 1 ? "it's" : "they're"} downstream of the model, but the value doesn't reach ${r.cleared === 1 ? 'it' : 'them'}.`])
+  if (r.mayCarry > 0) lines.push([`${r.mayCarry} more may ${lookup ? 'carry it' : 'change'}: ${r.mayCarry === 1 ? 'it uses' : 'they use'} the value in a way the trace can't follow (a filter or a join, say), ${r.mayCarry === 1 ? 'its' : 'their'} SQL couldn't be read, or ${r.mayCarry === 1 ? 'it reads' : 'they read'} from a model like that.`])
+  if (r.cleared) lines.push([`${r.cleared} ${lookup ? "don't carry it" : "shouldn't change"}: ${r.cleared === 1 ? "it's" : "they're"} downstream of the model, but the value doesn't reach ${r.cleared === 1 ? 'it' : 'them'}.`])
   const self = down.nodes[down.columns.find(one => one.hop === 0)?.model ?? -1]
-  if (self?.contract) lines.push([{ code: model }, ' enforces a contract, so a type change can fail its build.'])
+  if (self?.contract && !lookup) lines.push([{ code: model }, ' enforces a contract, so a type change can fail its build.'])
   const contracts = value.filter(one => one!.contract).map(one => String(one!.name ?? one!.id))
-  if (contracts.length > 0) lines.push([`${contracts.length === 1 ? 'One model it reaches enforces' : `${contracts.length} models it reaches enforce`} a contract, so a type change can fail the build there: `, ...namesList(contracts), '.'])
+  if (contracts.length > 0 && !lookup) lines.push([`${contracts.length === 1 ? 'One model it reaches enforces' : `${contracts.length} models it reaches enforce`} a contract, so a type change can fail the build there: `, ...namesList(contracts), '.'])
   const tests = value.reduce((sum, one) => sum + (num(one!.tests) ?? 0), 0)
   if (tests > 0) lines.push([`Tests on the models it reaches: ${tests}.`])
   const short = [r.unresolved ? `${count(r.unresolved, "model")} couldn't be read` : '', r.truncated ? 'the trace hit its limit' : ''].filter(Boolean).join(' and ')
@@ -420,8 +427,30 @@ export function impactWords(model: string, column: string | null, trace: ColumnT
   return lines
 }
 
+const DERIVED: Record<string, string> = { '=': 'the same value as', '~': 'renamed from', 'ƒ': 'calculated from', 'Σ': 'aggregated from' }
+
+/** Where one column comes from, in plain words: what it is made from one hop up, how far back it goes, and where it starts. */
+export function upstreamWords(model: string, column: string, up: ColumnAnswer | null): Words[] {
+  if (!up) return [['Where ', { code: `${model}.${column}` }, ' comes from could not be traced.']]
+  const read = up.columns.filter(one => one.hop > 0)
+  const name = (index: number) => nameOf(up, index)
+  if (read.length === 0) return [[{ code: column }, ' in ', { code: model }, " reads no column the trace could follow: a constant, say, or SQL the engine couldn't read."]]
+  const direct = read.filter(one => one.hop === 1)
+  const made = DERIVED[focusHow(up)?.glyph ?? ''] ?? 'made from'
+  const lines: Words[] = [[{ code: column }, ' in ', { code: model }, ` is ${made} ${count(direct.length, 'column')} one hop up: `, ...namesList(direct.map(one => `${name(one.model)}.${one.column}`)), '.']]
+  const models = new Set(read.map(one => one.model)).size
+  const hops = Math.max(...read.map(one => one.hop))
+  if (hops > 1) lines.push([`Followed all the way back, it draws on ${count(read.length, 'column')} in ${count(models, 'model')}, up to ${count(hops, 'hop')} away.`])
+  const starts = [...new Set(read.filter(one => one.end).map(one => name(one.model)))]
+  if (starts.length > 0) lines.push(['Where it starts: ', ...namesList(starts), '.'])
+  const unread = (up.unresolved ?? []).length
+  const short = [unread ? `${count(unread, 'model')} upstream couldn't be read` : '', up.truncated ? 'the trace hit its limit' : ''].filter(Boolean).join(' and ')
+  lines.push([short ? `${short.charAt(0).toUpperCase()}${short.slice(1)}, so more may feed it.` : 'Every upstream model was read.'])
+  return lines
+}
+
 /** The page's data for one changed column (or one model, when no column changed). */
-export function focusOf(change: ModelChange, column: ModelChange['columns'][number] | null, trace: ColumnTrace | undefined): ReportFocus {
+export function focusOf(change: ModelChange, column: ModelChange['columns'][number] | null, trace: ColumnTrace | undefined, lookup = false): ReportFocus {
   const down = trace?.down ?? null
   const up = trace?.up ?? null
   const any = down ?? up
@@ -448,7 +477,8 @@ export function focusOf(change: ModelChange, column: ModelChange['columns'][numb
     after: column?.after ?? null,
     reach,
     modelLevel: trace?.modelLevel ?? reach?.modelLevel ?? null,
-    impact: impactWords(change.model, column?.name ?? null, trace),
+    impact: impactWords(change.model, column?.name ?? null, trace, lookup),
+    upstream: column ? upstreamWords(change.model, column.name, up) : [],
     up: sectionOf(up, !up && !!column),
     down: sectionOf(down, !down && !!column),
     edges,
@@ -474,6 +504,7 @@ export function reportData(changes: ModelChange[], traces: ColumnTrace[], task:
   const names = changes.map(one => one.model)
   return {
     title: `Column impact · ${names.slice(0, 2).join(', ')}${names.length > 2 ? ` +${names.length - 2}` : ''}`,
+    lookup: null,
     ...task,
     defaultLevels: DEFAULT_LEVELS,
     changes: changes.map(one => ({ model: one.model, file: one.file, columns: one.columns })),
@@ -482,6 +513,23 @@ export function reportData(changes: ModelChange[], traces: ColumnTrace[], task:
   }
 }
 
+/** A report on one column asked for by name, apart from any task: where it comes from first, then where it goes. */
+export function columnReportData(model: string, column: string, trace: ColumnTrace, built: { builtAt: string; manifest: string }): ReportData {
+  const change: ModelChange = { model, file: '', root: '', columns: [] }
+  return {
+    title: `Column lineage · ${model}.${column}`,
+    lookup: { model, column },
+    finishedAt: '',
+    builtAt: built.builtAt,
+    manifest: built.manifest,
+    movedOn: [],
+    defaultLevels: DEFAULT_LEVELS,
+    changes: [],
+    focuses: [focusOf(change, { name: column, before: null, after: null }, trace, true)],
+    consumers: mergeConsumers([trace]),
+  }
+}
+
 /** JSON safe to place inside a script element: no tag can close it early. */
 const scriptJson = (value: unknown) =>
   JSON.stringify(value).replace(/</g, '\\u003c').replace(/>/g, '\\u003e').replace(/&/g, '\\u0026').replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029')
@@ -654,7 +702,8 @@ function stat(n,label,dim){var d=el('div','stat'+(dim?' dim':''));d.appendChild(
 function fold(title,count,items){var d=el('details','panel fold');var s=el('summary',null,title+' ');s.appendChild(el('span',null,'('+(count==null?'not reported':count)+')'));d.appendChild(s);var ul=el('ul');items.forEach(function(it){ul.appendChild(it)});if(!items.length)ul.appendChild(el('li','why',count==null?'Not reported by this altimate-code build.':count?'Only the count is known.':'None.'));d.appendChild(ul);return d}
 function li(name,rest){var l=el('li');l.appendChild(el('span','mono',name));if(rest){l.appendChild(document.createTextNode(' '));l.appendChild(el('span','why',rest))}return l}
 function words(parent,line){line.forEach(function(w){if(typeof w==='string')parent.appendChild(document.createTextNode(w));else parent.appendChild(el('code',null,w.code))});return parent}
-function impactPanel(){var p=el('div','panel impact');p.appendChild(el('h2',null,'What to expect downstream'));DATA.focuses.forEach(function(g){if(DATA.focuses.length>1)p.appendChild(el('h3','mono',g.column?g.model+'.'+g.column:g.model));var ul=el('ul');g.impact.forEach(function(line){ul.appendChild(words(el('li'),line))});p.appendChild(ul)});return p}
+function upstreamPanel(){var f=DATA.focuses[state.focus],p=el('div','panel impact upstream');p.appendChild(el('h2',null,'Where it comes from'));var ul=el('ul');f.upstream.forEach(function(line){ul.appendChild(words(el('li'),line))});p.appendChild(ul);return p}
+function impactPanel(){var p=el('div','panel impact');p.appendChild(el('h2',null,DATA.lookup?'Where it goes':'What to expect downstream'));DATA.focuses.forEach(function(g){if(DATA.focuses.length>1)p.appendChild(el('h3','mono',g.column?g.model+'.'+g.column:g.model));var ul=el('ul');g.impact.forEach(function(line){ul.appendChild(words(el('li'),line))});p.appendChild(ul)});return p}
 function consumerItem(c){var l=el('li');if(c.url){var a=el('a',null,c.label);a.href=c.url;a.rel='noopener noreferrer';a.target='_blank';l.appendChild(a)}else l.appendChild(document.createTextNode(c.label));var bits=[c.type];if(c.via.length)bits.push('reads '+c.via.join(', '));if(c.owner)bits.push('owner: '+c.owner);if(DATA.focuses.length>1&&c.columns.length)bits.push('for '+c.columns.join(', '));l.appendChild(el('span','why',' \\u00b7 '+bits.join(' \\u00b7 ')));return l}
 var TIERS=[['carries','Read a model the value reaches'],['may_carry','Read a model that may carry it'],['cleared',"Read only models the value doesn't reach"],[null,'Read this model or one downstream of it']];
 function consumersPanel(){var c=DATA.consumers,p=el('div','panel consumers');p.appendChild(el('h2',null,'Who consumes it'));
@@ -667,14 +716,15 @@ function consumersPanel(){var c=DATA.consumers,p=el('div','panel consumers');p.a
 function render(){
   var f=DATA.focuses[state.focus],i=state.focus;app.textContent='';
   var bar=el('div','pathbar');bar.id='pathbar';var wrap=el('div','wrap');wrap.appendChild(bar);
-  var top=el('header','top');top.appendChild(el('h1',null,DATA.title));top.appendChild(el('span','when','Task finished '+DATA.finishedAt+' \\u00b7 report built '+DATA.builtAt+' \\u00b7 read from '+DATA.manifest));wrap.appendChild(top);
+  var top=el('header','top');top.appendChild(el('h1',null,DATA.title));top.appendChild(el('span','when',(DATA.lookup?'Report built '+DATA.builtAt:'Task finished '+DATA.finishedAt+' \\u00b7 report built '+DATA.builtAt)+' \\u00b7 read from '+DATA.manifest));wrap.appendChild(top);
   if(DATA.movedOn.length)wrap.appendChild(el('div','note warn','\\u26a0 Since this task ended, '+DATA.movedOn.join(', ')+(DATA.movedOn.length===1?' has':' have')+' changed. This report describes the task, not the files as they are now.'));
   var ch=el('div','panel changes');ch.appendChild(el('h2',null,'What this task changed'));DATA.changes.forEach(function(c){var m=el('div','change-model mono',c.model);m.appendChild(el('span','file',c.file));ch.appendChild(m);if(!c.columns.length){ch.appendChild(el('div','empty','No output column changed (a filter or a join): only the model-level count applies.'));return}var d=el('div','diff');c.columns.forEach(function(col){d.appendChild(el('div','col-name mono',col.name));var was=el('div','was mono'+(col.before?'':' none'),col.before||'(not in the model before)');var now=el('div','now mono'+(col.after?'':' none'),col.after||'(removed)');if(col.before&&col.after&&col.before===col.after){d.appendChild(el('div','same','Expression unchanged; the column is named on a changed line.'));d.appendChild(el('div'))}else{d.appendChild(was);d.appendChild(now)}});ch.appendChild(d)});
   var page=el('div','page'),side=el('div','side'),main=el('div','main');page.appendChild(side);page.appendChild(main);
-  side.appendChild(ch);side.appendChild(impactPanel());side.appendChild(consumersPanel());
+  side.appendChild(DATA.lookup?upstreamPanel():ch);side.appendChild(impactPanel());side.appendChild(consumersPanel());
   var deep=el('div','deep');deep.appendChild(el('h2',null,'Column by column'));deep.appendChild(el('p',null,'Two levels up and down, with more on request. Click any column to light up its path; the rest dims and stays on the page.'));main.appendChild(deep);
   if(DATA.focuses.length>1){var tabs=el('div','tabs');tabs.setAttribute('role','tablist');DATA.focuses.forEach(function(g,j){var t=el('button','tab',g.column?g.model+'.'+g.column:g.model+' (model)');t.type='button';t.setAttribute('role','tab');t.setAttribute('aria-selected',j===i?'true':'false');t.addEventListener('click',function(){state.focus=j;state.selected=null;render()});tabs.appendChild(t)});main.appendChild(tabs)}
   var r=f.reach,stats=el('div','stats');
+  if(DATA.lookup){var uc=0,um={},uh=0,ue=!!f.up.error;f.up.hops.forEach(function(h){uh=Math.max(uh,h.hop);h.models.forEach(function(m){um[m.id]=1;uc+=m.columns.length})});stats.appendChild(stat(ue?null:uc,'columns upstream'));stats.appendChild(stat(ue?null:Object.keys(um).length,'models upstream'));stats.appendChild(stat(ue?null:uh,'hops up'))}
   if(r){stats.appendChild(stat(r.columns,'columns downstream'));stats.appendChild(stat(r.models,'models carry it'));stats.appendChild(stat(r.ends,'end columns'));stats.appendChild(stat(r.mayCarry,'may carry it',!r.mayCarry));stats.appendChild(stat(r.cleared,'cleared',r.cleared==null))}
   stats.appendChild(stat(f.modelLevel,'downstream at model level',true));main.appendChild(stats);
   if(r&&(r.unresolved||r.truncated))main.appendChild(el('div','note warn','\\u26a0 Lower bound: '+[r.unresolved?plural(r.unresolved,'model')+' could not be read':'',r.truncated?'the trace hit its limit':''].filter(Boolean).join('; ')+'. See \\u201cNot resolved\\u201d below.'));
@@ -683,7 +733,7 @@ function render(){
   var lg=el('div','legend');['=','~','\\u0192','\\u03a3','?'].forEach(function(g){var s=el('span');s.appendChild(glyph(g,false));s.appendChild(document.createTextNode(HOW[g]));lg.appendChild(s)});var bn=el('span');bn.appendChild(glyph('=',true));bn.appendChild(document.createTextNode('matched by name'));lg.appendChild(bn);var cb=el('span');cb.appendChild(el('span','badge c','C'));cb.appendChild(document.createTextNode(' contract enforced'));lg.appendChild(cb);main.appendChild(lg);
   var graph=null;if(!state.list){graph=graphPanel(f,i);main.appendChild(graph)}else{var lb=el('div','g-bar list-bar');lb.appendChild(el('span','g-title','Column list'));var gb=el('button','g-btn','Graph');gb.type='button';gb.addEventListener('click',function(){state.list=false;render()});lb.appendChild(gb);main.appendChild(lb);
   main.appendChild(section(f,i,'up'));
-  var fc=el('div','panel focus');fc.appendChild(el('div','label','The changed column'));var ti=el('div','title');if(f.key){ti.appendChild(colButton({key:f.key,column:f.model+'.'+(f.column||''),glyph:f.glyph||'?',byName:f.byName,end:false,type:null}))}else ti.appendChild(el('span','mono',f.column?f.model+'.'+f.column:f.model));fc.appendChild(ti);var hw=f.glyph?HOW[f.glyph]||'unknown':'';fc.appendChild(el('div','empty',(hw?hw.charAt(0).toUpperCase()+hw.slice(1)+' from what it reads'+(f.byName?' (matched by name)':'')+'. ':'')+(f.key?'Click any column to light up its path.':'')));main.appendChild(fc);
+  var fc=el('div','panel focus');fc.appendChild(el('div','label',DATA.lookup?'The column':'The changed column'));var ti=el('div','title');if(f.key){ti.appendChild(colButton({key:f.key,column:f.model+'.'+(f.column||''),glyph:f.glyph||'?',byName:f.byName,end:false,type:null}))}else ti.appendChild(el('span','mono',f.column?f.model+'.'+f.column:f.model));fc.appendChild(ti);var hw=f.glyph?HOW[f.glyph]||'unknown':'';fc.appendChild(el('div','empty',(hw?hw.charAt(0).toUpperCase()+hw.slice(1)+' from what it reads'+(f.byName?' (matched by name)':'')+'. ':'')+(f.key?'Click any column to light up its path.':'')));main.appendChild(fc);
   main.appendChild(section(f,i,'down'))}
   wrap.appendChild(page);
   wrap.appendChild(fold('Also reads it, outside the select',f.alsoReads.length,f.alsoReads.map(function(a){return li(a.name,'reads '+a.columns.join(', ')+(a.downstream!=null?' \\u00b7 '+plural(a.downstream,'model')+' downstream of it':''))})));
diff --git a/plugins/altimate-code/hooks/task-impact.test.tsx b/plugins/altimate-code/hooks/task-impact.test.tsx
index 3f043b9..e14db34 100644
--- a/plugins/altimate-code/hooks/task-impact.test.tsx
+++ b/plugins/altimate-code/hooks/task-impact.test.tsx
@@ -40,6 +40,8 @@ type Options = {
   cliFails?: boolean
   /** What impact_analysis adds to its answer. */
   impact?: (args: Record<string, any>) => Record<string, unknown>
+  /** The CLI's whole answer for a call, in place of the usual one. */
+  answer?: (args: Record<string, any>) => { status: string; output: string; metadata: Record<string, unknown> } | undefined
 }
 
 /**
@@ -136,6 +138,11 @@ async function start($: any, on: any, options: Options = {}) {
     if (bin === 'altimate') {
       const args = JSON.parse(String(argv[argv.indexOf('--args') + 1] ?? '{}'))
       if (options.cliFails) return { value: { exitCode: 1, stdout: JSON.stringify({ status: 'error', output: 'no', metadata: {} }), stderr: '' } }
+      const own = options.answer?.(args)
+      if (own) {
+        tools.push(args)
+        return ok(JSON.stringify(own))
+      }
       return ok(JSON.stringify({ status: 'ok', output: 'Impact', metadata: impactBody(args) }))
     }
     if (bin === 'mkdir') return ok()
@@ -527,3 +534,59 @@ test('macOS opens with open; /lineage-report before any report says so', async (
   await $.command.run({ command: 'lineage-report', args: '' } as any)
   expect(runs).toContainEqual(['open', REPORT])
 })
+
+const COLUMN_REPORT = `${ROOT}/target/.altimate-lineage/column-report.html`
+
+test('/lineage-report model.column opens that column\'s report, upstream first, with no task behind it, and leaves the task\'s report alone', async ($, on) => {
+  const { tools, writes, runs, toasts, clock } = await start($, on, { openers: { 'xdg-open': 0 } })
+  const out: any = await $.command.run({ command: 'lineage-report', args: ' fct_orders.revenue ' } as any)
+  await clock.settle()
+  expect(out.text).toBe(`Opened the column lineage report for fct_orders.revenue: ${COLUMN_REPORT}`)
+  expect(toasts).toContain('Tracing fct_orders.revenue both ways…')
+  expect(directional(tools).map(one => [one.direction, one.model, one.column, one.manifest_path]).sort()).toEqual([
+    ['downstream', 'fct_orders', 'revenue', MANIFEST],
+    ['upstream', 'fct_orders', 'revenue', MANIFEST],
+  ])
+  expect(runs).toContainEqual(['xdg-open', COLUMN_REPORT])
+  const report = embedded(writes.get(COLUMN_REPORT)!)
+  expect(report.lookup).toEqual({ model: 'fct_orders', column: 'revenue' })
+  expect(report.title).toBe('Column lineage · fct_orders.revenue')
+  expect(report.changes).toEqual([])
+  expect(report.focuses[0].upstream.length).toBeGreaterThan(0)
+  expect(writes.has(REPORT)).toBe(false)
+  // Without an argument it is still the last task's report, and there is none.
+  const none: any = await $.command.run({ command: 'lineage-report', args: '' } as any)
+  expect(none.text).toBe('No column impact report yet: one can be built after a task changes a dbt model.')
+})
+
+test('/lineage-report with a model the manifest lacks, a column the model lacks, or no model.column says so plainly and opens nothing', async ($, on) => {
+  const { runs, writes, tools } = await start($, on, {
+    openers: { 'xdg-open': 0 },
+    answer: args =>
+      args.model === 'nope'
+        ? { status: 'ok', output: 'Model "nope" not found in manifest. Available models: fct_orders, int_orders', metadata: { success: false } }
+        : args.column === 'nothing'
+          ? { status: 'ok', output: 'Impact', metadata: { success: true, model: 'fct_orders', column_answer_error: 'fct_orders has no column nothing; its columns are order_id, revenue' } }
+          : undefined,
+  })
+  const model: any = await $.command.run({ command: 'lineage-report', args: 'nope.revenue' } as any)
+  expect(model.text).toBe('Model "nope" not found in manifest. Available models: fct_orders, int_orders')
+  const column: any = await $.command.run({ command: 'lineage-report', args: 'fct_orders.nothing' } as any)
+  expect(column.text).toBe('fct_orders has no column nothing; its columns are order_id, revenue')
+  const asked = tools.length
+  for (const args of ['revenue', 'fct_orders.', '.revenue', 'fct orders.revenue']) {
+    const usage: any = await $.command.run({ command: 'lineage-report', args } as any)
+    expect(usage.text).toMatch(/^Usage: \/lineage-report for the last task's report, or \/lineage-report <model>\.<column>/)
+  }
+  expect(tools.length).toBe(asked)
+  expect(runs.some(argv => argv[0] === 'xdg-open')).toBe(false)
+  expect(writes.has(COLUMN_REPORT)).toBe(false)
+})
+
+test('/lineage-report takes a unique id as the model, the column after the last dot, and names the model as the CLI does', async ($, on) => {
+  const { tools, writes } = await start($, on, { openers: { 'xdg-open': 0 }, impact: () => ({ model: 'fct_orders' }) })
+  const out: any = await $.command.run({ command: 'lineage-report', args: 'model.shop.fct_orders.revenue' } as any)
+  expect(out.text).toBe(`Opened the column lineage report for fct_orders.revenue: ${COLUMN_REPORT}`)
+  expect(directional(tools).every(one => one.model === 'model.shop.fct_orders' && one.column === 'revenue')).toBe(true)
+  expect(embedded(writes.get(COLUMN_REPORT)!).lookup).toEqual({ model: 'fct_orders', column: 'revenue' })
+})
diff --git a/plugins/altimate-code/hooks/task-impact.tsx b/plugins/altimate-code/hooks/task-impact.tsx
index 3ddd98a..eb1d51c 100644
--- a/plugins/altimate-code/hooks/task-impact.tsx
+++ b/plugins/altimate-code/hooks/task-impact.tsx
@@ -9,6 +9,7 @@ import { later, runAltimate } from './altimate-cli'
 import {
   answerOf,
   changedColumns,
+  columnReportData,
   type ColumnTrace,
   consumersOf,
   fingerprint,
@@ -34,6 +35,9 @@ const RUNNING_MANIFEST = 'manifest-before.json'
 const TASK_MANIFEST = 'task-manifest.json'
 // What a report needs of the last finished task, so one can be built after a restart too.
 const TASK_FILE = 'last-task.json'
+// A report on one column, asked for by name; apart from the task's, which it never replaces.
+const COLUMN_REPORT = 'column-report.html'
+const REPORT_USAGE = 'Usage: /lineage-report for the last task\'s report, or /lineage-report <model>.<column> (say int_orders.amount) for where one column comes from and where it goes.'
 const EDIT_TOOLS = new Set(['Edit', 'Write', 'MultiEdit'])
 // The most changed models one task traces; the rest are named in the log.
 const MAX_MODELS = 5
@@ -438,6 +442,61 @@ async function buildAndOpen($: EngineInterface): Promise<string> {
   return opened ? `Opened the column impact report for the task that finished at ${stamp(done.finishedAt)}: ${built.path}` : `No browser could be opened. The report is at ${built.path}`
 }
 
+/** What /lineage-report was asked for: the last task's report, one column's, or something it can't read. */
+export function reportRequest(args: string): { kind: 'task' } | { kind: 'column'; model: string; column: string } | { kind: 'usage' } {
+  const text = args.trim()
+  if (!text) return { kind: 'task' }
+  // The column is what follows the last dot, so the model can be a name or a unique id (model.shop.int_orders).
+  const dot = text.lastIndexOf('.')
+  if (/\s/.test(text) || dot <= 0 || dot === text.length - 1) return { kind: 'usage' }
+  return { kind: 'column', model: text.slice(0, dot), column: text.slice(dot + 1) }
+}
+
+/** Traces one column both ways in the project's manifest as it is now and writes its report; a plain error when it can't. */
+async function buildColumnReport($: EngineInterface, model: string, column: string): Promise<{ path: string; name: string } | { error: string }> {
+  const root = await projectRoot($, await $.session.root().catch(() => '.'), false).catch(() => null)
+  if (!root) return { error: 'No dbt project here: /lineage-report <model>.<column> reads the target/manifest.json of the dbt project this session runs in.' }
+  const manifest = `${root}/target/manifest.json`
+  if (!(await $.fs.exists(manifest).catch(() => false))) return { error: 'This project has no target/manifest.json yet. Run `dbt parse` or `dbt compile`, then ask again.' }
+  const args = { manifest_path: manifest, model, column, change_type: 'modify' }
+  // Through the CLI, as for a task: nobody asked for these calls by name.
+  const [down, up] = await Promise.all((['downstream', 'upstream'] as const).map(direction => runTool($, 'impact_analysis', { ...args, direction }, true).catch(() => null)))
+  for (const result of [down, up]) {
+    const meta = result?.metadata as any
+    // The model isn't in the manifest: the CLI's own words, which name some that are.
+    if (meta?.success === false && result?.text) return { error: result.text.split('\n')[0]! }
+    if (typeof meta?.column_answer_error === 'string') return { error: meta.column_answer_error }
+  }
+  if (!down?.ok || !up?.ok) return { error: `The lineage of ${model}.${column} could not be traced${down?.text || up?.text ? `: ${(down?.text || up?.text)!.split('\n')[0]}` : ''}.` }
+  const downAnswer = answerOf(down.metadata)
+  const upAnswer = answerOf(up.metadata)
+  if (!downAnswer && !upAnswer) return { error: 'This altimate-code traces no single column. Update it to use /lineage-report <model>.<column>.' }
+  const name = typeof (down.metadata as any)?.model === 'string' ? String((down.metadata as any).model) : model
+  const trace: ColumnTrace = { model: name, column, down: downAnswer, up: upAnswer, modelLevel: modelLevelOf(down.metadata), failed: false, consumers: consumersOf(down.metadata) }
+  const data = columnReportData(name, column, trace, { builtAt: stamp(await $.clock.now()), manifest: 'target/manifest.json as it is now' })
+  const path = `${root}/${LINEAGE_DIR}/${COLUMN_REPORT}`
+  try {
+    await $.process.run(['mkdir', '-p', `${root}/${LINEAGE_DIR}`], { timeoutMs: 5_000 }).catch(() => null)
+    await $.fs.write(path, reportHtml(data))
+    return { path, name: `${name}.${column}` }
+  } catch (error) {
+    return { error: `The report could not be written: ${String(error)}` }
+  }
+}
+
+/** /lineage-report <model>.<column>: builds that column's report and opens it; what to say about it. Leaves the band alone. */
+async function openColumnReport($: EngineInterface, model: string, column: string): Promise<string> {
+  $.ui.toast(`Tracing ${model}.${column} both ways…`)
+  const built = await buildColumnReport($, model, column)
+  if ('error' in built) {
+    reportEvent($, 'build_failed')
+    return built.error
+  }
+  const opened = await openReport($, built.path)
+  reportEvent($, opened ? 'built' : 'no_browser')
+  return opened ? `Opened the column lineage report for ${built.name}: ${built.path}` : `No browser could be opened. The report is at ${built.path}`
+}
+
 /** Registers /lineage-report; called from the plugin's one session.start hook. */
 export async function startTaskImpact($: EngineInterface) {
   task = null
@@ -446,7 +505,8 @@ export async function startTaskImpact($: EngineInterface) {
   await update($, planAtom, () => null)
   await $.command.register({
     name: REPORT_COMMAND,
-    description: 'Build and open the column impact report of the last task that changed a dbt model: what changed and what it reaches',
+    description: 'Open the column impact report of the last task that changed a dbt model, or with model.column, where that column comes from and where it goes',
+    argumentHint: '[model.column]',
   })
 }
 
@@ -525,10 +585,12 @@ export function taskTurnComplete($: EngineInterface, e: { agentId?: string }) {
   later($, () => finishTask($, done).catch(error => $.ui.log(`lineage-summary · failed: ${String(error)}`)))
 }
 
-/** /lineage-report: builds the last finished task's report and opens it. */
+/** /lineage-report: builds the last finished task's report and opens it; with model.column, that column's. */
 export function registerTaskImpact(on: On) {
-  on('command.run', { command: REPORT_COMMAND }, async $ => {
+  on('command.run', { command: REPORT_COMMAND }, async ($, e) => {
+    const asked = reportRequest(String(e.args ?? ''))
+    if (asked.kind === 'usage') return { text: REPORT_USAGE }
     reportEvent($, 'command_run')
-    return { text: await buildAndOpen($) }
+    return { text: asked.kind === 'column' ? await openColumnReport($, asked.model, asked.column) : await buildAndOpen($) }
   })
 }

From 9f62178bfa1c2d2f24f8533fdcd24ecd0d81bda0 Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Thu, 12 Nov 2026 01:09:46 +0800
Subject: [PATCH 17/21] fix: a click on a graph column counts when the pointer
 drifts a little

A press and release on the same column, or on a folded level, within 12 px is a click. A press that moved more, or started on the canvas, still pans. Before, any move of 5 px or more while pressed made a click a drag, and nothing lit up.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VEmKQwEiHMwQ7BdwgPo9sb
---
 plugins/altimate-code/CHANGELOG.md            |  2 +-
 plugins/altimate-code/hooks/impact-report.ts  |  3 +-
 .../altimate-code/hooks/report-graph.test.ts  | 27 ++++++++++++++++-
 plugins/altimate-code/hooks/report-graph.ts   | 30 +++++++++++++++----
 4 files changed, 53 insertions(+), 9 deletions(-)

diff --git a/plugins/altimate-code/CHANGELOG.md b/plugins/altimate-code/CHANGELOG.md
index 7fb9c89..c26f101 100644
--- a/plugins/altimate-code/CHANGELOG.md
+++ b/plugins/altimate-code/CHANGELOG.md
@@ -10,7 +10,7 @@ All notable changes to this plugin will be documented in this file.
 - `/lineage-report <model>.<column>` opens the same report for any column, with no task behind it: where the column comes from first, then where its value goes. It reads the project's manifest as it is now, writes its own file beside the task's report, and an unknown model or column gets a plain error.
 - When a plan goes up for approval, a line above the dialog gives the downstream models, tests and exposures of each model the plan names.
 - Usage events for the report, through altimate-code's telemetry (`tool report-event`): the summary shown, **Open report** pressed, `/lineage-report` run, and the report built, failed or with no browser. The step and the session id only, off under the telemetry opt-out. See PRIVACY.md.
-- The report draws the column lineage as a graph beside the summary: upstream on the left, downstream on the right, opened to fit, with zoom and pan. A click lights a column's path, "more levels" adds one, and a level of more than 12 models folds into one box. The page allows only its own inline script and style. An edge carries a label only when the engine told how the value changes (same, renamed, calculated, aggregated); the rest are dashed and unlabelled, and a note under the graph says so.
+- The report draws the column lineage as a graph beside the summary: upstream on the left, downstream on the right, opened to fit, with zoom and pan. A click lights a column's path, "more levels" adds one, and a level of more than 12 models folds into one box. The page allows only its own inline script and style. An edge carries a label only when the engine told how the value changes (same, renamed, calculated, aggregated); the rest are dashed and unlabelled, and a note under the graph says so. A click on a column counts even when the hand drifts a few pixels (up to 12) before letting go; a longer drag still pans.
 
 ### Changed
 - The per-edit impact note no longer shows as a toast and band; it still goes to Claude's context with the edit's result. A lookup that missed its time or failed still shows a toast.
diff --git a/plugins/altimate-code/hooks/impact-report.ts b/plugins/altimate-code/hooks/impact-report.ts
index a145f49..2038665 100644
--- a/plugins/altimate-code/hooks/impact-report.ts
+++ b/plugins/altimate-code/hooks/impact-report.ts
@@ -2,7 +2,7 @@
 // and a self-contained HTML report. Pure functions only; the hooks live in task-impact.tsx.
 
 import type { PlanImpactView, Reach, TaskSummaryView } from '../types'
-import { GRAPH_CSS, GRAPH_VIEW_JS, graphLayout } from './report-graph'
+import { GRAPH_CSS, GRAPH_VIEW_JS, graphLayout, pressIsClick } from './report-graph'
 import { selectItems, touchedColumns } from './lineage-graph'
 
 export type { PlanImpactView, Reach, TaskSummaryView }
@@ -749,6 +749,7 @@ function applyHighlight(){var f=DATA.focuses[state.focus],bar=document.getElemen
   var shown={};cols.forEach(function(c){shown[c.dataset.key]=1});var hidden=Object.keys(p.all).filter(function(k){return!shown[k]}).length;
   bar.textContent='';bar.appendChild(el('span',null,'Path of '+state.selected.split('|')[0].split('.').pop()+'.'+state.selected.split('|').pop()+': '+plural(p.up,'column')+' upstream, '+plural(p.down,'column')+' downstream'+(hidden?' \\u00b7 '+hidden+' more on hidden levels or folded models':'')));var clr=el('button',null,'Clear');clr.type='button';clr.addEventListener('click',function(){select(state.selected)});bar.appendChild(clr)}
 ${graphLayout.toString()}
+${pressIsClick.toString()}
 ${GRAPH_VIEW_JS}
 document.addEventListener('keydown',function(e){if(e.key==='Escape'&&state.selected)select(state.selected)});
 render();
diff --git a/plugins/altimate-code/hooks/report-graph.test.ts b/plugins/altimate-code/hooks/report-graph.test.ts
index 42525c8..f306f4b 100644
--- a/plugins/altimate-code/hooks/report-graph.test.ts
+++ b/plugins/altimate-code/hooks/report-graph.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'claude-code/testing'
-import { graphLayout as layoutOf } from './report-graph'
+import { graphLayout as layoutOf, pressIsClick } from './report-graph'
 import { type ColumnAnswer, type ModelChange, reportData, reportHtml } from './impact-report'
 
 type Layout = {
@@ -115,6 +115,31 @@ describe('report graph layout', () => {
   })
 })
 
+describe('a press on the graph', () => {
+  const row = 'row:model.shop.fct|revenue'
+  test('on a column, released on it a few pixels away, is a click: a hand drifts while clicking', () => {
+    expect(pressIsClick({ x: 100, y: 50, target: row }, { x: 100, y: 50, target: row })).toBe(true)
+    expect(pressIsClick({ x: 100, y: 50, target: row }, { x: 103, y: 52, target: row })).toBe(true)
+    expect(pressIsClick({ x: 100, y: 50, target: row }, { x: 93, y: 42, target: row })).toBe(true)
+    expect(pressIsClick({ x: 100, y: 50, target: 'box:2' }, { x: 106, y: 46, target: 'box:2' })).toBe(true)
+  })
+
+  test('that moves further, ends on something else, or starts on the canvas is a drag', () => {
+    expect(pressIsClick({ x: 100, y: 50, target: row }, { x: 113, y: 50, target: row })).toBe(false)
+    expect(pressIsClick({ x: 100, y: 50, target: row }, { x: 102, y: 51, target: 'row:model.shop.a|revenue' })).toBe(false)
+    expect(pressIsClick({ x: 100, y: 50, target: row }, { x: 101, y: 50, target: null })).toBe(false)
+    expect(pressIsClick({ x: 100, y: 50, target: null }, { x: 100, y: 50, target: null })).toBe(false)
+  })
+
+  test('the page decides a pointer click at its release, and a column\'s own click event only serves the keyboard and scripts', () => {
+    const html = reportHtml(reportData([CHANGE], [{ model: 'fct', column: 'revenue', down: answer(['a']), up: UP, modelLevel: null, failed: false }], TASK))
+    expect(html).toContain('function pressIsClick(')
+    expect(html).toContain('ok=pressIsClick(press,{x:ev.clientX,y:ev.clientY,target:targetOf(document.elementFromPoint(ev.clientX,ev.clientY))})')
+    expect(html).toContain("row.addEventListener('click',function(ev){ev.stopPropagation();if(tookPress)return;select(r.key)})")
+    expect(html).not.toContain('if(moved)return;ev.stopPropagation()')
+  })
+})
+
 describe('report page', () => {
   test('allows only its own inline script and style, and carries the graph', () => {
     const html = reportHtml(reportData([CHANGE], [{ model: 'fct', column: 'revenue', down: answer(['a']), up: UP, modelLevel: null, failed: false }], TASK))
diff --git a/plugins/altimate-code/hooks/report-graph.ts b/plugins/altimate-code/hooks/report-graph.ts
index e1e6bf4..1277d4a 100644
--- a/plugins/altimate-code/hooks/report-graph.ts
+++ b/plugins/altimate-code/hooks/report-graph.ts
@@ -92,16 +92,26 @@ export function graphLayout(f: any, levels: { up: number; down: number }, expand
   return { boxes: boxes, edges: edges, bounds: { x: minX, y: minY, w: maxX - minX, h: maxY - minY }, focus: fb ? { x: fb.x + fb.w / 2, y: fb.y + fb.h / 2 } : { x: 0, y: 0 } }
 }
 
+/**
+ * `pressIsClick(press, release)`: whether a press and release on the graph is a click on what was pressed, a column or a
+ * folded level. It is when both are on the same thing and the pointer moved at most 12 px between them, as a hand drifts
+ * while clicking; a press anywhere else, or one that moved further, is a drag and pans. The page runs this function's own
+ * source, like graphLayout's.
+ */
+export function pressIsClick(press: { x: number; y: number; target: string | null }, release: { x: number; y: number; target: string | null }): boolean {
+  return press.target !== null && press.target === release.target && Math.hypot(release.x - press.x, release.y - press.y) <= 12
+}
+
 /**
  * The graph panel: draws `graphLayout` as SVG, and handles zoom (wheel, pinch, buttons, + and -),
  * pan (drag, arrow keys), fit (0, or the Fit button) and column clicks, which call the page's
- * `select(key)`. Uses the page's `el`, `state`, `render` and `GLYPH`.
+ * `select(key)`. Uses the page's `el`, `state`, `render` and `GLYPH`, and `pressIsClick`.
  */
 export const GRAPH_VIEW_JS = `
 var SVG='http://www.w3.org/2000/svg';
 function sv(tag,attrs,text){var n=document.createElementNS(SVG,tag);for(var k in attrs)if(attrs[k]!=null)n.setAttribute(k,String(attrs[k]));if(text!=null)n.textContent=String(text);return n}
 function graphPanel(f,i){
-  var lv=state.levels[i],ex=state.expanded[i],lay=graphLayout(f,lv,ex);
+  var lv=state.levels[i],ex=state.expanded[i],lay=graphLayout(f,lv,ex),opens={},tookPress=false,press=null;
   var p=el('div','panel graph'),bar=el('div','g-bar');
   function btn(label,title,fn){var b=el('button','g-btn',label);b.type='button';b.title=title;b.setAttribute('aria-label',title);b.addEventListener('click',fn);bar.appendChild(b);return b}
   var hiddenUp=f.up.hops.filter(function(h){return h.hop>lv.up}).length,hiddenDown=f.down.hops.filter(function(h){return h.hop>lv.down}).length;
@@ -126,7 +136,7 @@ function graphPanel(f,i){
     var badge=[];if(b.contract)badge.push('C');if(b.exposures)badge.push('\\u25a3'+b.exposures);if(b.flags)badge.push('!');
     if(badge.length)g.appendChild(sv('text',{x:b.w-10,y:19,'class':'g-badge','text-anchor':'end'},badge.join(' ')));
     if(b.collapsed){g.appendChild(sv('text',{x:10,y:48,'class':'g-more'},b.sub+' \\u00b7 click to show them'));g.setAttribute('tabindex','0');g.setAttribute('role','button');
-      var open=function(){state.expanded[i][b.layer]=true;state.views[i]=null;render()};g.addEventListener('click',function(ev){if(moved)return;ev.stopPropagation();open()});g.addEventListener('keydown',function(ev){if(ev.key==='Enter'||ev.key===' '){ev.preventDefault();open()}})}
+      var open=function(){state.expanded[i][b.layer]=true;state.views[i]=null;render()};opens[b.id]=open;g.addEventListener('click',function(ev){ev.stopPropagation();if(tookPress)return;open()});g.addEventListener('keydown',function(ev){if(ev.key==='Enter'||ev.key===' '){ev.preventDefault();open()}})}
     b.rows.forEach(function(r){
       var row=sv('g',{'class':'g-row','data-key':r.key,tabindex:0,role:'button','aria-label':r.title+': light up its path',transform:'translate(0,'+(r.y-b.y-10)+')'});
       row.appendChild(sv('title',{},r.title));
@@ -134,7 +144,8 @@ function graphPanel(f,i){
       row.appendChild(sv('text',{x:12,y:14,'class':'g-glyph '+(GLYPH[r.glyph]||'unk')+(r.byName?' byname':'')},r.glyph||'?'));
       row.appendChild(sv('text',{x:28,y:14,'class':'g-col'},r.column));
       if(r.end)row.appendChild(sv('text',{x:b.w-10,y:14,'class':'g-end','text-anchor':'end'},'end'));
-      row.addEventListener('click',function(ev){if(moved)return;ev.stopPropagation();select(r.key)});
+      // A pointer press is decided at its release (pressIsClick); this click is the keyboard's or a script's.
+      row.addEventListener('click',function(ev){ev.stopPropagation();if(tookPress)return;select(r.key)});
       row.addEventListener('keydown',function(ev){if(ev.key==='Enter'||ev.key===' '){ev.preventDefault();select(r.key)}});
       g.appendChild(row)});
     gB.appendChild(g)});
@@ -153,12 +164,19 @@ function graphPanel(f,i){
   function zoomBy(m){var s=size();zoomAt(v.k*m,s.w/2,s.h/2)}
   svg.addEventListener('wheel',function(ev){ev.preventDefault();var r=svg.getBoundingClientRect();zoomAt(v.k*Math.exp(-ev.deltaY*0.0015),ev.clientX-r.left,ev.clientY-r.top)},{passive:false});
   var ptrs={},start=null;
-  svg.addEventListener('pointerdown',function(ev){ptrs[ev.pointerId]={x:ev.clientX,y:ev.clientY};moved=false;start={x:ev.clientX,y:ev.clientY,vx:v.x,vy:v.y};var ids=Object.keys(ptrs);if(ids.length===2){var a=ptrs[ids[0]],b=ptrs[ids[1]];start.d=Math.hypot(a.x-b.x,a.y-b.y);start.k=v.k}});
+  function targetOf(n){var r=n&&n.closest?n.closest('.g-row'):null;if(r)return 'row:'+r.getAttribute('data-key');var b=n&&n.closest?n.closest('.g-box.collapsed'):null;return b?'box:'+b.getAttribute('data-box'):null}
+  svg.addEventListener('pointerdown',function(ev){ptrs[ev.pointerId]={x:ev.clientX,y:ev.clientY};moved=false;press=Object.keys(ptrs).length===1?{x:ev.clientX,y:ev.clientY,target:targetOf(ev.target)}:null;start={x:ev.clientX,y:ev.clientY,vx:v.x,vy:v.y};var ids=Object.keys(ptrs);if(ids.length===2){var a=ptrs[ids[0]],b=ptrs[ids[1]];start.d=Math.hypot(a.x-b.x,a.y-b.y);start.k=v.k}});
   svg.addEventListener('pointermove',function(ev){if(!ptrs[ev.pointerId]||!start)return;ptrs[ev.pointerId]={x:ev.clientX,y:ev.clientY};var ids=Object.keys(ptrs);
     if(ids.length===2&&start.d){var a=ptrs[ids[0]],b=ptrs[ids[1]],r=svg.getBoundingClientRect();moved=true;zoomAt(start.k*Math.hypot(a.x-b.x,a.y-b.y)/start.d,(a.x+b.x)/2-r.left,(a.y+b.y)/2-r.top);return}
     var dx=ev.clientX-start.x,dy=ev.clientY-start.y;if(!moved&&Math.abs(dx)+Math.abs(dy)<5)return;
     if(!moved){moved=true;try{svg.setPointerCapture(ev.pointerId)}catch(e){}}v.x=start.vx+dx;v.y=start.vy+dy;apply()});
-  function up(ev){delete ptrs[ev.pointerId];if(!Object.keys(ptrs).length)start=null;setTimeout(function(){moved=false},0)}
+  // A press on a column or a folded level that ends on it, having moved a little, is a click: any small pan it made is
+  // undone. The click event that follows is then ignored, as is one after a drag.
+  function up(ev){var was=start;delete ptrs[ev.pointerId];
+    if(ev.type==='pointerup'&&press&&!Object.keys(ptrs).length){var t=press.target,ok=pressIsClick(press,{x:ev.clientX,y:ev.clientY,target:targetOf(document.elementFromPoint(ev.clientX,ev.clientY))});
+      tookPress=true;setTimeout(function(){tookPress=false},0);
+      if(ok){if(moved&&was){v.x=was.vx;v.y=was.vy;apply()}if(t.indexOf('row:')===0)select(t.slice(4));else if(opens[t.slice(4)])opens[t.slice(4)]()}}
+    if(!Object.keys(ptrs).length){start=null;press=null}setTimeout(function(){moved=false},0)}
   svg.addEventListener('pointerup',up);svg.addEventListener('pointercancel',up);
   svg.addEventListener('keydown',function(ev){var step=48;
     if(ev.key==='ArrowLeft'){v.x+=step}else if(ev.key==='ArrowRight'){v.x-=step}else if(ev.key==='ArrowUp'){v.y+=step}else if(ev.key==='ArrowDown'){v.y-=step}

From 462251f54a10ea142bc03d847cb880c7ca00eddb Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Thu, 12 Nov 2026 12:57:07 +0800
Subject: [PATCH 18/21] fix: an older altimate-code's missing column answer
 reads as "update it", not a failed trace

An altimate-code from before the column answer gives neither the answer nor its error. The summary and report now keep the model-level count and say to update altimate-code, instead of "could not be traced".

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VEmKQwEiHMwQ7BdwgPo9sb
---
 plugins/altimate-code/hooks/impact-report.ts  | 19 ++++++++++++-------
 .../altimate-code/hooks/task-impact.test.tsx  | 17 +++++++++++++++++
 plugins/altimate-code/hooks/task-impact.tsx   |  4 +++-
 3 files changed, 32 insertions(+), 8 deletions(-)

diff --git a/plugins/altimate-code/hooks/impact-report.ts b/plugins/altimate-code/hooks/impact-report.ts
index 2038665..e52f242 100644
--- a/plugins/altimate-code/hooks/impact-report.ts
+++ b/plugins/altimate-code/hooks/impact-report.ts
@@ -216,6 +216,8 @@ export type ColumnTrace = {
   up: ColumnAnswer | null
   modelLevel: number | null
   failed: boolean
+  /** The altimate-code answered without a column answer: one from before it. */
+  stale?: boolean
   consumers?: ReportConsumers
 }
 
@@ -248,7 +250,7 @@ export function summaryLines(view: TaskSummaryView): string[] {
     if (model.columns.length === 0) lines.push('  no output column changed: the model-level count stands')
     for (const col of model.columns) {
       if (view.state === 'tracing' && !col.reach) lines.push(`  ${col.name}  tracing…`)
-      else if (!col.reach) lines.push(`  ${col.name}  ${col.failed ? 'could not be traced' : 'no column answer'}`)
+      else if (!col.reach) lines.push(`  ${col.name}  ${col.failed ? 'could not be traced' : 'no column answer: update altimate-code'}`)
       else {
         const r = col.reach
         const parts = [`reaches ${plural(r.columns, 'column')} in ${plural(r.models, 'model')} (${plural(r.ends, 'end')})`]
@@ -352,9 +354,12 @@ const nameOf = (answer: ColumnAnswer, index: number | undefined) => {
   return String(node?.name ?? node?.id ?? index ?? '?')
 }
 
+/** What the report says for a column when the altimate-code predates the column answer. */
+const STALE = 'This altimate-code gives no column answer: update it to trace the column.'
+
 /** One direction's columns beyond the focus, grouped by hop and then by model. */
-export function sectionOf(answer: ColumnAnswer | null, failed = false): ReportSection {
-  if (!answer) return { hops: [], truncated: false, error: failed ? 'This direction could not be traced.' : null }
+export function sectionOf(answer: ColumnAnswer | null, failed = false, stale = false): ReportSection {
+  if (!answer) return { hops: [], truncated: false, error: stale ? STALE : failed ? 'This direction could not be traced.' : null }
   const byHop = new Map<number, Map<number, ReportModel>>()
   answer.columns.forEach((col, i) => {
     if (!(col.hop > 0)) return
@@ -407,7 +412,7 @@ export function impactWords(model: string, column: string | null, trace: ColumnT
     if (level === null) return [['The downstream count could not be read for ', { code: model }, '.']]
     return [[...downstream, ...(level > 0 ? ["No output column changed (a filter or a join, say), so this can't say which of them are affected."] : [])]]
   }
-  if (!down) return [[...downstream, 'The column ', { code: column }, ' could not be traced.']]
+  if (!down) return [[...downstream, ...(trace?.stale ? [STALE] : ['The column ', { code: column }, ' could not be traced.'])]]
   const r = reachOf(down)
   const lines: Words[] = []
   const value = [...new Set(down.columns.filter(one => one.hop > 0).map(one => one.model))].map(index => down.nodes[index]).filter(Boolean)
@@ -478,9 +483,9 @@ export function focusOf(change: ModelChange, column: ModelChange['columns'][numb
     reach,
     modelLevel: trace?.modelLevel ?? reach?.modelLevel ?? null,
     impact: impactWords(change.model, column?.name ?? null, trace, lookup),
-    upstream: column ? upstreamWords(change.model, column.name, up) : [],
-    up: sectionOf(up, !up && !!column),
-    down: sectionOf(down, !down && !!column),
+    upstream: column ? (trace?.stale ? [[STALE]] : upstreamWords(change.model, column.name, up)) : [],
+    up: sectionOf(up, !up && !!column, !!trace?.stale),
+    down: sectionOf(down, !down && !!column, !!trace?.stale),
     edges,
     alsoReads: (down?.also_reads ?? []).map(one => ({ name: nameOf(down!, one.model), columns: (one.columns ?? []).map(String), downstream: num(one.downstream) })),
     unresolved: (down?.unresolved ?? []).map(one => ({ name: nameOf(down!, one.model), reason: String(one.reason ?? 'not read'), downstream: num(one.downstream) })),
diff --git a/plugins/altimate-code/hooks/task-impact.test.tsx b/plugins/altimate-code/hooks/task-impact.test.tsx
index e14db34..3cb9abc 100644
--- a/plugins/altimate-code/hooks/task-impact.test.tsx
+++ b/plugins/altimate-code/hooks/task-impact.test.tsx
@@ -377,6 +377,23 @@ test('a failed upstream trace is asked again next time, and the band keeps its n
   expect(directional(tools).map(one => one.direction)).toEqual(['downstream', 'upstream', 'downstream', 'upstream'])
 })
 
+test('with an altimate-code from before the column answer, the band and the report say to update it, not that the trace failed', async ($, on) => {
+  const reachOnly = { column_answer: undefined, column_reach: { models: [{ name: 'rpt_orders', columns: ['revenue'] }], exposures: [] } }
+  const { writes, turn } = await start($, on, { openers: { 'xdg-open': 0 }, impact: () => reachOnly })
+  await turn('t1', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
+  })
+  const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  expect(await band.find({ type: 'Text', text: /no column answer: update altimate-code/ })).toBeDefined()
+  expect(await band.find({ type: 'Text', text: /could not be traced/ })).toBeUndefined()
+  await band.unmount()
+  await $.command.run({ command: 'lineage-report', args: '' } as any)
+  const focus = embedded(writes.get(REPORT)!).focuses[0]
+  const update = 'This altimate-code gives no column answer: update it to trace the column.'
+  expect([focus.down.error, focus.up.error]).toEqual([update, update])
+  expect(focus.modelLevel).toBe(6)
+})
+
 test('a plan that names no model, or a subagent\'s, shows nothing; a new turn clears a plan\'s band; a plan file is the fallback', async ($, on) => {
   const { tools, logs, clock, files } = await start($, on)
   await $.turn.start({ text: 'plan it', turnId: 'p1' })
diff --git a/plugins/altimate-code/hooks/task-impact.tsx b/plugins/altimate-code/hooks/task-impact.tsx
index eb1d51c..a82d8b4 100644
--- a/plugins/altimate-code/hooks/task-impact.tsx
+++ b/plugins/altimate-code/hooks/task-impact.tsx
@@ -208,7 +208,9 @@ async function traceDown($: EngineInterface, done: Finished): Promise<ColumnTrac
       jobs.push(async () => {
         const meta = await ask($, done, change, col.name, 'downstream')
         const down = answerOf(meta)
-        return { model: change.model, column: col.name, down, up: null, modelLevel: modelLevelOf(meta), failed: !down, consumers: consumersOf(meta) }
+        // An altimate-code from before the column answer gives neither the answer nor its error.
+        const stale = !!meta && !down && (meta as any).column_answer === undefined && (meta as any).column_answer_error === undefined
+        return { model: change.model, column: col.name, down, up: null, modelLevel: modelLevelOf(meta), failed: !down && !stale, stale, consumers: consumersOf(meta) }
       })
     }
   }

From 694771492dda44dd9e7d967e8658c742d016674b Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Thu, 12 Nov 2026 13:07:59 +0800
Subject: [PATCH 19/21] fix: each session keeps its own manifest copies, so
 another session's task can't replace them

The start-of-task and end-of-task copies carry the session's id, and a task's end removes copies a day old.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VEmKQwEiHMwQ7BdwgPo9sb
---
 plugins/altimate-code/README.md               |  2 +-
 .../altimate-code/hooks/task-impact.test.tsx  | 48 ++++++++++++++-----
 plugins/altimate-code/hooks/task-impact.tsx   | 26 +++++++---
 3 files changed, 55 insertions(+), 21 deletions(-)

diff --git a/plugins/altimate-code/README.md b/plugins/altimate-code/README.md
index fa4ca57..a77e22b 100644
--- a/plugins/altimate-code/README.md
+++ b/plugins/altimate-code/README.md
@@ -109,7 +109,7 @@ The plugin's lineage pane follows the dbt model Claude reads or edits (by Read,
 - **Column reach.** `c` picks a column; the pane shows the downstream models whose SQL reads it and the dashboards on them, from `impact_analysis` (it traces each downstream model's compiled SQL, renames included). Models that name the column only in a filter or join, or that could not be traced (no compiled SQL), are listed apart, and the count is then a lower bound.
 - **Impact first.** Before an edit to a model's SQL lands, the plugin checks what reads the model and the reach of every column the edit touches (up to three, merged). It tells a touched column from the model's own lineage (what the pane already read, or `dbt_lineage` through the CLI), so a column `schema.yml` leaves out still counts. It adds the result to Claude's context with the edit's result. You see the summary at the end of the task, not a note per edit; a toast says so when the lookup missed its time or failed and the edit went ahead without it.
 - **End-of-task summary.** When a task (one prompt and Claude's work on it) changed a model, by an edit or a shell command git sees, a band above the prompt says what changed and how far it reaches: each changed column (up to three per model) with the columns, models and end columns downstream that carry its value, the models that may carry it and those cleared, next to the model-level count, and a line when some models could not be read. The trace reads a copy of `target/manifest.json` taken when the task started, so a recompile mid-task does not change the answer. These lookups go through the CLI, so they raise no permission prompt.
-- **The report, on demand.** **Open report** or `/lineage-report` builds an offline HTML report of the last task that changed a model and opens it in the browser (`target/.altimate-lineage/report.html`). It leads with what changed, before and after, what to expect downstream in plain words, and who consumes it: the dbt exposures on the model or downstream, grouped by whether they read a model the value reaches, and a plain statement when the project declares none. Only declared exposures appear: other BI tools and backend services do not. Under that are two levels upstream and downstream (more on request), and a click on any column lights up its path. Nothing is written until you ask. What it reads was kept when the task ended (`task-manifest.json`, `last-task.json`), so asking later, after other turns or a restart, still describes that task, and it says if a file has changed since. A later task that changes a model replaces it. The band's button goes when the next turn starts; `/lineage-report` keeps working.
+- **The report, on demand.** **Open report** or `/lineage-report` builds an offline HTML report of the last task that changed a model and opens it in the browser (`target/.altimate-lineage/report.html`). It leads with what changed, before and after, what to expect downstream in plain words, and who consumes it: the dbt exposures on the model or downstream, grouped by whether they read a model the value reaches, and a plain statement when the project declares none. Only declared exposures appear: other BI tools and backend services do not. Under that are two levels upstream and downstream (more on request), and a click on any column lights up its path. Nothing is written until you ask. What it reads was kept when the task ended (`task-manifest.<session>.json`, `last-task.json`), so asking later, after other turns or a restart, still describes that task, and it says if a file has changed since. Each session keeps its own copy of the manifest, and copies a day old are removed. A later task that changes a model replaces it. The band's button goes when the next turn starts; `/lineage-report` keeps working.
 - **Before a plan.** When Claude puts a plan up for approval, the plugin looks for the models the plan names and adds one line above the dialog with each one's downstream models, tests and exposures, at the model level. It holds nothing back and spends no model tokens. The band shows the same once the dialog closes, until the task's summary takes over. It goes by the names in the plan's text, so a model it mentions may not be one it changes, and "the staging models" finds nothing. Leaving plan mode with shift+tab shows nothing.
 - **Warehouse lineage.** When a connected MCP server offers Altimate's `table_lineage` (Snowflake) or `databricks_table_lineage`, the pane adds what the warehouse's query history shows for the model's table. The plugin calls a tool of that name on whichever connected server offers it, itself and without a permission prompt, and sends it the model's `database.schema.table`. It does so only when you ask for the model (`/lineage`, a press in the pane, or `r`), never when the pane follows one of Claude's reads.
 - **Claude's own lineage calls.** A `dbt_lineage` result is drawn as a list of edges colored by how each column is derived; ctrl+o keeps the original output under it.
diff --git a/plugins/altimate-code/hooks/task-impact.test.tsx b/plugins/altimate-code/hooks/task-impact.test.tsx
index 3cb9abc..04c0e2f 100644
--- a/plugins/altimate-code/hooks/task-impact.test.tsx
+++ b/plugins/altimate-code/hooks/task-impact.test.tsx
@@ -4,8 +4,11 @@ import { DOWN, UP, embedded } from './impact-report.test'
 
 const ROOT = '/repo'
 const MANIFEST = `${ROOT}/target/manifest.json`
-const SNAPSHOT = `${ROOT}/target/.altimate-lineage/manifest-before.json`
-const FROZEN = `${ROOT}/target/.altimate-lineage/task-manifest.json`
+// The manifest copies carry the session's id: read from the copy the task start made.
+let RUNS: string[][] = []
+const tag = () => RUNS.map(one => (one[0] === 'cp' ? /\/manifest-before\.([^/]+)\.json$/.exec(one[2] ?? '')?.[1] : undefined)).find(Boolean) ?? ''
+const snapshot = () => `${ROOT}/target/.altimate-lineage/manifest-before.${tag()}.json`
+const frozen = () => `${ROOT}/target/.altimate-lineage/task-manifest.${tag()}.json`
 const TASK_FILE = `${ROOT}/target/.altimate-lineage/last-task.json`
 const REPORT = `${ROOT}/target/.altimate-lineage/report.html`
 const MODEL = `${ROOT}/models/fct_orders.sql`
@@ -195,6 +198,7 @@ async function start($: any, on: any, options: Options = {}) {
     await $.turn.complete({ answer: 'Done.', durationMs: 5, isAborted: false, reason: 'answer', turnId: id } as any)
     await clock.settle()
   }
+  RUNS = runs
   return { clock, files, runs, tools, writes, logs, toasts, copies, dialogs, mcpAsked, turn }
 }
 
@@ -204,10 +208,28 @@ test('a task start copies the manifest aside, never reading it', async ($, on) =
   const { runs, turn } = await start($, on)
   await turn('t1', async () => {})
   expect(runs).toContainEqual(['mkdir', '-p', `${ROOT}/target/.altimate-lineage`])
-  expect(runs).toContainEqual(['cp', MANIFEST, SNAPSHOT])
+  expect(runs).toContainEqual(['cp', MANIFEST, snapshot()])
   expect(runs.findIndex(one => one[0] === 'mkdir')).toBeLessThan(runs.findIndex(one => one[0] === 'cp'))
 })
 
+test("each session's manifest copies carry its id, so another session's task never replaces them; a task's end clears copies a day old", async ($, on) => {
+  const { runs, turn, tools, clock } = await start($, on)
+  await turn('t1', async () => {
+    await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
+  })
+  await clock.settle()
+  // The id in the copies' names is the one the usage events carry.
+  const event = runs.find(one => one.includes('report-event'))!
+  const id = event[event.indexOf('--session') + 1]!.replace(/^claude:/, '')
+  expect(tag()).toBe(id.replace(/[^A-Za-z0-9_-]/g, '_'))
+  expect(tag().length).toBeGreaterThan(0)
+  expect(runs).toContainEqual(['mv', '-f', snapshot(), frozen()])
+  expect(directional(tools).every(one => one.manifest_path === frozen())).toBe(true)
+  const clear = runs.findIndex(one => one[0] === 'find')
+  expect(runs[clear]).toEqual(['find', `${ROOT}/target/.altimate-lineage`, '-maxdepth', '1', '-name', '*manifest*.json', '-mmin', '+1440', '-delete'])
+  expect(clear).toBeLessThan(runs.findIndex(one => one[0] === 'mv'))
+})
+
 test('an edited model is traced downstream at the task end for the band; the report waits until it is asked for', async ($, on) => {
   const { tools, writes, turn, clock, logs, mcpAsked } = await start($, on)
   await turn('t1', async () => {
@@ -215,7 +237,7 @@ test('an edited model is traced downstream at the task end for the band; the rep
     // A second edit of the same file: the original stays the one from before the first.
     await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'order_id,', new_string: 'order_id ,' })
   })
-  expect(directional(tools)).toEqual([{ manifest_path: FROZEN, model: 'fct_orders', column: 'revenue', change_type: 'modify', direction: 'downstream' }])
+  expect(directional(tools)).toEqual([{ manifest_path: frozen(), model: 'fct_orders', column: 'revenue', change_type: 'modify', direction: 'downstream' }])
   expect(writes.has(REPORT)).toBe(false)
   // One log line: the transcript draws a newline in a log as a replacement glyph.
   expect(logs).toContain('◆ Lineage after this task · 1 model changed · fct_orders · 6 downstream models at model level · revenue  reaches 4 columns in 3 models (2 ends) · 1 may carry it · 2 cleared · ⚠ Lower bound: 1 model could not be read')
@@ -231,7 +253,7 @@ test('an edited model is traced downstream at the task end for the band; the rep
   await band.press({ key: 'lineage-report-open' })
   await clock.settle()
   expect(directional(tools).map(one => one.direction)).toEqual(['downstream', 'upstream'])
-  expect(directional(tools)[1]!.manifest_path).toBe(FROZEN)
+  expect(directional(tools)[1]!.manifest_path).toBe(frozen())
   const report = embedded(writes.get(REPORT)!)
   expect(report.changes).toEqual([
     { model: 'fct_orders', file: 'models/fct_orders.sql', columns: [{ name: 'revenue', before: 'sum(amount) as revenue', after: 'sum(amount) - sum(refunds) as revenue' }] },
@@ -262,8 +284,8 @@ test('once the session has moved on, /lineage-report still builds that task, fro
   await turn('t2', async () => {
     files[MODEL] = files[MODEL]!.replace('order_id,', 'order_id as id,')
   })
-  expect(copies.has(SNAPSHOT)).toBe(true)
-  expect(copies.has(FROZEN)).toBe(true)
+  expect(copies.has(snapshot())).toBe(true)
+  expect(copies.has(frozen())).toBe(true)
   const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
   expect(await band.find({ key: 'lineage-report-open' })).toBeUndefined()
   await band.unmount()
@@ -271,7 +293,7 @@ test('once the session has moved on, /lineage-report still builds that task, fro
   const out: any = await $.command.run({ command: 'lineage-report', args: '' } as any)
   await clock.settle()
   expect(out.text).toMatch(/^Opened the column impact report for the task that finished at .* UTC: /)
-  expect(directional(tools).slice(before).map(one => [one.direction, one.manifest_path])).toEqual([['upstream', FROZEN]])
+  expect(directional(tools).slice(before).map(one => [one.direction, one.manifest_path])).toEqual([['upstream', frozen()]])
   const report = embedded(writes.get(REPORT)!)
   expect(report.changes[0].columns[0].after).toBe('sum(amount) * 2 as revenue')
   expect(report.movedOn).toEqual(['models/fct_orders.sql'])
@@ -291,7 +313,7 @@ test('a later task that changes a model takes over: its report, its manifest', a
   expect(writes.has(REPORT)).toBe(false)
   await $.command.run({ command: 'lineage-report', args: '' } as any)
   expect(embedded(writes.get(REPORT)!).changes.map((one: any) => one.model)).toEqual(['stg_payments'])
-  expect(directional(tools).filter(one => one.model === 'stg_payments').every(one => one.manifest_path === FROZEN)).toBe(true)
+  expect(directional(tools).filter(one => one.model === 'stg_payments').every(one => one.manifest_path === frozen())).toBe(true)
 })
 
 test('after a restart, /lineage-report rebuilds the last task from what was saved, both ways', async ($, on) => {
@@ -301,13 +323,13 @@ test('after a restart, /lineage-report rebuilds the last task from what was save
   })
   const saved = JSON.parse(writes.get(TASK_FILE)!)
   expect(saved.changes[0]).toMatchObject({ model: 'fct_orders', file: 'models/fct_orders.sql' })
-  expect(saved.manifests).toEqual({ [ROOT]: FROZEN })
+  expect(saved.manifests).toEqual({ [ROOT]: frozen() })
   await $.session.start({ cwd: ROOT, surface: 'terminal', isInteractive: true })
   await clock.settle()
   const before = directional(tools).length
   // A commit in between moves HEAD but not the task, and the file is as the task left it.
   const out: any = await $.command.run({ command: 'lineage-report', args: '' } as any)
-  expect(directional(tools).slice(before).map(one => `${one.direction}:${one.manifest_path === FROZEN}`).sort()).toEqual(['downstream:true', 'upstream:true'])
+  expect(directional(tools).slice(before).map(one => `${one.direction}:${one.manifest_path === frozen()}`).sort()).toEqual(['downstream:true', 'upstream:true'])
   expect(out.text).toContain(`: ${REPORT}`)
   expect(embedded(writes.get(REPORT)!).movedOn).toEqual([])
   expect(files[MODEL]).toContain('* 2 as revenue')
@@ -319,7 +341,7 @@ test("when the task's copy of the manifest is gone it reads the project's and sa
   await turn('t1', async () => {
     await $.tool.call({ tool: 'Edit', file_path: MODEL, old_string: 'sum(amount) as revenue', new_string: 'sum(amount) * 2 as revenue' })
   })
-  copies.delete(FROZEN)
+  copies.delete(frozen())
   await $.command.run({ command: 'lineage-report', args: '' } as any)
   expect(embedded(writes.get(REPORT)!).manifest).toBe("target/manifest.json as it is now, as the copy from the task's start is gone")
   gone = true
@@ -436,7 +458,7 @@ test('a change to no output column falls back to the model-level count', async (
   await turn('t1', async () => {
     await $.tool.call({ tool: 'Edit', file_path: STAGING, old_string: "status = 'ok'", new_string: "status in ('ok', 'settled')" })
   })
-  expect(directional(tools)).toEqual([{ manifest_path: FROZEN, model: 'stg_payments', change_type: 'modify', direction: 'downstream' }])
+  expect(directional(tools)).toEqual([{ manifest_path: frozen(), model: 'stg_payments', change_type: 'modify', direction: 'downstream' }])
   const band = await $.ui.mount({ ...BAND, surface: 'terminal' })
   expect(await band.find({ type: 'Text', text: 'stg_payments · 6 downstream models at model level' })).toBeDefined()
   expect(await band.find({ type: 'Text', text: '  no output column changed: the model-level count stands' })).toBeDefined()
diff --git a/plugins/altimate-code/hooks/task-impact.tsx b/plugins/altimate-code/hooks/task-impact.tsx
index a82d8b4..a8d1f9c 100644
--- a/plugins/altimate-code/hooks/task-impact.tsx
+++ b/plugins/altimate-code/hooks/task-impact.tsx
@@ -30,9 +30,15 @@ import { modelsNamed, openPane, projectRoot, runTool, within } from './lineage'
 export const REPORT_COMMAND = 'lineage-report'
 // Under the project's target/, which dbt already keeps out of git.
 const LINEAGE_DIR = 'target/.altimate-lineage'
-// A task's copy of the manifest while it runs, and the last finished task's, kept for its report.
-const RUNNING_MANIFEST = 'manifest-before.json'
-const TASK_MANIFEST = 'task-manifest.json'
+// A task's copy of the manifest while it runs, and the last finished task's, kept for its report. Each
+// session has its own, so two sessions in one project never read each other's; a day on, they go.
+export const runningManifest = (tag: string) => `manifest-before.${tag}.json`
+export const taskManifest = (tag: string) => `task-manifest.${tag}.json`
+const MANIFEST_COPIES_KEPT_MINUTES = '+1440'
+/** This session's id as a file-name part. */
+export async function sessionTag($: EngineInterface): Promise<string> {
+  return String(await $.session.id().catch(() => 'session')).replace(/[^A-Za-z0-9_-]/g, '_')
+}
 // What a report needs of the last finished task, so one can be built after a restart too.
 const TASK_FILE = 'last-task.json'
 // A report on one column, asked for by name; apart from the task's, which it never replaces.
@@ -119,8 +125,9 @@ function prepareRoot($: EngineInterface, t: Task, root: string): Promise<RootSta
       // The manifest can be far over the 4 MiB a plugin reads, so it is copied, never read.
       const dir = `${root}/${LINEAGE_DIR}`
       const made = await $.process.run(['mkdir', '-p', dir], { timeoutMs: 5_000 }).catch(() => null)
-      const copied = made?.exitCode === 0 ? await $.process.run(['cp', manifest, `${dir}/${RUNNING_MANIFEST}`], { timeoutMs: 20_000 }).catch(() => null) : null
-      if (copied?.exitCode === 0) snapshot = `${dir}/${RUNNING_MANIFEST}`
+      const copy = `${dir}/${runningManifest(await sessionTag($))}`
+      const copied = made?.exitCode === 0 ? await $.process.run(['cp', manifest, copy], { timeoutMs: 20_000 }).catch(() => null) : null
+      if (copied?.exitCode === 0) snapshot = copy
     }
     const top = (await git($, ['-C', root, 'rev-parse', '--show-toplevel']))?.trim()
     let gitStart: GitStart | null = null
@@ -230,16 +237,21 @@ async function traceFull($: EngineInterface, done: Finished): Promise<ColumnTrac
 
 const stamp = (ms: number) => new Date(ms).toISOString().slice(0, 16).replace('T', ' ') + ' UTC'
 
-/** Moves each project's copy of the manifest out of the next task's way. */
+/** Moves each project's copy of the manifest out of the next task's way, and clears copies a day old. */
 async function freezeManifests($: EngineInterface, t: Task, changes: ModelChange[]): Promise<Record<string, string | null>> {
   const out: Record<string, string | null> = {}
+  const tag = await sessionTag($)
   for (const root of new Set(changes.map(one => one.root))) {
+    const dir = `${root}/${LINEAGE_DIR}`
+    await $.process
+      .run(['find', dir, '-maxdepth', '1', '-name', '*manifest*.json', '-mmin', MANIFEST_COPIES_KEPT_MINUTES, '-delete'], { timeoutMs: 5_000 })
+      .catch(() => null)
     const state = await t.roots.get(root)?.catch(() => null)
     if (!state?.snapshot) {
       out[root] = null
       continue
     }
-    const frozen = `${root}/${LINEAGE_DIR}/${TASK_MANIFEST}`
+    const frozen = `${dir}/${taskManifest(tag)}`
     const moved = await $.process.run(['mv', '-f', state.snapshot, frozen], { timeoutMs: 5_000 }).catch(() => null)
     out[root] = moved?.exitCode === 0 ? frozen : state.snapshot
   }

From a9bda04f95d20b18861298cf2a65bdc740569383 Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Thu, 12 Nov 2026 14:24:15 +0800
Subject: [PATCH 20/21] fix: the report's path bar floats over the page instead
 of pushing it down

A click on a column showed the path bar in the page's flow, which moved everything under the pointer, so the tooltip then named the row above. The bar is now fixed at the top, lets the pointer through, and keeps its Clear button clickable.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VEmKQwEiHMwQ7BdwgPo9sb
---
 plugins/altimate-code/hooks/impact-report.test.ts | 11 +++++++++++
 plugins/altimate-code/hooks/impact-report.ts      |  5 +++--
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/plugins/altimate-code/hooks/impact-report.test.ts b/plugins/altimate-code/hooks/impact-report.test.ts
index 2f827aa..cb5c3ad 100644
--- a/plugins/altimate-code/hooks/impact-report.test.ts
+++ b/plugins/altimate-code/hooks/impact-report.test.ts
@@ -350,6 +350,17 @@ describe('the report', () => {
     expect(data.changes[0].columns[0].after).toBe('sum(amount) - sum(refunds) as revenue')
   })
 
+  test('a click shows the path bar over the page, so nothing under the pointer moves', () => {
+    const html = reportHtml(reportData([CHANGE], [TRACE], TASK))
+    const rule = /\.pathbar\{[^}]*\}/.exec(html)![0]
+    expect(rule).toContain('position:fixed')
+    expect(rule).not.toContain('sticky')
+    expect(rule).not.toMatch(/margin:-/)
+    // The bar lets the pointer through to the column under it; its Clear button still takes clicks.
+    expect(rule).toContain('pointer-events:none')
+    expect(html).toMatch(/\.pathbar button\{[^}]*pointer-events:auto/)
+  })
+
   test('is one offline file: no external resource, and project text cannot close its script', () => {
     const hostile = { ...CHANGE, model: 'x</script><script>alert(1)</script>' }
     const html = reportHtml(reportData([hostile], [{ ...TRACE, model: hostile.model }], TASK))
diff --git a/plugins/altimate-code/hooks/impact-report.ts b/plugins/altimate-code/hooks/impact-report.ts
index e52f242..fa81048 100644
--- a/plugins/altimate-code/hooks/impact-report.ts
+++ b/plugins/altimate-code/hooks/impact-report.ts
@@ -668,9 +668,10 @@ details.fold summary span{color:var(--muted);font-weight:400}
 details.fold ul{margin:0 0 10px;padding-left:18px}
 details.fold li{margin:3px 0}
 details.fold .why{color:var(--muted)}
-.pathbar{position:sticky;top:0;z-index:5;display:none;align-items:center;gap:10px;flex-wrap:wrap;background:var(--accent);color:#fff;padding:8px 14px;border-radius:0 0 10px 10px;margin:-20px 0 12px;font-size:13px}
+/* The path bar floats over the page: shown in the flow, it would push the page down under the pointer that clicked. */
+.pathbar{position:fixed;top:8px;left:16px;right:16px;max-width:1648px;margin:0 auto;z-index:20;display:none;align-items:center;gap:10px;flex-wrap:wrap;background:var(--accent);color:#fff;padding:8px 14px;border-radius:10px;box-shadow:0 4px 16px rgba(0,0,0,.2);font-size:13px;pointer-events:none}
 @media (prefers-color-scheme:dark){.pathbar{color:#111}}
-.pathbar button{appearance:none;border:1px solid currentColor;background:transparent;color:inherit;border-radius:6px;padding:2px 8px;font:inherit;cursor:pointer}
+.pathbar button{appearance:none;border:1px solid currentColor;background:transparent;color:inherit;border-radius:6px;padding:2px 8px;font:inherit;cursor:pointer;pointer-events:auto}
 body.hl .pathbar{display:flex}
 body.hl .col:not(.on){opacity:.28}
 body.hl .model:not(.has-on){opacity:.45}

From 1cf43a221ac9c5fc60536f9091b8c72362601f5a Mon Sep 17 00:00:00 2001
From: "Ralph Sto. Domingo" <ralph@altimate.ai>
Date: Thu, 12 Nov 2026 14:29:40 +0800
Subject: [PATCH 21/21] fix: the report's graph reads at first sight, on a
 phone and from the keyboard

The key names every mark (exposures, engine notes, end, the changed column) and which side is upstream; each count says what it counts on hover. A narrow panel opens on the changed column at a readable zoom. Badges no longer cover names, and Tab goes left to right, bringing each column into view.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VEmKQwEiHMwQ7BdwgPo9sb
---
 .../altimate-code/hooks/impact-report.test.ts | 11 +++-
 plugins/altimate-code/hooks/impact-report.ts  | 19 ++++---
 .../altimate-code/hooks/report-graph.test.ts  | 51 ++++++++++++++++++-
 plugins/altimate-code/hooks/report-graph.ts   | 49 ++++++++++++++----
 4 files changed, 108 insertions(+), 22 deletions(-)

diff --git a/plugins/altimate-code/hooks/impact-report.test.ts b/plugins/altimate-code/hooks/impact-report.test.ts
index cb5c3ad..a351e85 100644
--- a/plugins/altimate-code/hooks/impact-report.test.ts
+++ b/plugins/altimate-code/hooks/impact-report.test.ts
@@ -293,7 +293,7 @@ describe('a column looked up by name', () => {
     const html = reportHtml(data)
     const at = (one: string) => html.indexOf(one, html.indexOf('function render(){'))
     expect(html).toContain("side.appendChild(DATA.lookup?upstreamPanel():ch)")
-    expect(at("if(DATA.lookup){var uc=0")).toBeLessThan(at("if(r){stats.appendChild(stat(r.columns,'columns downstream'))"))
+    expect(at("if(DATA.lookup){var uc=0")).toBeLessThan(at("if(r){stats.appendChild(stat(r.columns,'columns downstream',"))
     expect(html).toContain("'Where it comes from'")
     expect(html).toContain("DATA.lookup?'Where it goes':'What to expect downstream'")
     expect(reportData([CHANGE], [TRACE], TASK).lookup).toBeNull()
@@ -361,6 +361,15 @@ describe('the report', () => {
     expect(html).toMatch(/\.pathbar button\{[^}]*pointer-events:auto/)
   })
 
+  test('its key names every mark the graph draws, and each count says what it counts', () => {
+    const html = reportHtml(reportData([CHANGE], [TRACE], TASK))
+    for (const key of ['exposures on the model', 'noted by the engine', 'nothing further downstream reads it', "DATA.lookup?'the column':'the changed column'", 'Upstream on the left, downstream on the right'])
+      expect(html).toContain(key)
+    for (const tip of ['Columns the value reaches that nothing further downstream reads', 'Downstream of the model, but the value doesn\\u2019t reach them', 'Every model downstream of this one, whether or not the value reaches it'])
+      expect(html).toContain(tip)
+    expect(html).toContain("stat(r.cleared,'models cleared',r.cleared==null,")
+  })
+
   test('is one offline file: no external resource, and project text cannot close its script', () => {
     const hostile = { ...CHANGE, model: 'x</script><script>alert(1)</script>' }
     const html = reportHtml(reportData([hostile], [{ ...TRACE, model: hostile.model }], TASK))
diff --git a/plugins/altimate-code/hooks/impact-report.ts b/plugins/altimate-code/hooks/impact-report.ts
index fa81048..137c4c7 100644
--- a/plugins/altimate-code/hooks/impact-report.ts
+++ b/plugins/altimate-code/hooks/impact-report.ts
@@ -2,7 +2,7 @@
 // and a self-contained HTML report. Pure functions only; the hooks live in task-impact.tsx.
 
 import type { PlanImpactView, Reach, TaskSummaryView } from '../types'
-import { GRAPH_CSS, GRAPH_VIEW_JS, graphLayout, pressIsClick } from './report-graph'
+import { GRAPH_CSS, GRAPH_VIEW_JS, graphLayout, graphView, pressIsClick } from './report-graph'
 import { selectItems, touchedColumns } from './lineage-graph'
 
 export type { PlanImpactView, Reach, TaskSummaryView }
@@ -626,6 +626,7 @@ header.top .when{color:var(--muted);font-size:12.5px}
 .inputs{color:var(--muted);font-size:12px;margin:-4px 0 14px}
 .legend{display:flex;flex-wrap:wrap;gap:4px 12px;color:var(--muted);font-size:12px;margin:0 0 14px}
 .legend .g{margin-right:4px}
+.legend .sw{display:inline-block;width:16px;height:12px;border-radius:3px;background:var(--focus);border:1.5px solid var(--focus-line);vertical-align:-2px}
 .section{margin:0 0 12px}
 .section-head{display:flex;align-items:center;flex-wrap:wrap;gap:8px;margin:18px 0 8px}
 .section-head h2{flex:1}
@@ -648,7 +649,7 @@ header.top .when{color:var(--muted);font-size:12.5px}
 .col:hover{background:var(--accent-soft)}
 .col .name{overflow-wrap:anywhere;flex:1}
 .col .type{color:var(--faint);font-size:11.5px}
-.col .end{font-size:10.5px;color:var(--muted);border:1px solid var(--line-strong);border-radius:4px;padding:0 4px}
+.col .end,.legend .end{font-size:10.5px;color:var(--muted);border:1px solid var(--line-strong);border-radius:4px;padding:0 4px}
 .g{display:inline-flex;align-items:center;justify-content:center;min-width:20px;height:20px;border-radius:5px;font-weight:700;font-size:12.5px;flex:none}
 .g.same{color:var(--same);background:var(--same-bg)}
 .g.ren{color:var(--ren);background:var(--ren-bg)}
@@ -682,7 +683,7 @@ body.hl .col.sel{outline:2px solid var(--accent)}
   .wrap{padding:14px 12px 48px}
   header.top h1{font-size:17px}
   .models{grid-template-columns:1fr}
-  .stat{min-width:0;flex:1 1 40%}
+  .stat{min-width:0;flex:1 1 28%;padding:5px 8px}
 }
 `
 
@@ -704,7 +705,7 @@ function colButton(c){var b=el('button','col');b.type='button';b.dataset.key=c.k
 function modelCard(m){var card=el('div','panel model');var head=el('div','model-head');head.appendChild(el('span','model-name mono',m.name));if(m.contract){var c=el('span','badge c','C');c.title='Contract enforced: a change to this column can fail its build';head.appendChild(c)}if(m.tests){head.appendChild(el('span','badge',plural(m.tests,'test')))}m.exposures.forEach(function(x){var b=el('span','badge x','\\u25a3 '+x);b.title='Exposure (dashboard or app) on this model';head.appendChild(b)});(m.flags||[]).forEach(function(x){var b=el('span','badge f',x);b.title='Noted by the engine: the trace through this model is less certain';head.appendChild(b)});card.appendChild(head);var meta=[m.folder,m.materialized].filter(Boolean).join(' \\u00b7 ');if(meta)card.appendChild(el('div','model-meta',meta));m.columns.forEach(function(c){card.appendChild(colButton(c))});return card}
 function hopBlock(h,dir){var d=el('div','hop');var cols=h.models.reduce(function(n,m){return n+m.columns.length},0);d.appendChild(el('div','hop-label',(dir==='up'?'Reads from \\u00b7 ':'')+plural(h.hop,'hop')+' '+(dir==='up'?'up':'down')+' \\u00b7 '+plural(h.models.length,'model')+' \\u00b7 '+plural(cols,'column')));var grid=el('div','models');h.models.forEach(function(m){grid.appendChild(modelCard(m))});d.appendChild(grid);return d}
 function section(f,i,dir){var sec=f[dir],lv=state.levels[i][dir],s=el('section','section');var head=el('div','section-head');head.appendChild(el('h2',null,dir==='up'?'Upstream: where it comes from':'Downstream: where it goes'));var total=sec.hops.length,hidden=sec.hops.filter(function(h){return h.hop>lv}).length;if(hidden>0){var more=el('button','more',hidden===1?'Show 1 more level':'Show more levels ('+hidden+' hidden)');more.type='button';more.addEventListener('click',function(){state.levels[i][dir]=lv+1;render()});head.appendChild(more);if(hidden>1){var all=el('button','more','Show all');all.type='button';all.addEventListener('click',function(){state.levels[i][dir]=Infinity;render()});head.appendChild(all)}}else if(total>DATA.defaultLevels&&lv>DATA.defaultLevels){var less=el('button','more','Back to '+DATA.defaultLevels+' levels');less.type='button';less.addEventListener('click',function(){state.levels[i][dir]=DATA.defaultLevels;render()});head.appendChild(less)}s.appendChild(head);if(sec.error){s.appendChild(el('div','empty',sec.error));return s}var shown=sec.hops.filter(function(h){return h.hop<=lv});if(!shown.length)s.appendChild(el('div','empty',dir==='up'?'Nothing upstream was traced for this column.':'No downstream model carries this column\\u2019s value.'));if(dir==='up')shown=shown.slice().reverse();shown.forEach(function(h){s.appendChild(hopBlock(h,dir))});if(sec.truncated)s.appendChild(el('div','note warn','The trace stopped at its limit: more may sit beyond the last level.'));return s}
-function stat(n,label,dim){var d=el('div','stat'+(dim?' dim':''));d.appendChild(el('b',null,n==null?'\\u2013':n));d.appendChild(el('span',null,label));return d}
+function stat(n,label,dim,tip){var d=el('div','stat'+(dim?' dim':''));if(tip)d.title=tip;d.appendChild(el('b',null,n==null?'\\u2013':n));d.appendChild(el('span',null,label));return d}
 function fold(title,count,items){var d=el('details','panel fold');var s=el('summary',null,title+' ');s.appendChild(el('span',null,'('+(count==null?'not reported':count)+')'));d.appendChild(s);var ul=el('ul');items.forEach(function(it){ul.appendChild(it)});if(!items.length)ul.appendChild(el('li','why',count==null?'Not reported by this altimate-code build.':count?'Only the count is known.':'None.'));d.appendChild(ul);return d}
 function li(name,rest){var l=el('li');l.appendChild(el('span','mono',name));if(rest){l.appendChild(document.createTextNode(' '));l.appendChild(el('span','why',rest))}return l}
 function words(parent,line){line.forEach(function(w){if(typeof w==='string')parent.appendChild(document.createTextNode(w));else parent.appendChild(el('code',null,w.code))});return parent}
@@ -730,13 +731,14 @@ function render(){
   var deep=el('div','deep');deep.appendChild(el('h2',null,'Column by column'));deep.appendChild(el('p',null,'Two levels up and down, with more on request. Click any column to light up its path; the rest dims and stays on the page.'));main.appendChild(deep);
   if(DATA.focuses.length>1){var tabs=el('div','tabs');tabs.setAttribute('role','tablist');DATA.focuses.forEach(function(g,j){var t=el('button','tab',g.column?g.model+'.'+g.column:g.model+' (model)');t.type='button';t.setAttribute('role','tab');t.setAttribute('aria-selected',j===i?'true':'false');t.addEventListener('click',function(){state.focus=j;state.selected=null;render()});tabs.appendChild(t)});main.appendChild(tabs)}
   var r=f.reach,stats=el('div','stats');
-  if(DATA.lookup){var uc=0,um={},uh=0,ue=!!f.up.error;f.up.hops.forEach(function(h){uh=Math.max(uh,h.hop);h.models.forEach(function(m){um[m.id]=1;uc+=m.columns.length})});stats.appendChild(stat(ue?null:uc,'columns upstream'));stats.appendChild(stat(ue?null:Object.keys(um).length,'models upstream'));stats.appendChild(stat(ue?null:uh,'hops up'))}
-  if(r){stats.appendChild(stat(r.columns,'columns downstream'));stats.appendChild(stat(r.models,'models carry it'));stats.appendChild(stat(r.ends,'end columns'));stats.appendChild(stat(r.mayCarry,'may carry it',!r.mayCarry));stats.appendChild(stat(r.cleared,'cleared',r.cleared==null))}
-  stats.appendChild(stat(f.modelLevel,'downstream at model level',true));main.appendChild(stats);
+  if(DATA.lookup){var uc=0,um={},uh=0,ue=!!f.up.error;f.up.hops.forEach(function(h){uh=Math.max(uh,h.hop);h.models.forEach(function(m){um[m.id]=1;uc+=m.columns.length})});stats.appendChild(stat(ue?null:uc,'columns upstream',false,'Columns the value is made from, followed all the way back'));stats.appendChild(stat(ue?null:Object.keys(um).length,'models upstream',false,'Models those columns sit in'));stats.appendChild(stat(ue?null:uh,'hops up',false,'How many models back the trace goes'))}
+  if(r){stats.appendChild(stat(r.columns,'columns downstream',false,'Columns the value flows into, at every level'));stats.appendChild(stat(r.models,'models carry it',false,'Downstream models with a column the value flows into'));stats.appendChild(stat(r.ends,'end columns',false,'Columns the value reaches that nothing further downstream reads'));stats.appendChild(stat(r.mayCarry,'models may carry it',!r.mayCarry,'Models that use the value in a way the trace can\\u2019t follow (a filter or a join, say), whose SQL couldn\\u2019t be read, or that read from a model like that'));stats.appendChild(stat(r.cleared,'models cleared',r.cleared==null,'Downstream of the model, but the value doesn\\u2019t reach them'))}
+  stats.appendChild(stat(f.modelLevel,'models downstream (model level)',true,'Every model downstream of this one, whether or not the value reaches it'));main.appendChild(stats);
   if(r&&(r.unresolved||r.truncated))main.appendChild(el('div','note warn','\\u26a0 Lower bound: '+[r.unresolved?plural(r.unresolved,'model')+' could not be read':'',r.truncated?'the trace hit its limit':''].filter(Boolean).join('; ')+'. See \\u201cNot resolved\\u201d below.'));
   else if(r)main.appendChild(el('div','note ok','\\u2713 Every downstream model was read.'));
   var inp=[];if(f.inputs.engine)inp.push('engine '+f.inputs.engine);inp.push(f.inputs.catalog?'with catalog types':'no catalog: types from the manifest');if(f.inputs.olderThanSql)inp.push('the manifest is older than the SQL');main.appendChild(el('div','inputs',inp.join(' \\u00b7 ')));
-  var lg=el('div','legend');['=','~','\\u0192','\\u03a3','?'].forEach(function(g){var s=el('span');s.appendChild(glyph(g,false));s.appendChild(document.createTextNode(HOW[g]));lg.appendChild(s)});var bn=el('span');bn.appendChild(glyph('=',true));bn.appendChild(document.createTextNode('matched by name'));lg.appendChild(bn);var cb=el('span');cb.appendChild(el('span','badge c','C'));cb.appendChild(document.createTextNode(' contract enforced'));lg.appendChild(cb);main.appendChild(lg);
+  var lg=el('div','legend');['=','~','\\u0192','\\u03a3','?'].forEach(function(g){var s=el('span');s.appendChild(glyph(g,false));s.appendChild(document.createTextNode(HOW[g]));lg.appendChild(s)});var bn=el('span');bn.appendChild(glyph('=',true));bn.appendChild(document.createTextNode('matched by name'));lg.appendChild(bn);var cb=el('span');cb.appendChild(el('span','badge c','C'));cb.appendChild(document.createTextNode(' contract enforced'));lg.appendChild(cb);
+  [['badge x','\u25a3','exposures on the model'],['badge f','!','noted by the engine'],['end','end','nothing further downstream reads it'],['sw','',DATA.lookup?'the column':'the changed column']].forEach(function(k){var s=el('span');s.appendChild(el('span',k[0],k[1]));s.appendChild(document.createTextNode(' '+k[2]));lg.appendChild(s)});main.appendChild(lg);
   var graph=null;if(!state.list){graph=graphPanel(f,i);main.appendChild(graph)}else{var lb=el('div','g-bar list-bar');lb.appendChild(el('span','g-title','Column list'));var gb=el('button','g-btn','Graph');gb.type='button';gb.addEventListener('click',function(){state.list=false;render()});lb.appendChild(gb);main.appendChild(lb);
   main.appendChild(section(f,i,'up'));
   var fc=el('div','panel focus');fc.appendChild(el('div','label',DATA.lookup?'The column':'The changed column'));var ti=el('div','title');if(f.key){ti.appendChild(colButton({key:f.key,column:f.model+'.'+(f.column||''),glyph:f.glyph||'?',byName:f.byName,end:false,type:null}))}else ti.appendChild(el('span','mono',f.column?f.model+'.'+f.column:f.model));fc.appendChild(ti);var hw=f.glyph?HOW[f.glyph]||'unknown':'';fc.appendChild(el('div','empty',(hw?hw.charAt(0).toUpperCase()+hw.slice(1)+' from what it reads'+(f.byName?' (matched by name)':'')+'. ':'')+(f.key?'Click any column to light up its path.':'')));main.appendChild(fc);
@@ -755,6 +757,7 @@ function applyHighlight(){var f=DATA.focuses[state.focus],bar=document.getElemen
   var shown={};cols.forEach(function(c){shown[c.dataset.key]=1});var hidden=Object.keys(p.all).filter(function(k){return!shown[k]}).length;
   bar.textContent='';bar.appendChild(el('span',null,'Path of '+state.selected.split('|')[0].split('.').pop()+'.'+state.selected.split('|').pop()+': '+plural(p.up,'column')+' upstream, '+plural(p.down,'column')+' downstream'+(hidden?' \\u00b7 '+hidden+' more on hidden levels or folded models':'')));var clr=el('button',null,'Clear');clr.type='button';clr.addEventListener('click',function(){select(state.selected)});bar.appendChild(clr)}
 ${graphLayout.toString()}
+${graphView.toString()}
 ${pressIsClick.toString()}
 ${GRAPH_VIEW_JS}
 document.addEventListener('keydown',function(e){if(e.key==='Escape'&&state.selected)select(state.selected)});
diff --git a/plugins/altimate-code/hooks/report-graph.test.ts b/plugins/altimate-code/hooks/report-graph.test.ts
index f306f4b..718323c 100644
--- a/plugins/altimate-code/hooks/report-graph.test.ts
+++ b/plugins/altimate-code/hooks/report-graph.test.ts
@@ -1,9 +1,9 @@
 import { describe, expect, test } from 'claude-code/testing'
-import { graphLayout as layoutOf, pressIsClick } from './report-graph'
+import { graphLayout as layoutOf, graphView, pressIsClick } from './report-graph'
 import { type ColumnAnswer, type ModelChange, reportData, reportHtml } from './impact-report'
 
 type Layout = {
-  boxes: { id: string; layer: number; x: number; y: number; h: number; name: string; title: string; collapsed?: boolean; count?: number; rows: { key: string }[] }[]
+  boxes: { id: string; layer: number; x: number; y: number; h: number; name: string; title: string; badge?: string; model?: string; collapsed?: boolean; count?: number; rows: { key: string }[] }[]
   edges: { from: string; to: string; keys: string[][]; label: string | null }[]
 }
 const graphLayout = layoutOf as (focus: unknown, levels: { up: number; down: number }, expanded: Record<number, boolean>) => Layout
@@ -113,6 +113,53 @@ describe('report graph layout', () => {
     expect(box.name).toBe(`${long.slice(0, 27)}…`)
     expect(box.title.startsWith(long)).toBe(true)
   })
+
+  test("cuts a name shorter when the box carries a badge, so the two don't run into each other", () => {
+    const long = 'mrt_tableau_dashboard_cost_attribution'
+    const down = answer([long, 'plain'])
+    down.nodes[1] = { ...down.nodes[1]!, contract: true, exposures: ['exec', 'ops'] }
+    down.flags = [{ model: 1, flag: 'filter_rewritten' }]
+    const boxes = layer(graphLayout(focusOf(down), { up: 0, down: 1 }, {}), 1)
+    const marked = boxes.find(box => box.title.startsWith(long))!
+    expect(marked.badge).toBe('C \u25a32 !')
+    // 28 characters less the badge and a space.
+    expect(marked.name).toBe(`${long.slice(0, 20)}…`)
+    expect(boxes.find(box => box.title.startsWith('plain'))!.badge).toBe('')
+  })
+
+  test('lists its boxes in reading order, left to right then top to bottom, which is the order Tab takes', () => {
+    const lay = graphLayout(focusOf(answer(['a', 'b'], { a: 'x', b: 'y' })), { up: 2, down: 2 }, {})
+    expect(lay.boxes.map(box => box.name)).toEqual(['orders', 'stg_orders', 'fct', 'a', 'b', 'x', 'y'])
+    // A column read out to the keyboard names its model too: many models share a column name.
+    expect(lay.boxes.map(box => box.model)).toEqual(['orders', 'stg_orders', 'fct', 'a', 'b', 'x', 'y'])
+    expect(lay.boxes.every((box, i) => i === 0 || lay.boxes[i - 1]!.layer < box.layer || (lay.boxes[i - 1]!.layer === box.layer && lay.boxes[i - 1]!.y < box.y))).toBe(true)
+  })
+})
+
+describe('the first view of the graph', () => {
+  const bounds = { x: -656, y: -100, w: 1640, h: 200 }
+  const focus = { x: 118, y: 0 }
+  test('shows the whole graph when it fits at a readable zoom, and never zooms past 1', () => {
+    expect(graphView({ w: 990, h: 600 }, bounds, focus, false)).toEqual({ k: (990 - 32) / 1640, x: 495 - (bounds.x + 820) * ((990 - 32) / 1640), y: 300 })
+    expect(graphView({ w: 990, h: 600 }, { x: 0, y: 0, w: 236, h: 50 }, focus, false).k).toBe(1)
+  })
+
+  test('in a narrow panel, starts on the changed column at 0.7, where the whole graph would be unreadable', () => {
+    const narrow = graphView({ w: 398, h: 600 }, bounds, focus, false)
+    expect(narrow).toEqual({ k: 0.7, x: 199 - focus.x * 0.7, y: 300 })
+    // A wide panel only steps in below 0.35.
+    expect(graphView({ w: 990, h: 600 }, { ...bounds, w: 4000 }, focus, false).k).toBe(0.35)
+    // Fit always shows the whole graph.
+    expect(graphView({ w: 398, h: 600 }, bounds, focus, true).k).toBe((398 - 32) / 1640)
+  })
+
+  test('the page runs the same function, and a column reached by Tab is brought into the panel', () => {
+    const html = reportHtml(reportData([CHANGE], [{ model: 'fct', column: 'revenue', down: answer(['a']), up: UP, modelLevel: null, failed: false }], TASK))
+    expect(html).toContain('function graphView(')
+    expect(html).toContain('v=graphView(size(),lay.bounds,lay.focus,force)')
+    expect(html).toContain("row.addEventListener('focus',function(){if(!row.matches(':focus-visible'))return;")
+    expect(html).toContain("'aria-label':r.title+' in '+b.model+': light up its path'")
+  })
 })
 
 describe('a press on the graph', () => {
diff --git a/plugins/altimate-code/hooks/report-graph.ts b/plugins/altimate-code/hooks/report-graph.ts
index 1277d4a..d9adf5d 100644
--- a/plugins/altimate-code/hooks/report-graph.ts
+++ b/plugins/altimate-code/hooks/report-graph.ts
@@ -12,6 +12,10 @@
  *   then by name, so edges cross less and the order never depends on the data's order.
  * - An edge's `label` is its derivation when the engine told it (same, renamed, calculated,
  *   aggregated), else null: an unknown one is drawn without a label.
+ * - A box's `badge` says what the model carries (C a contract, ▣N exposures, ! an engine note); its
+ *   name is cut shorter to leave the badge room.
+ * - Boxes come in reading order, left to right and then top to bottom, which is the order Tab
+ *   visits their columns.
  *
  * The page runs this function's own source (`graphLayout.toString()`), so it uses nothing from
  * outside its body but the language's built-ins.
@@ -61,8 +65,14 @@ export function graphLayout(f: any, levels: { up: number; down: number }, expand
         it.keys.forEach(function (k: string) { at[k] = { x1: r1(x), x2: r1(x + G.boxW), y: r1(y + h / 2), box: box.id, folded: true } })
       } else {
         var m = it.model
-        box.name = cut(m.name, G.maxName)
+        var badge: string[] = []
+        if (m.contract) badge.push('C')
+        if ((m.exposures || []).length) badge.push('\u25a3' + m.exposures.length)
+        if ((m.flags || []).length) badge.push('!')
+        box.badge = badge.join(' ')
+        box.name = cut(m.name, G.maxName - (box.badge ? box.badge.length + 1 : 0))
         box.title = String(m.name) + (m.folder ? ' · ' + m.folder : '') + (m.materialized ? ' · ' + m.materialized : '')
+        box.model = String(m.name)
         box.focus = !!m.focus; box.contract = !!m.contract; box.tests = m.tests || 0; box.exposures = (m.exposures || []).length; box.flags = (m.flags || []).length
         box.rows = it.rows.map(function (r: any, i: number) {
           var ry = r1(y + G.headH + i * G.rowH + G.rowH / 2)
@@ -88,10 +98,26 @@ export function graphLayout(f: any, levels: { up: number; down: number }, expand
   })
   var minX = 0, minY = 0, maxX = 0, maxY = 0
   boxes.forEach(function (b) { minX = Math.min(minX, b.x); minY = Math.min(minY, b.y); maxX = Math.max(maxX, b.x + b.w); maxY = Math.max(maxY, b.y + b.h) })
-  var fb = boxes[0]
+  boxes.sort(function (a, b) { return a.layer - b.layer || a.y - b.y })
+  var fb = boxes.filter(function (b) { return b.layer === 0 })[0]
   return { boxes: boxes, edges: edges, bounds: { x: minX, y: minY, w: maxX - minX, h: maxY - minY }, focus: fb ? { x: fb.x + fb.w / 2, y: fb.y + fb.h / 2 } : { x: 0, y: 0 } }
 }
 
+/**
+ * `graphView(size, bounds, focus, whole)`: the zoom and pan that first show a graph of `bounds` in a
+ * panel of `size`. The whole graph when it fits at a readable zoom, else the changed column at that
+ * zoom, centred: 0.35 in a wide panel, 0.7 in a narrow one (under 640 px), where less is unreadable.
+ * `whole` (the Fit button) always shows the whole graph. Never above 1. The page runs this
+ * function's own source, like graphLayout's.
+ */
+export function graphView(size: { w: number; h: number }, bounds: { x: number; y: number; w: number; h: number }, focus: { x: number; y: number }, whole: boolean): { k: number; x: number; y: number } {
+  var k = Math.min(1, (size.w - 32) / Math.max(1, bounds.w), (size.h - 32) / Math.max(1, bounds.h))
+  var floor = size.w < 640 ? 0.7 : 0.35
+  if (k < floor && !whole) return { k: floor, x: size.w / 2 - focus.x * floor, y: size.h / 2 - focus.y * floor }
+  k = Math.max(0.05, k)
+  return { k: k, x: size.w / 2 - (bounds.x + bounds.w / 2) * k, y: size.h / 2 - (bounds.y + bounds.h / 2) * k }
+}
+
 /**
  * `pressIsClick(press, release)`: whether a press and release on the graph is a click on what was pressed, a column or a
  * folded level. It is when both are on the same thing and the pointer moved at most 12 px between them, as a hand drifts
@@ -105,7 +131,7 @@ export function pressIsClick(press: { x: number; y: number; target: string | nul
 /**
  * The graph panel: draws `graphLayout` as SVG, and handles zoom (wheel, pinch, buttons, + and -),
  * pan (drag, arrow keys), fit (0, or the Fit button) and column clicks, which call the page's
- * `select(key)`. Uses the page's `el`, `state`, `render` and `GLYPH`, and `pressIsClick`.
+ * `select(key)`. Uses the page's `el`, `state`, `render` and `GLYPH`, `graphView` and `pressIsClick`.
  */
 export const GRAPH_VIEW_JS = `
 var SVG='http://www.w3.org/2000/svg';
@@ -133,12 +159,11 @@ function graphPanel(f,i){
     g.appendChild(sv('title',{},b.title));
     g.appendChild(sv('rect',{width:b.w,height:b.h,rx:8,'class':'g-rect'}));
     g.appendChild(sv('text',{x:10,y:19,'class':'g-name'},b.name));
-    var badge=[];if(b.contract)badge.push('C');if(b.exposures)badge.push('\\u25a3'+b.exposures);if(b.flags)badge.push('!');
-    if(badge.length)g.appendChild(sv('text',{x:b.w-10,y:19,'class':'g-badge','text-anchor':'end'},badge.join(' ')));
+    if(b.badge)g.appendChild(sv('text',{x:b.w-10,y:19,'class':'g-badge','text-anchor':'end'},b.badge));
     if(b.collapsed){g.appendChild(sv('text',{x:10,y:48,'class':'g-more'},b.sub+' \\u00b7 click to show them'));g.setAttribute('tabindex','0');g.setAttribute('role','button');
       var open=function(){state.expanded[i][b.layer]=true;state.views[i]=null;render()};opens[b.id]=open;g.addEventListener('click',function(ev){ev.stopPropagation();if(tookPress)return;open()});g.addEventListener('keydown',function(ev){if(ev.key==='Enter'||ev.key===' '){ev.preventDefault();open()}})}
     b.rows.forEach(function(r){
-      var row=sv('g',{'class':'g-row','data-key':r.key,tabindex:0,role:'button','aria-label':r.title+': light up its path',transform:'translate(0,'+(r.y-b.y-10)+')'});
+      var row=sv('g',{'class':'g-row','data-key':r.key,tabindex:0,role:'button','aria-label':r.title+' in '+b.model+': light up its path',transform:'translate(0,'+(r.y-b.y-10)+')'});
       row.appendChild(sv('title',{},r.title));
       row.appendChild(sv('rect',{x:4,y:0,width:b.w-8,height:20,rx:4,'class':'g-hit'}));
       row.appendChild(sv('text',{x:12,y:14,'class':'g-glyph '+(GLYPH[r.glyph]||'unk')+(r.byName?' byname':'')},r.glyph||'?'));
@@ -147,19 +172,20 @@ function graphPanel(f,i){
       // A pointer press is decided at its release (pressIsClick); this click is the keyboard's or a script's.
       row.addEventListener('click',function(ev){ev.stopPropagation();if(tookPress)return;select(r.key)});
       row.addEventListener('keydown',function(ev){if(ev.key==='Enter'||ev.key===' '){ev.preventDefault();select(r.key)}});
+      // Tab to a column outside the panel brings it in; a pointer's focus leaves the graph where it is.
+      row.addEventListener('focus',function(){if(!row.matches(':focus-visible'))return;var a=row.getBoundingClientRect(),s=svg.getBoundingClientRect(),dx=0,dy=0;
+        if(a.left<s.left+8)dx=s.left+8-a.left;else if(a.right>s.right-8)dx=s.right-8-a.right;if(a.top<s.top+8)dy=s.top+8-a.top;else if(a.bottom>s.bottom-8)dy=s.bottom-8-a.bottom;
+        if(dx||dy){v.x+=dx;v.y+=dy;apply()}});
       g.appendChild(row)});
     gB.appendChild(g)});
   p.appendChild(svg);
   if(lay.edges.some(function(e){return!e.label}))p.appendChild(el('div','g-note','Dashed, unlabelled: the engine couldn\u2019t tell how the value changes.'));
-  var hint=el('div','g-hint','Drag to move \\u00b7 wheel or pinch to zoom \\u00b7 click a column to light up its path');p.appendChild(hint);
+  var hint=el('div','g-hint','Upstream on the left, downstream on the right \\u00b7 drag to move \\u00b7 wheel or pinch to zoom \\u00b7 click a column to light up its path');p.appendChild(hint);
   // Zoom and pan: one transform, kept per focus while levels change.
   var v=state.views[i],moved=false;
   function apply(){vp.setAttribute('transform','translate('+Math.round(v.x)+','+Math.round(v.y)+') scale('+Math.round(v.k*1000)/1000+')')}
   function size(){var r=svg.getBoundingClientRect();return {w:r.width||800,h:r.height||500}}
-  function fit(force){var s=size(),bb=lay.bounds,k=Math.min(1,(s.w-32)/Math.max(1,bb.w),(s.h-32)/Math.max(1,bb.h));
-    if(k<0.35&&!force){k=0.35;v={k:k,x:s.w/2-lay.focus.x*k,y:s.h/2-lay.focus.y*k}}
-    else{k=Math.max(0.05,k);v={k:k,x:s.w/2-(bb.x+bb.w/2)*k,y:s.h/2-(bb.y+bb.h/2)*k}}
-    state.views[i]=v;apply()}
+  function fit(force){v=graphView(size(),lay.bounds,lay.focus,force);state.views[i]=v;apply()}
   function zoomAt(k2,px,py){k2=Math.min(3,Math.max(0.05,k2));v.x=px-(px-v.x)*k2/v.k;v.y=py-(py-v.y)*k2/v.k;v.k=k2;apply()}
   function zoomBy(m){var s=size();zoomAt(v.k*m,s.w/2,s.h/2)}
   svg.addEventListener('wheel',function(ev){ev.preventDefault();var r=svg.getBoundingClientRect();zoomAt(v.k*Math.exp(-ev.deltaY*0.0015),ev.clientX-r.left,ev.clientY-r.top)},{passive:false});
@@ -228,4 +254,5 @@ export const GRAPH_CSS = `
 body.hl .g-edge{opacity:.12}body.hl .g-edge.on{opacity:1}body.hl .g-edge.on path{stroke-opacity:1;stroke-width:2.2}
 body.hl .g-row{opacity:.3}body.hl .g-row.on{opacity:1}body.hl .g-row.on .g-hit{fill:var(--accent-soft)}body.hl .g-row.sel .g-hit{fill:var(--focus)}
 body.hl .g-box{opacity:.55}body.hl .g-box.has-on,body.hl .g-box.focus{opacity:1}
+@media (max-width:560px){.graph{height:min(68vh,640px);min-height:380px}}
 `