Skip to content

fix: launch blockers — no false zero in the column summary, no start-up nags, old CLI shown, narrow-terminal line, settings text (1.8.1) - #38

Merged
hkaltai merged 12 commits into
mainfrom
fix/plugin-launch-blockers
Nov 19, 2026
Merged

hkaltai merged 12 commits into
mainfrom
fix/plugin-launch-blockers

Conversation

@hkaltai

@hkaltai hkaltai commented Nov 19, 2026 •

Copy link
Copy Markdown
Contributor

Seven launch issues in the plugin, fixed together in one PR. Version 1.8.0 → 1.8.1.

What changed

A. No upgrade toast at session start. A missing altimate-code doesn't toast either. A CLI that is installed but refused to start keeps its own error words. On main, when the installed altimate-code had no dbt_health tool, the health check at session start (and after each turn) popped "needs an altimate-code build newer than 0.12.10". That version is wrong now, since 0.12.11 is out. The toast no longer appears. Only /health, which you run yourself, says it, and it names the tool and the install command instead of a version: "Project health needs an altimate-code release with the dbt_health tool: npm i -g @altimateai/altimate-code". Other features checked for the same problem:

  • docs, cte-profile, comments, sql-graph, to-model, defer, runs, integrations and review-notices only say it when you use them, so they stay as they were.
  • The docs messages that said "newer than 0.12.10" now give the install command.
  • Test: an altimate-code without the dbt_health tool toasts nothing at session start or at a turn; /health says what to install.

B. No false "reaches 0 columns in 0 models". Reproduction and root cause are below.

  • When the models that read the column have no compiled SQL, the band, the log line and the report say "not traced: N downstream models have no compiled SQL (run dbt compile)".
  • Every changed column is still asked about by name. If the SQL from before the task didn't name the column and the manifest from before the task lacks it, the band says its reach is unknown ("not in the manifest from before the task (new in it?)"). The old name of a rename is still traced.
  • A downstream model that was read only in part (read_in_part, read_columns_unknown, unclear_sql, capped) also makes the reach unknown. A model read in full that the value wasn't traced to keeps main's wording: "reaches 0 … · N more may change".
  • The report's downstream section and /lineage-report <model>.<column> follow the same rules. So does the per-edit impact note, both to Claude and, with show_edit_impact on, in the transcript.
  • A column found with nothing downstream still says it reaches 0.
  • Tests:
    • a column whose downstream models have no compiled SQL is not shown as reaching 0 …. Its fixture is the JSON the real 0.12.11 CLI returned.
    • a renamed column is never shown as reaching 0 columns in 0 models …
    • a column the queried manifest does not know is not shown as 0 …
    • a column found in the manifest with nothing downstream still says it reaches 0 (a guard: it passes on main too).
    • a column the SQL from before the task did not name but the manifest has (a select * spelled out) is traced by name, with its real reach
    • /lineage-report on a column the manifest answers without reaching is a plain error, never a report that it reaches 0
    • an edit whose readers have no compiled SQL never notes that it reaches 0, to Claude or the person
    • an edit whose answer never reaches the column is unchecked, never a reach of 0
    • models read in full that the value was not traced to keep the reach at 0 with "may change"; only unread models make it unknown

C. An old altimate-code is shown, not used silently.

  • Once per interactive session, in the background, the plugin runs --version on the binary it would use (altimate, then altimate-code).
  • If that version is older than MIN_ALTIMATE_CODE (0.12.11), a part stays at the end of the status line, after the feature parts so it never hides them: "altimate 0.12.9 found at /opt/bin/altimate; this plugin needs ≥ 0.12.11: npm i -g @altimateai/altimate-code".
  • With no CLI on PATH, it says the CLI is not installed. A current version, a preview build (0.0.0-…) or an unreadable version shows nothing. The last version the CLI prints is the one read.
  • README (install and troubleshooting), commands/*.md and skills/*/SKILL.md now give one install method, npm i -g @altimateai/altimate-code. The curl method and the unscoped npm install -g altimate-code are gone.
  • Tests:
    • versions are read from what --version prints and compared as semver
    • a session start with an altimate-code older than the plugin needs keeps a line on the status line …
    • … with a current altimate-code leaves the status line without the line
    • … with no altimate-code on PATH says it is not installed …
    • a version answer nobody can read leaves the status line alone
    • a preview build of altimate-code leaves the status line alone
    • with no altimate on PATH the version of altimate-code is the one checked and named
    • with nobody at the prompt the version is not checked

D. Lineage pane on a narrow terminal. The one-off 10-second toast is now backed by a line above the prompt. It gives the width the pane needs and stays until the pane can open or /lineage is used. README: "make the text smaller (Cmd -) or type /lineage". Tests:

  • a pane left undrawn keeps its reason on the band until /lineage opens it
  • the narrow-terminal band clears once the terminal is wide enough

E. Settings text. healthBlocksPush now also says a push is held while the check cannot run or has not finished.

  • maxScanBytes, commentsPollSeconds and commentsInContext no longer say "not used yet" (both features are on main). Each now says what it does.
  • Every option's description ends with "Optional; default: …".
  • The README settings table matches plugin.json.
  • Checked with claude plugin validate --strict and by comparing each stated default against the code. The test runner cannot load plugin.json, so there is no unit test for this.

F. Test count with a column in focus. The pane now counts only the tests on that column of the model ("3 tests on amount"). Names are compared case-insensitively and with one layer of quotes removed. With no column in focus, or when the graph doesn't say which column each test checks (a manifest over 4 MiB, read through altimate-code), it keeps the count of tests downstream. A test with no attached_node counts only when the model is its only parent. The followed model's subgraph also dropped each test's column; that is fixed too. The pane says "1 test", not "1 tests". Tests:

  • with a column in focus the pane counts only that column's tests; without one, the model's
  • the followed model's subgraph keeps each test's column

G. show_edit_impact setting (off by default). When it is on, the per-edit impact note Claude gets is also shown in the transcript. When it is off, nothing changes. It is documented in the README and plugin.json. Test: the per-edit impact note stays off the transcript unless show_edit_impact is set.

B: reproduction (real altimate-code 0.12.11)

Real dbt project: stg_orders(order_id, amount) is read by order_totals and order_report. target/manifest.json comes from dbt parse, so no node has compiled SQL. That is the state after the plugin's own doctor offers Run dbt parse.

The plugin's call at the end of the task, made against the copy of the manifest taken when the task started:

altimate tool run impact_analysis --args '{"manifest_path":"<task-start copy>","model":"stg_orders","column":"amount","change_type":"modify","direction":"downstream"}' --json

The answer: counts {columns:0, models:0, ends:0, may_carry_models:2, model_level:2}. columns holds only the column itself. unresolved has 2 entries, each "no compiled SQL: run dbt compile". There is no column_answer_error. Asking for a column the manifest doesn't have (the new name after a rename) returns the same shape with a parse-only manifest. With a compiled manifest the engine reports an error for it instead ("stg has no column total"), which main already showed as "could not be traced".

Before (main):

amount  reaches 0 columns in 0 models (0 end columns) · 2 more may change · ⚠ Lower bound: 2 models could not be read

After:

amount  not traced: 2 downstream models have no compiled SQL (run `dbt compile`) · ⚠ Lower bound: 2 models could not be read

Root cause: the band read an answer that reached no column as a real zero. That happens when the models downstream could not be read (no compiled SQL) or when the column isn't in the manifest that was asked (added or renamed in the task). The fix: an answer that reaches no column while models it reads were left unread (unresolved, or "may carry") is shown as not traced. A column added in the task is asked about only at the model level.

Tests

  • claude plugin test plugins/altimate-code at 3f40e70 (main merged in, so test: cost and runs tests pass with both features on #37 included): 1171 pass, 0 fail.
  • Earlier, at f237e53 before main was merged in: 1135 pass, 12 fail. 11 of those also fail on main before test: cost and runs tests pass with both features on #37 (10 cost/runs "overlapping dbt commands", 1 health push-gate stall). The 12th is the known "a line with a great many dbt calls" timing flake.
  • With test: cost and runs tests pass with both features on #37 merged (main now contains it; the tree is the same as git merge-tree --write-tree of this branch and origin/fix/cost-runs-together, which had no conflicts): 1167 pass, 0 fail. One earlier run hit the two known timing flakes.
  • claude plugin validate --strict . passes. claude plugin validate --strict ./plugins/altimate-code reports the same warnings as on main, all from before this PR: icon, two setTimeout warnings, network hosts.
  • bash tests/*.sh: all 8 pass.
  • Every new regression test was run against the code before its fix and failed there. For the D, F and G tests and the version check, the test files don't load against main's sources, because the exports they use don't exist there yet.

Review

/review-loop used claude -p and codex exec -m gpt-6.1-sol as independent reviewers across 8 rounds. The MAJORs found along the way are all fixed with tests:

  • undeclared pane state
  • the per-column count on CLI graphs and on unattached tests
  • the report's downstream text
  • a start toast for a missing CLI
  • /lineage-report without the hop-0 check
  • the per-edit note's false zero
  • the per-edit note's fallback to the older reach

Both reviewers approved f237e53, then b216dd2 (after main with #37 was merged in), then 3f40e70 (Kilo's three threads on a7c7b3f fixed: the band footer, the reason text in the per-edit note, and one shared not-found pattern).

Notes and limits

  • This PR does not touch hooks/features/cost.tsx, so it does not overlap with test: cost and runs tests pass with both features on #37.
  • Two limits I chose to accept:
    • The narrow-terminal line compares the width of the chat area with the width the pane needs. While another plugin's pane is docked it can stay up a little after the terminal is wide enough, but it never hides when it shouldn't.
    • Manifests from before dbt 1.5, which have no attached_node, don't count multi-parent tests (such as relationships) in the per-column count.
  • The version check looks at the binary runAltimate uses (altimate, else altimate-code). MCP mode starts altimate-code; npm installs both names together.

🤖 Generated with Claude Code

…up nags, old CLI shown, narrow-terminal line, settings text, per-column test count (1.8.1)

- column summary: a column whose downstream models have no compiled SQL, or one
  added or renamed in the task, is shown as not traced, never as reaching 0
- an altimate-code without dbt_health is told only by /health, not by a toast
  at session start
- an altimate-code older than the plugin needs keeps a status-line part with
  its version, binary path and the npm install command
- a terminal too narrow for the lineage pane keeps a line above the prompt
- settings: accurate descriptions, each optional with its default; new
  show_edit_impact (off by default)
- with a column in focus the lineage pane counts only that column's tests
- one install method (npm) across README, commands and skills

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@hkaltai
hkaltai marked this pull request as ready for review November 19, 2026 05:29
Comment thread plugins/altimate-code/hooks/lineage.tsx Outdated
<Box flexDirection="column">
<Text dimColor>
{counts.direct} direct · {counts.transitive}{graph.truncated ? '+' : ''} transitive · {counts.tests} tests ·{' '}
{counts.direct} direct · {counts.transitive}{graph.truncated ? '+' : ''} transitive · {column ? `${testsOnColumn(graph, focus.model, column)} tests on ${column}` : `${counts.tests} tests`} ·{' '}

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

SUGGESTION: Singular count reads "1 tests on amount"

testsOnColumn returns a number interpolated directly before the literal tests, so a column with exactly one test renders "1 tests on amount". Use the plural helper this file already imports.

Suggested change
{counts.direct} direct · {counts.transitive}{graph.truncated ? '+' : ''} transitive · {column ? `${testsOnColumn(graph, focus.model, column)} tests on ${column}` : `${counts.tests} tests`} ·{' '}
{counts.direct} direct · {counts.transitive}{graph.truncated ? '+' : ''} transitive · {column ? `${plural(testsOnColumn(graph, focus.model, column), 'test')} on ${column}` : `${counts.tests} tests`} ·{' '}

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in aeed9d5. The count goes through plural: the pane says "1 test on amount" (testCountText in hooks/lineage-graph.ts).

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in aeed9d5. The pane's count now goes through testCountText (lineage-graph.ts:334), which uses plural, so it reads "1 test on amount".

}
}

const isTestType = (type: string) => type === 'test' || type === 'unit_test'

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

SUGGESTION: isTestType duplicates isTest

isTest (line 249) already encodes the same set ('test' and 'unit_test'). Two definitions of one predicate can drift if another test type is added, and nodeOf is the natural place to reuse the shared definition. Consider one constant/helper used by both.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in 55e9b1c. nodeOf and isTest now share one TEST_TYPES set in hooks/lineage-graph.ts.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in 55e9b1c. isTestType is gone, and test detection uses the one isTest/TEST_TYPES definition.

export function testsOnColumn(graph: LineageGraph, id: string, column: string): number {
return downstreamOf(graph, id).testIds.filter(test => {
const node = graph.nodes[test]
return node?.testColumn === column && (!node.testOn || node.testOn === id)

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

SUGGESTION: Downstream tests with the same column name are counted when attached_node is absent

When testOn is null (manifests or dbt versions without attached_node, and graphs handed over by altimate-code's dbt_lineage), !node.testOn accepts every downstream test whose column_name matches, including tests attached to downstream models. For a common name (id, amount) this over-counts "tests on ". Fall back to checking the test's actual dependency on id (e.g. its direct parent) instead of accepting all tests with the name.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in aeed9d5. A test with no attached_node counts only when the focused model is its one parent. The subgraph keeps each test's parents. Test: "a test dbt does not attach to a model counts for a column only when that model is its one parent".

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in aeed9d5. Without attached_node, a test counts only when the model is its only parent (lineage-graph.ts:328), so tests on downstream models with the same column name are no longer counted.

if (n === 0) return null
if (missing > 0) return `not traced: ${count(missing, 'downstream model')} ${missing === 1 ? 'has' : 'have'} no compiled SQL (run \`dbt compile\`)`
const why = (answer.unresolved ?? []).map(one => String(one?.reason ?? '')).find(Boolean)
return `not traced: ${count(n, 'downstream model')} could not be read${why ? ` (${why})` : ''}`

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

SUGGESTION: "could not be read" is wrong for may-carry models

n is max(unresolved, mayCarry), and may_carry reasons include star, natural_join, names_column and reads_value_model — models that were read, where the value just wasn't traced. When missing === 0 and only mayCarry contributes, this line tells the user those models "could not be read", which is false. Branch the wording (for example "N downstream models may carry it") or surface the may-carry reason when it is the source of the count.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in 0754bcd, and refined in f237e53. Models read in full that the value wasn't traced to (not_traced, star, …) keep "reaches 0 … · N more may change". Only unread models, or models read in part (unresolved, read_in_part, read_columns_unknown, unclear_sql, capped), make the reach unknown. Unit test in hooks/impact-report.test.ts.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed. Models that were read in full but not traced (star, natural_join, …) no longer count toward "could not be read". Only unread models (unresolved) and models read in part (PARTLY_READ: read_in_part, read_columns_unknown, unclear_sql, capped) make the reach unknown (impact-report.ts:232-240). A real zero next to fully-read may-carry models still shows "reaches 0 · N more may change".

const r = reachOf(answer)
if (r.columns > 0 || r.models > 0) return null
const missing = (answer.unresolved ?? []).filter(one => /no compiled sql/i.test(String(one?.reason ?? ''))).length
const n = Math.max(r.unresolved, r.mayCarry)

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

SUGGESTION: The zero guard ignores missing

missing is counted from answer.unresolved, but the early return only checks r.unresolved/r.mayCarry, which prefer the engine's counts. If the engine reports unresolved_models: 0 (or may_carry_models: 0) while unresolved still lists models with no compiled SQL, n === 0 returns null and the false zero this function exists to prevent is shown again. Include missing in the guard.

Suggested change
const n = Math.max(r.unresolved, r.mayCarry)
const n = Math.max(r.unresolved, r.mayCarry, missing)

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in 55e9b1c. The unread count is the largest of counts.unresolved_models, the length of the unresolved list and the partial-read may-carry count (f237e53), so counts that say 0 can't hide a listed model.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed. unread takes the largest of the engine's count, the length of the unresolved list and the partly-read may-carry entries (impact-report.ts:236), so unresolved_models: 0 beside a non-empty unresolved no longer gives a false zero.

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 trace: ColumnTrace = { model: name, column, down: downAnswer, up: upAnswer, modelLevel: modelLevelOf(down.metadata), failed: false, ...unknownOf(downAnswer), consumers: consumersOf(down.metadata) }

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

SUGGESTION: /lineage-report skips the "no hop 0" guard applied in traceDown

traceDown treats an answer with no hop === 0 column as unchecked and reports "could not be traced" (lines 229-230). buildColumnReport passes that same empty answer straight to unknownOf, so with a parse-only manifest and a model that has no downstream models (may_carry_models: 0, no unresolved entries), unknownReach returns null and the report again says "reaches 0 columns in 0 models" for a column the manifest does not know. Apply the same columns.some(one => one.hop === 0) / unchecked check here.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in 0754bcd. buildColumnReport applies the same hop-0 check as traceDown. An answer that never reaches the column is a plain error telling you to run dbt parse/dbt compile, never a report that it reaches 0. Test: "/lineage-report on a column the manifest answers without reaching is a plain error …".

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Already guarded: buildColumnReport returns " has no column in target/manifest.json. Run dbt parse or dbt compile …" when the answer has no hop-0 entry (task-impact.tsx:554, added in 0754bcd). The case reads as not traced, not as reaching 0.

@kilo-code-bot

kilo-code-bot Bot commented Nov 19, 2026 •

Copy link
Copy Markdown

Code Review Summary

Status: No Issues Found | Recommendation: Merge

Incremental review of b216dd2..3f40e70 (4 files, 33 changed lines). The increment closes the two carried findings: summaryOf now counts partly-read may-carry models (read_in_part, read_columns_unknown, unclear_sql, capped) into view.unresolved when a column's reach is unknown, so the band prints "⚠ Lower bound" instead of "✓ Every downstream model was read", with a test covering the mixed-reach case; and the not-found wording now lives in one exported NOT_FOUND, with MISSING_BINARY rebuilt from it and the health check reusing it (equivalent alternation, no g flag so test() stays stateless). No new defects found on the changed lines.

Files Reviewed (4 files)
  • plugins/altimate-code/hooks/altimate-cli.ts
  • plugins/altimate-code/hooks/features/health.tsx
  • plugins/altimate-code/hooks/impact-report.ts
  • plugins/altimate-code/hooks/impact-report.test.ts
Previous Review Summaries (4 snapshots, latest commit b216dd2)

Current summary above is authoritative. Previous snapshots are kept for context only.

Previous review (commit b216dd2)

Status: 2 Issues Found | Recommendation: Address before merge

Incremental review of a7c7b3f..b216dd2 (5 files, 33 changed lines). The increment adds no new defects: parseVersion is now fed stdout first with a stderr fallback, so a runtime note on stderr (Using node v22.1.0) no longer hides an old CLI on stdout, while a version printed only on stderr is still read; both new tests in integrations.test.tsx exercise those paths, and the helper's { stderr: '', ...got } spread keeps the default while letting a case supply its own stderr. The per-edit note now names the no-hop-0 case ("not in the manifest: dbt compile adds a new one"), which resolves the previous suggestion about the timeout-only wording, and every test that expected the old phrase was updated (no copy of "over the limit or no answer in time" remains). The status-line.ts change is comment rewrapping only, and STATUS_ORDER still puts the version notice last. Two carried findings remain.

Overview

Severity Count
CRITICAL 0
WARNING 1
SUGGESTION 1
Issue Details (click to expand)

WARNING

File Line Issue
plugins/altimate-code/hooks/impact-report.ts 238 Partly read may-carry models make a column "not traced", but summaryOf/summaryLines still count only answer.unresolved, so the band can print "✓ Every downstream model was read" under that column

SUGGESTION

File Line Issue
plugins/altimate-code/hooks/features/health.tsx 484 The not-found check copies three alternatives of MISSING_BINARY (altimate-cli.ts:16), giving two definitions of "the binary is not there"
Files Reviewed (8 files)
  • plugins/altimate-code/hooks/altimate-cli.ts - no issues
  • plugins/altimate-code/hooks/integrations.test.tsx - no issues
  • plugins/altimate-code/hooks/lineage.test.tsx - no issues
  • plugins/altimate-code/hooks/lineage.tsx - no issues
  • plugins/altimate-code/hooks/status-line.ts - no issues
  • plugins/altimate-code/hooks/impact-report.ts - 1 warning (targeted check, carried)
  • plugins/altimate-code/hooks/features/health.tsx - 1 suggestion (targeted check, carried)
  • plugins/altimate-code/hooks/lineage-graph.ts - no issues (the pre-1.5 attached_node limit is documented and accepted; not re-raised)

Fix these issues in Kilo Cloud

Previous review (commit a7c7b3f)

Status: 4 Issues Found | Recommendation: Address before merge

Incremental review of 55e9b1c..a7c7b3f. The three findings fixed in f237e53 are resolved: partly read may-carry models (read_in_part, read_columns_unknown, unclear_sql, capped) now make a zero reach unknown, the added-column note no longer fires merely because before === null (every changed column is asked by name, and the note is only used when the manifest lacks it), and MISSING_BINARY no longer classifies a refused spawn as "not on PATH". Preview builds, the last-version read, the status-line order and the case/quote-folded test count are all verified. The one remaining previous suggestion is carried below.

Overview

Severity Count
CRITICAL 0
WARNING 1
SUGGESTION 3
Issue Details (click to expand)

WARNING

File Line Issue
plugins/altimate-code/hooks/impact-report.ts 238 Partial-read may-carry models make a column "not traced", but summaryOf/summaryLines still count only answer.unresolved, so the band can print "✓ Every downstream model was read" under that column

SUGGESTION

File Line Issue
plugins/altimate-code/hooks/lineage.tsx 942 A no-hop-0 answer is pushed into unchecked, so Claude is told the column was skipped for being "over the limit or no answer in time"
plugins/altimate-code/hooks/features/health.tsx 484 The new not-found regex copies three alternatives of MISSING_BINARY, giving two definitions of "the binary is not there"
plugins/altimate-code/hooks/lineage-graph.ts 329 Carried, still present: on manifests without attached_node, a multi-parent test (relationships) is never counted for a column; the PR documents this as an accepted limit
Files Reviewed (20 files)
  • plugins/altimate-code/.claude-plugin/plugin.json - no issues
  • plugins/altimate-code/CHANGELOG.md - no issues
  • plugins/altimate-code/README.md - no issues
  • plugins/altimate-code/hooks/altimate-cli.ts - no issues
  • plugins/altimate-code/hooks/altimate-cli.test.ts - no issues
  • plugins/altimate-code/hooks/features/docs.tsx - no issues
  • plugins/altimate-code/hooks/features/docs.test.tsx - no issues
  • plugins/altimate-code/hooks/features/health.tsx - 1 suggestion
  • plugins/altimate-code/hooks/health.test.tsx - no issues
  • plugins/altimate-code/hooks/impact-report.ts - 1 warning
  • plugins/altimate-code/hooks/impact-report.test.ts - no issues
  • plugins/altimate-code/hooks/integrations.test.tsx - no issues
  • plugins/altimate-code/hooks/lineage-graph.ts - 1 suggestion
  • plugins/altimate-code/hooks/lineage-graph.test.ts - no issues
  • plugins/altimate-code/hooks/lineage.tsx - 1 suggestion
  • plugins/altimate-code/hooks/lineage.test.tsx - no issues
  • plugins/altimate-code/hooks/status-line.ts - no issues
  • plugins/altimate-code/hooks/task-impact.tsx - no issues
  • plugins/altimate-code/hooks/task-impact.test.tsx - no issues
  • plugins/altimate-code/hooks/tool-chain.test.ts - no issues

Fix these issues in Kilo Cloud

Previous review (commit 55e9b1c)

Status: 4 Issues Found | Recommendation: Address before merge

Incremental review of b3a01f3..55e9b1c. All six findings from the previous round on the touched files are resolved (isTestType/isTest now share TEST_TYPES, the in-focus count is pluralized via testCountText, the attached_node over-count and the may-carry "could not be read" wording are fixed, the zero guard now includes the unresolved list, and /lineage-report rejects an answer without hop 0). The findings below are new to this pass.

Overview

Severity Count
CRITICAL 0
WARNING 2
SUGGESTION 2
Issue Details (click to expand)

WARNING

File Line Issue
plugins/altimate-code/hooks/impact-report.ts 236 Partially read may-carry models (read_in_part, read_columns_unknown, unclear_sql, capped) no longer make a zero reach untrusted, so the false "reaches 0 columns in 0 models" can still appear
plugins/altimate-code/hooks/impact-report.ts 260 ADDED_NOTE claims the pre-task manifest lacks a column whenever before === null, which also happens when select * is expanded into an explicit list

SUGGESTION

File Line Issue
plugins/altimate-code/hooks/lineage-graph.ts 325 The "only parent" fallback drops multi-parent (relationships) tests on manifests without attached_node, showing "0 tests on "
plugins/altimate-code/hooks/features/health.tsx 483 MISSING_BINARY also matches start/spawn/run failures, so an installed-but-blocked CLI is reported as not on PATH and no longer toasted
Files Reviewed (13 files)
  • plugins/altimate-code/CHANGELOG.md - no issues
  • plugins/altimate-code/README.md - no issues
  • plugins/altimate-code/hooks/features/health.tsx - 1 suggestion
  • plugins/altimate-code/hooks/health.test.tsx - no issues
  • plugins/altimate-code/hooks/impact-report.test.ts - no issues
  • plugins/altimate-code/hooks/impact-report.ts - 2 warnings
  • plugins/altimate-code/hooks/lineage-graph.test.ts - no issues
  • plugins/altimate-code/hooks/lineage-graph.ts - 1 suggestion
  • plugins/altimate-code/hooks/lineage.test.tsx - no issues
  • plugins/altimate-code/hooks/lineage.tsx - no issues
  • plugins/altimate-code/hooks/task-impact.test.tsx - no issues
  • plugins/altimate-code/hooks/task-impact.tsx - no issues
  • plugins/altimate-code/types/index.d.ts - no issues

Fix these issues in Kilo Cloud

Previous review (commit b3a01f3)

Status: 6 Issues Found | Recommendation: Address before merge

Overview

Severity Count
CRITICAL 0
WARNING 0
SUGGESTION 6
Issue Details (click to expand)

SUGGESTION

File Line Issue
plugins/altimate-code/hooks/lineage.tsx 1608 "1 tests on amount": the in-focus test count is not pluralized
plugins/altimate-code/hooks/lineage-graph.ts 43 isTestType duplicates isTest; the same predicate is defined twice and can drift
plugins/altimate-code/hooks/lineage-graph.ts 315 Without attached_node, tests on downstream models that share the column name are counted as tests on this column
plugins/altimate-code/hooks/impact-report.ts 240 "could not be read" is wrong when the count comes from may-carry models (star, natural_join, ...)
plugins/altimate-code/hooks/impact-report.ts 236 The zero guard ignores missing, so a 0 from the engine's counts can still produce the false "reaches 0"
plugins/altimate-code/hooks/task-impact.tsx 552 /lineage-report skips the no-hop-0 (unchecked) guard, so a column absent from a parse-only manifest can still read as "reaches 0"
Files Reviewed (30 files)
  • .claude-plugin/marketplace.json - no issues
  • plugins/altimate-code/.claude-plugin/plugin.json - no issues
  • plugins/altimate-code/CHANGELOG.md - no issues
  • plugins/altimate-code/README.md - no issues
  • plugins/altimate-code/commands/altimate.md - no issues
  • plugins/altimate-code/commands/review.md - no issues
  • plugins/altimate-code/commands/rules.md - no issues
  • plugins/altimate-code/hooks/altimate-cli.test.ts - no issues
  • plugins/altimate-code/hooks/altimate-cli.ts - no issues
  • plugins/altimate-code/hooks/features/comments.tsx - no issues
  • plugins/altimate-code/hooks/features/docs.test.tsx - no issues
  • plugins/altimate-code/hooks/features/docs.tsx - no issues
  • plugins/altimate-code/hooks/features/health.tsx - no issues
  • plugins/altimate-code/hooks/features/to-model.test.tsx - no issues
  • plugins/altimate-code/hooks/features/to-model.tsx - no issues
  • plugins/altimate-code/hooks/health.test.tsx - no issues
  • plugins/altimate-code/hooks/impact-report.ts - 2 suggestions
  • plugins/altimate-code/hooks/integrations.test.tsx - no issues
  • plugins/altimate-code/hooks/integrations.tsx - no issues
  • plugins/altimate-code/hooks/lineage-graph.test.ts - no issues
  • plugins/altimate-code/hooks/lineage-graph.ts - 2 suggestions
  • plugins/altimate-code/hooks/lineage.test.tsx - no issues
  • plugins/altimate-code/hooks/lineage.tsx - 1 suggestion
  • plugins/altimate-code/hooks/status-line.ts - no issues
  • plugins/altimate-code/hooks/task-impact.test.tsx - no issues
  • plugins/altimate-code/hooks/task-impact.tsx - 1 suggestion
  • plugins/altimate-code/hooks/tool-chain.test.ts - no issues
  • plugins/altimate-code/skills/altimate-code/SKILL.md - no issues
  • plugins/altimate-code/skills/review/SKILL.md - no issues
  • plugins/altimate-code/types/index.d.ts - no issues

Fix these issues in Kilo Cloud


Reviewed by deepseek-v4.1-flash-1017 · Input: 70.6K · Output: 12.5K · Cached: 620K

hkaltai and others added 4 commits November 19, 2026 11:15
…on CLI graphs and unattached tests, report downstream section, no health toast for a missing CLI

- lineageNarrow is declared in PluginState (strict plugin validation)
- a graph whose tests carry no column (altimate-code's include_graph) keeps the
  model-level count; a test dbt does not attach counts only when the focused
  model is its one parent; subgraph keeps each test's parents; '1 test'
- the report's downstream section says the reach is unknown instead of
  'No downstream model carries this column's value'
- a missing altimate-code is not toasted by the background health checks
- the band says a column added in the task has an unknown reach, as the report

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ot reach, may-carry stays 'may change', added vs untraced wording

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…s the engine's list when its counts say fewer

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… is asked of the live manifest when no copy was taken, version-check fallback and non-interactive tests

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
const r = reachOf(answer)
// Models read in full that the value was not traced to stay "may change" beside a real 0; only unread models make it
// unknown, counted from the engine's counts or its list, whichever names more.
const unread = Math.max(r.unresolved, answer.unresolved?.length ?? 0)

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

WARNING: A partially read model no longer makes a zero reach untrusted

unread now comes only from counts.unresolved_models / answer.unresolved. MAY_CARRY_REASONS above shows the engine also files models it did not fully read under may_carry: read_in_part (its SQL was read only in part), read_columns_unknown, unclear_sql, and capped (the trace stopped there). For an answer with counts: {columns: 0, models: 0}, unresolved: [] and may_carry: [{reason: read_in_part}], unread is 0, so this returns null and the band prints the exact "reaches 0 columns in 0 models" for a value that was not ruled out. Only not_traced (read in full) is safe to keep at 0; the partial-read reasons should still make the reach unknown.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. PARTLY_READ (unresolved, read_in_part, read_columns_unknown, unclear_sql, capped) in hooks/impact-report.ts counts those may-carry models as unread, so the reach is unknown, not 0. Only not_traced and the other read-in-full reasons keep the 0 with "may change". Unit test added.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. Models read only in part (read_in_part, read_columns_unknown, unclear_sql, capped) now count as unread (PARTLY_READ, impact-report.ts:236), so a zero with such a may-carry model shows as "not traced". There's a test in impact-report.test.ts.

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!, reach, failed: one.failed }
const note = one.unknown ?? (one.unchecked && one.column && change.columns.some(col => col.name === one.column && col.before === null) ? ADDED_NOTE : undefined)

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

WARNING: before === null does not mean the pre-task manifest lacks the column

ADDED_NOTE is attached to every trace with unchecked, and traceDown sets unchecked from col.before === null. But changedColumns derives before from selectItems, which cannot name the columns behind select *: rewrite select * from stg into an explicit column list and every listed column comes back with before: null. The band then tells the user "new in this task: its reach is unknown, not zero (the manifest from before the task lacks it)" for columns that were already there and are in the pre-task manifest. The same happens when an original select item cannot be parsed into a name. Consider wording that only says it could not be traced from before the task, rather than claiming the manifest lacks it.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. Every changed column is now asked about by name. The "not in the manifest from before the task (new in it?)" wording is used only when the old SQL didn't name the column and the manifest's answer shows it lacks it (an error, or no hop 0). A spelled-out select * is traced with its real reach. Test: "a column the SQL from before the task did not name but the manifest has … is traced by name, with its real reach".

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. Every changed column is asked by name. A column is called new only when the SQL from before didn't name it and the manifest lacks it too (a column error, or no hop 0) (task-impact.tsx:223-232). Expanding a select * therefore keeps the real reach.

if (node?.testColumn !== column) return false
if (node.testOn) return node.testOn === id
const parents = graph.parents[test] ?? []
return parents.length > 0 && parents.every(parent => parent === id)

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

SUGGESTION: Multi-parent tests are never counted for a column without attached_node

The fallback requires id to be the test's only parent. On manifests that have no attached_node (the case this fallback exists for), a relationships test's depends_on.nodes lists both the model under test and the referenced model/source, so parents.every(...) is false and the test is never counted. With a column in focus the pane then shows "0 tests on " even though a test checks it. Worth deciding whether those tests should count (e.g. via test_metadata) or documenting that pre-1.5 manifests only count single-parent tests.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Declined, documented as a limit in the PR body. attached_node has been in manifests since dbt 1.5. Without it, a multi-parent test (relationships) can't be tied to one model from depends_on alone, and counting it for every parent would bring back the over-count the per-column count exists to avoid. On those older manifests the pane counts single-parent tests only (hooks/lineage-graph.ts testsOnColumn).

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This one stays as it is, deliberately. Without attached_node, a multi-parent test such as relationships can't be placed on either model from the manifest alone, because its column_name belongs to only one of them. Counting it on every parent would bring back the over-count from the earlier comment, so the column count leaves it out. The model-level test count still includes it, and dbt 1.5+ manifests carry attached_node, which places it exactly.

const until = (await $.clock.now()) + CHECK_MS
result = await runTool($, 'dbt_health', toolArgs(options.healthConfigPath), { write: true, until })
} catch (error) {
if (MISSING_BINARY.test(String(error))) return { problem: NO_CLI }

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

SUGGESTION: MISSING_BINARY is wider than "the CLI is not on your PATH"

MISSING_BINARY (altimate-cli.ts:16) also matches (cannot|could not|failed to) (start|spawn|run), so an installed CLI whose process is refused (a sandbox denying the spawn, say) lands here and the user is told the CLI is not on PATH. tell() now suppresses that exact string, so the real failure is not toasted at all and only /health shows it. The generic branch below keeps the actionable message; consider matching a real not-found error here (ENOENT, not found, no such file), or leaving the generic wording when the error does not say that.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. Only a real not-found (ENOENT, not found, no such file) maps to the "not on your PATH" message (hooks/features/health.tsx check). A CLI that is there but refused to start keeps "Project health could not run: …" and is toasted. Test: "an altimate-code that is there but refused to start is not called missing …".

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. Health now maps only a binary that isn't there (ENOENT|not found|no such file) to the "not installed" problem. A spawn that's refused keeps its own words ("Project health could not run: …") and is toasted (health.tsx:483-484). There's a test in health.test.tsx.

hkaltai and others added 2 commits November 19, 2026 12:44
…either (no hop 0 is unchecked, unread readers make the reach unknown)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…olumn is not replaced by the older reach on the same result

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@sahrizvi sahrizvi left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Consensus review (Claude + Codex) of 55e9b1c: request changes.

Panel: Claude (lead) and Codex (codex exec -s read-only, default model). Codex reviewed on its own first, then checked the lead's findings. Both reach REQUEST_CHANGES. Codex raised both main majors on its own; the lead's checks with the real CLI reproduced them.

What holds. The launch blocker B is fixed for the case it targets. I recorded real answers from both the npm 0.12.11 CLI and a build of altimate-code main on a dbt-duckdb project. Parse-only and partly compiled zeros now say "not traced: N downstream models have no compiled SQL". Every compiled answer (a real reach, a real zero with "may change", a column error) reads exactly as on main. The push gate is unchanged and still fails closed. All seven settings texts match the code and the README. The tree merged with current main passes 1153 tests, 0 fail. Each guard I mutated (the not-traced decision, the zero guard, the hop-0 gate, the added rule, the semver compare, the interactive-only check) fails the PR's tests.

Blocking (3 majors, inline):

  • task-impact.tsx:225: rewriting a select * (or dbt_utils.star, or an unaliased amount::int) marks existing columns as "new in this task", so a real reach becomes "unknown". Main traced these. Asking by name is already safe with the real CLI.
  • altimate-cli.ts:82: a local preview build (0.0.0-<branch>-<time>, which has every tool) keeps the "needs ≥ 0.12.11" nag on the status line all session.
  • lineage.tsx:1275: with show_edit_impact on, the transcript shows … reaches 0 columns in 0 models, 4 may carry it on a parse-only manifest. That's B's false zero on G's new surface.

Minors (non-blocking):

  • Test count is exact on column case and quoting (lineage-graph.ts:322): edge input.
  • One docs message still gives a version, not the install command (docs.tsx:465): wording.
  • parseVersion reads the first x.y.z (:32): edge, an unusual wrapper.
  • A failing altimate stops the search, and MCP uses altimate-code (:81): edge PATH setup.
  • The status-line notice is long and comes first (status-line.ts:12): cosmetic.
  • The healthBlocksPush text leaves out the holds on a failed or missing check (plugin.json:41): wording, carried from an earlier review.

The engine-answer, version-string, settings and suite tables, plus the nits, are in the combined comment.

const down = answerOf(meta)
// A column the SQL from before the task lacks is no column of the task's manifest: asking for it
// would read as nothing downstream. Only the model's own count is asked.
const added = col.before === null

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Major (Codex and Claude): an existing column is treated as "new in this task" whenever the SQL from before the edit doesn't name it.

added = col.before === null relies on changedColumns/selectItems finding the column in the original SQL. Probed with the PR's own changedColumns:

changedColumns on common edits (before: null = treated as added)

Edit Result
select * from {{ ref("x") }} → select order_id, amount * 2 as amount … amount and order_id both added
select {{ dbt_utils.star(ref("x")) }} → … except=["amount"]) }}, amount * 2 as amount amount added
select order_id, amount::int → amount::bigint as amount amount added
plain, qualified, quoted alias, CTE, union existing (correct)

In each case amount is already in the manifest from the start of the task. Main traced it by name and showed its real reach. Now the band says new in this task: its reach is unknown, not zero, and the upstream trace is skipped. That's a real reach shown as not traced, on the path this PR changes. Expanding a select * into an explicit list is a common edit.

The short-circuit isn't needed for B. The real 0.12.11 CLI already makes asking by name safe:

  • On a parse-only manifest, a column the manifest lacks comes back with only itself at hop 0 and the downstream models in unresolved. unknownReach now shows that as "not traced".
  • On a compiled manifest it comes back as column_answer_error, which shows as "could not be traced".

Suggest always asking by name. Use the "added" wording only when the answer shows the manifest lacks the column (an error, or no hop-0 entry).

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53, as you suggested. Every changed column is asked about by name (hooks/task-impact.tsx traceDown). It is called "not in the manifest from before the task (new in it?)" only when the old SQL didn't name it and the answer shows the manifest lacks it (column_answer_error, or no hop 0). So select * spelled out, a star macro or a cast given its name now shows the real reach and is traced upstream for the report. Test: "a column the SQL from before the task did not name but the manifest has (a select * spelled out) is traced by name, with its real reach".

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. Every changed column is now asked by name (task-impact.tsx:223-226). "New in this task" is used only when the old SQL didn't name the column and the answer shows the manifest lacks it: a column_answer_error, or an answer with no hop-0 entry (:229-231). Expanding a select *, using dbt_utils.star(... except=...), or naming a cast keeps the real reach. Tests in task-impact.test.tsx cover the select * expansion and the real 0.12.11 answer for a missing column.

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53, and confirmed at 3f40e70. Every changed column is asked by name, and a column is called "not in the manifest" only when the old SQL didn't name it and the answer shows the manifest lacks it. I checked this with npm 0.12.11 and a local main build on a compiled dbt-duckdb manifest. A select * or dbt_utils.star rewrite into explicit columns, and an unaliased amount::int given its name on Postgres, now show their real reach (for example amount 4 columns in 4 models). Round 1's head said "new in this task". With the fix reverted, the new test fails. One edge remains: any engine exception is read as the column missing. It's in the round-2 review as a minor.

continue
}
const version = answer.exitCode === 0 ? parseVersion(`${answer.stdout ?? ''}\n${answer.stderr ?? ''}`) : null
if (!version || compareVersions(version, MIN_ALTIMATE_CODE) >= 0) return null

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Major (Codex and Claude): a local preview build of altimate-code gets the upgrade nag.

altimate-code's build script names a branch or local build 0.0.0-<branch>-<YYYYMMDDHHmm>, or 0.0.0--<time> on a detached HEAD (packages/script/src/index.ts). I built altimate-code main locally; its --version printed 0.0.0--202611190701. With that binary first on PATH, altimateCodeNotice returns:

altimate 0.0.0--202611190701 found at …/altimate; this plugin needs ≥ 0.12.11: npm i -g @altimateai/altimate-code

The session-start path puts it on the status line, where it stays all session. That build has dbt_health and every other tool the plugin needs. 0.0.0-dev gets the same nag. Suggest treating a 0.0.0-* version as a preview build and saying nothing, the way an unreadable version is handled. A test with 0.0.0-main-202611191200 would hold that.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. isPreviewBuild (hooks/altimate-cli.ts) treats a 0.0.0-… version as a preview build and says nothing, as for an unreadable version. Tests: "a preview build of altimate-code leaves the status line alone" (0.0.0-main-202611191200) and the unit test for 0.0.0--202611190701.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. isPreviewBuild treats any 0.0.0-* version (0.0.0-main-202611191200, 0.0.0--202611190701, 0.0.0-dev) as a preview build and says nothing (altimate-cli.ts:42, :87). There's a session-start test with 0.0.0-main-202611191200 in integrations.test.tsx, plus unit tests in altimate-cli.test.ts.

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53, and confirmed at 3f40e70. isPreviewBuild keeps 0.0.0--202611190701, 0.0.0-main-202611191200, 0.0.0-dev and the real local build (0.0.0--202611190944) quiet. Real npm 0.12.9 still gets the notice, and 0.12.11 doesn't. With the fix reverted, 2 tests fail.

if (note) {
$.ui.log(note.toast, { to: 'debug' })
// Opt-in: the same note on the transcript too.
if (showEditImpact) $.ui.log(note.toast)

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Major (Codex; Claude raised it as minor, and the code supports Codex's rating): with show_edit_impact on, the transcript shows the false zero that B removes from the band.

note.toast for a traced column is built at :965-:971 from reachOf alone. Nothing in that path checks for "not traced". With the real 0.12.11 answer on a parse-only manifest (no unresolved_models count, 4 entries in unresolved, each "no compiled SQL"), the PR's own reachOf and the template give:

◆ impact-first · stg_orders.amount reaches 0 columns in 0 models, 4 may carry it

Before this PR the line went only to the debug log. This line puts it in the transcript, with no lower-bound warning (only Claude's context copy has "lower bound: 4 models could not be read"). Suggest running the carried entries through unknownReach and using its words in the toast.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in a45d913 and 8498e57. impactFirst (hooks/lineage.tsx) treats an answer with no hop-0 column as unchecked, and doesn't fall back to the older column_reach on the same result. Each traced column goes through unknownReach, so the toast and log line say "stg_orders.amount not traced: 4 downstream models have no compiled SQL (run dbt compile)", not a count. The unread count also reads the unresolved list when unresolved_models is absent. Tests: "an edit whose readers have no compiled SQL never notes that it reaches 0, to Claude or the person" and "an edit whose answer never reaches the column is unchecked, never a reach of 0".

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in a45d913 (round 4). The per-edit note runs each carried answer through unknownReach, so on a parse-only manifest the transcript says "not traced: 4 downstream models have no compiled SQL (run dbt compile)" instead of "reaches 0". An answer with no hop 0 goes into the not-checked list. As of b216dd2, that line also names the missing-manifest reason: "(over the limit, no answer in time, or not in the manifest: dbt compile adds a new one)".

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in a45d913 and 8498e57, and confirmed at 3f40e70. On a real parse-only manifest the per-edit note says "not traced: 5 downstream models have no compiled SQL (run dbt compile)" and never "reaches 0". An answer with no hop 0 is listed as unchecked. Reverting unknownReach fails 1 test, and reverting the hop-0 gate fails another.

const tests = downstreamOf(graph, id).testIds.map(test => [test, graph.nodes[test]] as const)
if (tests.some(([, node]) => node?.testColumn === undefined)) return null
return tests.filter(([test, node]) => {
if (node?.testColumn !== column) return false

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor (Codex and Claude; edge input): the column match is exact, so case or quoting differences count 0 tests.

On a real dbt-duckdb 1.12.7 manifest, a not_null test on a column written Amount in YAML, with amount in focus, gives 0 tests on amount. Codex got the same result with column_name: '"amount"' and with backtick quoting. Matching after lower-casing and stripping one layer of quotes would cover it. This doesn't block: the model-level count is unchanged, and it needs YAML spelled differently from the SQL.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f5565b0 (case) and f237e53 (quotes). Names are compared after removing one layer of ", backtick or [] and folding case (bareName in hooks/lineage-graph.ts). Test: "a column typed in another case counts the tests on that column" now also covers "Revenue" against revenue.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed. Test columns are matched with case folded and one layer of quotes ("…", backticks, […]) taken off (lineage-graph.ts:313, :326), as suggested. Amount in YAML and "amount" both count for amount. There's a test in lineage-graph.test.ts.

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f5565b0 (case) and f237e53 (one layer of quotes), via bareName. With it reverted, the case test fails.

if (unrated && !saidOldReach) {
saidOldReach = true
lines.push('◆ docs · this altimate-code does not rate how each downstream column comes from the traced one (needs a release newer than 0.12.10), so no description can be offered to copy')
lines.push('◆ docs · this altimate-code does not rate how each downstream column comes from the traced one (needs altimate-code 0.12.11 or newer), so no description can be offered to copy')

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor (Codex; wording): this message still names a version and not the install command.

The PR says the docs messages give the install command in place of "newer than 0.12.10". The second message (:497) does. This one says needs altimate-code 0.12.11 or newer. Suggest ending it with npm i -g @altimateai/altimate-code, like the rest.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. The message now ends with the install command: "…so no description can be offered to copy: npm i -g @altimateai/altimate-code" (hooks/features/docs.tsx). The test was updated.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. The message now ends with the install command: "…so no description can be offered to copy: npm i -g @altimateai/altimate-code" (docs.tsx:465).

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53: the message now ends with npm i -g @altimateai/altimate-code.

throw lastError ?? new Error('altimate CLI not found')
}

const SEMVER = /(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor (Claude, Codex accepts; edge: an unusual wrapper): parseVersion takes the first x.y.z anywhere in stdout and stderr.

Suppose a wrapper script prints Using node v22.1.0 before 0.12.9. The version is then read as 22.1.0, so an old CLI is missed. It fails quiet, with no false nag. Reading the last line, or the last match, would be safer.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. parseVersion takes the last version printed, so Using node v22.1.0 followed by 0.12.9 reads 0.12.9. Unit test added.

@hkaltai hkaltai Nov 19, 2026 •

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed. parseVersion takes the last version printed (f237e53). As of b216dd2, stdout is read first and stderr only as a fallback (altimate-cli.ts:86), so a runtime note on either stream doesn't hide the CLI's version. Tests cover Using node v22.1.0⏎0.12.9, stdout 0.12.8 with stderr Using node v22.1.0, and a version printed only on stderr.

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53 (last match) and b216dd2 (stdout first, stderr as a fallback). The round-1 case now reads 0.12.8 and nags. Reverting each part fails its own test. A new edge: a version printed after the CLI's own, such as altimate-code 0.12.8 (built with bun 1.2.3), reads as 1.2.3. No real CLI prints that, so it's a minor inside the approval.

if (!MISSING_BINARY.test(String(error))) return null
continue
}
const version = answer.exitCode === 0 ? parseVersion(`${answer.stdout ?? ''}\n${answer.stderr ?? ''}`) : null

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor (Claude, Codex accepts; edge PATH setup): a failing altimate --version stops the search, and MCP uses the other name.

A non-zero exit from altimate returns null without trying altimate-code. MCP mode also launches altimate-code mcp serve (.mcp.json). So when the two names on PATH are different installs, the version checked may not be the one MCP calls. That's rare: npm installs both names together.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Declined on purpose (comment at altimateCodeNotice, hooks/altimate-cli.ts). The notice checks the binary runAltimate actually runs: the first name that starts. An altimate that starts and fails is still the one the plugin's calls use, so reporting altimate-code's version instead would describe a binary that isn't used. MCP mode starting altimate-code is covered by the README's MCP note. npm installs both names together.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This stays as it is on purpose, and the reason is now written in the docstring (altimate-cli.ts:73). The check names the binary runAltimate actually runs, which is the first name that starts. runAltimate doesn't fall through to altimate-code when altimate starts and fails, so checking altimate-code in that case would report a binary the plugin never uses. A missing altimate still falls through, and a test covers that. Different installs under the two names is rare, as you noted, since npm installs both together.

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Accepted as declined. The notice describes the binary runAltimate actually runs, the first name that starts, and the docstring now says so. It's an unusual PATH setup, so this doesn't block.


/** The order the parts are drawn in. */
export const STATUS_ORDER: readonly StatusPartId[] = ['integrations', ...FEATURE_IDS]
export const STATUS_ORDER: readonly StatusPartId[] = ['integrations', 'altimateCode', ...FEATURE_IDS]

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor (Claude, Codex accepts; cosmetic): the notice is about 110 characters and comes before every feature part.

Example: altimate 0.12.9 found at /path/altimate; this plugin needs ≥ 0.12.11: npm i -g @altimateai/altimate-code. On a terminal of about 120 columns it pushes the health and cost parts off the line. It only shows with an old or missing CLI. A shorter form, such as altimate 0.12.9 < 0.12.11 · npm i -g @altimateai/altimate-code, or putting it last, would avoid that.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. The notice moved to the end of STATUS_ORDER (hooks/status-line.ts), after every feature part, so on a narrow terminal it's the part that gets cut. The wording stays because it names the version, the binary path and the install command, which the launch issue asked for. Test: "the version notice comes after every other part, so it never hides them".

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. The version notice is now the last part of the status line (STATUS_ORDER, status-line.ts:13), so it never pushes the health or cost parts off. There's a test in integrations.test.tsx. I kept the text as it is because it names the binary, the path and the install command.

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53: the notice is last in STATUS_ORDER. With it reverted, "the version notice comes after every other part" fails.

"type": "boolean",
"title": "Project health blocks git push",
"description": "On refuses a git push while the project health check finds new issues in the models you changed this session; off only shows them.",
"description": "On refuses a git push while the project health check finds new issues in the models you changed this session; off only shows them. Optional; default: off.",

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor (Claude, Codex accepts; wording, carried from the health PR's review): the healthBlocksPush text still leaves out the other holds.

A push is also held when the check can't run or doesn't finish. Since this PR, that includes "altimate-code not on PATH" and "no dbt_health tool", because NO_CLI and NEEDS_CLI become state.problem, and the gate holds with "could not run (…)". The gate itself is unchanged and fails closed, as approved before. README :163 has the same gap. Suggest adding "…and while the check cannot run or has not finished".

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. Both plugin.json and the README table now say the push is also held "while the check cannot run (altimate-code missing, or without dbt_health) or has not finished".

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. plugin.json and README now say: "On refuses a git push while the project health check finds new issues in the models you changed this session, and while the check cannot run or has not finished; off only shows them."

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in f237e53. plugin.json and the README now name the holds while the check can't run or hasn't finished. That matches decide() in health.tsx, and the gate code is unchanged.

@sahrizvi

Copy link
Copy Markdown
Collaborator

Consensus review (Claude + Codex) of 55e9b1c: details.

Scope: git diff 5d8fb0463f..55e9b1c9de, 4 commits: b3a01f3 (parts A–G), aeed9d5 (review round 1), 0754bcd (review round 2), 55e9b1c (test types and unread count). I also ran the suites on this head merged with current main (e014863, which includes #37); the merge has no conflicts.

Engine: the npm @altimateai/altimate-code@0.12.11 CLI, and altimate-code main built locally (it prints 0.0.0--202611190701). Both ran with an isolated HOME on a dbt-duckdb 1.12.7 project: stg_orders(order_id, amount, status, note), read by order_totals, order_report, order_status and a select * model. Manifests came from dbt parse, from a full dbt compile, and from dbt compile -s stg_orders order_totals (a mix). The recorded impact_analysis answers went through main's and this head's band code. The two engines gave the same text in every row.

B: band text per real engine answer

Answer shape (real CLI) main shows head shows Correct
parse-only, amount (counts 0/0, unresolved 4 × no compiled SQL) reaches 0 columns in 0 models · 4 more may change not traced: 4 downstream models have no compiled SQL (run dbt compile) head
compiled, amount (3 columns in 3 models) reaches 3 columns in 3 models same both
compiled, real zero (note, no select * model; unresolved empty, may_carry 3) reaches 0 · 3 more may change same both
mixed, amount (1 compiled reader reached, 3 unread) reaches 1 column in 1 model · lower bound 3 same both
mixed, status (0 reached, 3 unread) reaches 0 columns in 0 models not traced: 3 … no compiled SQL head
compiled, absent column (column_answer_error) could not be traced same both
parse-only, absent column (only itself at hop 0, 4 unresolved) reaches 0 columns in 0 models not traced: 4 … no compiled SQL head
column added in the task (model-level answer) no column answer: update altimate-code new in this task: its reach is unknown, not zero head
rename amount as amt → as total — amt traced by name, total treated as added head
select * → explicit list, column exists real reach new in this task: unknown main (major, inline)
counts missing or null — falls back to the column list and unresolved (Codex probe) head
per-edit note with show_edit_impact on, parse-only (debug log only) transcript: reaches 0 columns in 0 models, 4 may carry it neither (major, inline)

C: version strings through altimateCodeNotice

These ran through the plugin's function with fake binaries on PATH, plus the real npm and local builds.

--version prints Read as Result Right?
0.12.11 / altimate-code 0.12.11 / v0.12.11 / 0.12.11 (abc123) 0.12.11 quiet yes
0.12.9, 0.12.10 same nag with path and install command yes
0.13.0-beta.1 same quiet yes
0.12.11-beta.1 same nag yes (semver)
0.0.0--202611190701 (real local build), 0.0.0-main-…, 0.0.0-dev same nag no (major)
Using node v22.1.0 then 0.12.9 22.1.0 quiet no (minor, edge)
empty, 0.12, unrelated text null quiet yes
exits 0 with no output null quiet yes
reads stdin (read x) stdin is EOF; 0.12.9 nag yes, no hang
hangs host timeout (10 s) quiet; the check runs in later(), so session start isn't held yes
no binary on PATH — "altimate-code is not installed …" yes
real npm 0.12.11 0.12.11 quiet yes

The check runs once per session start, only when isInteractive. A /clear starts a new session and runs it again; that's fine, because clearStatusParts clears the part first. A shell alias or function is invisible to it, which matches runAltimate.

E: settings

Setting Description (plugin.json) Default stated Default in code Used by
dbt_mods dbt helpers on/off on on (!== false) dbt-mods.tsx:1756
maxScanBytes BigQuery hold limit; 0 never holds 10737418240 10 * 1024 ** 3; <= 0 never holds cost.tsx:21, :103, :201
healthBlocksPush refuse push on new issues off off (=== true || 'true') health.tsx:705 (text leaves out the other holds, minor)
healthConfigPath DataPilot config path empty empty → default checks health.tsx:476, :481
commentsPollSeconds poll interval, 30 to 86400 900 900, clamped to 30–86400 comments.tsx:24, :86
commentsInContext comments to Claude's context on on (!== false) comments.tsx:89
show_edit_impact per-edit note in the transcript off off (=== true || 'true') lineage.tsx:1144, :1275

Every description ends with "Optional; default: …". The README table matches.

Suites (run one after the other)

Check base 5d8fb04 head 55e9b1c head + main
claude plugin validate plugins/altimate-code pass pass pass
claude plugin validate --strict . pass pass pass
claude plugin validate --strict plugins/altimate-code fail (ICON_MISSING, see nits) same same
claude plugin test plugins/altimate-code 1097 pass, 11 fail 1122 pass, 11 fail (the same 11) 1153 pass, 0 fail
tests/*.sh (8) all pass all pass all pass
pytest tests/ 65 pass 65 pass 65 pass

CONTRIBUTING.md names no tsc step. tsconfig.json extends a types folder that the engine writes, so there was nothing to run. The head's 11 failures are the cost/runs overlap and push-gate-stall tests, and #37 fixes them.

Mutation checks (PR suite; baseline 11 fail)

Mutant Result
unknownReach always returns null caught (+3)
zero guard (unread === 0) dropped caught (+3)
hop-0 gate dropped caught (+1)
added column asked by name caught (+1)
>= 0 → > 0 (a current CLI nags) caught (+1)
prerelease ordering flattened caught (+1)
isInteractive guard dropped caught (+2)

A: checked. At head, nothing says "newer than 0.12.10". Both docs call sites changed, and health's NEEDS_CLI changed. tell() drops NEEDS_CLI and NO_CLI, so a missing CLI or tool no longer toasts at session start or at a turn. /health still shows the problem. With healthBlocksPush on and no CLI or tool, a push after a model change is still held ("could not run (…)"), and one with no changes runs. That's #33's approved fail-closed behaviour; the gate code is untouched.

D: checked. The line appears when a follow's ui.open comes back unplaced with a "columns" reason. It hides while viewport.columns is at or above the floor. It clears when the pane opens, on /lineage, and at session start or end. It doesn't fire for a reason without "columns". Codex first raised the line coming back when the terminal narrows again; it then agreed with me that this is the tested design, so it isn't a finding.

F and G: checked. Tests without a column (singular tests, multi-column tests) aren't counted on any column. The subgraph keeps testColumn/testOn and the tests' parents. With show_edit_impact off, the only change is a skipped $.ui.log, so the transcript is the same as on main.

Version: plugin.json and marketplace.json are both at 1.8.1. The CHANGELOG entry covers A–G, and the docs give one install method.

Earlier reviews' open items:

Nits:

  • The CHANGELOG has no entry that introduces /health or team comments, yet the 1.8.1 entry refers to both. Release bookkeeping, carried over.
  • claude plugin validate --strict plugins/altimate-code exits 1 on base and head alike, with Claude Code 2.1.328's new ICON_MISSING directory warning. --strict . passes, as the PR says. Not from this PR.

Live check: claude --plugin-dir in a 200-column tmux session with an isolated HOME and config folder stopped at the login-method screen, so no turns ran. The kit runs with real CLI output and real --version binaries stand in for it.

hkaltai and others added 3 commits November 19, 2026 13:04
…etraced on every open; mixed unread reasons count every unread model

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…read, preview builds not nagged, last version read, notice last on the status line, quoted test columns, health keeps a refused spawn's words, settings and docs wording

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@hkaltai

hkaltai commented Nov 19, 2026

Copy link
Copy Markdown
Contributor Author

review-loop: APPROVED at f237e53 (reviewers: claude, codex gpt-6.1-sol)

The head a7c7b3f is that commit merged with main, which now has #37. Its tree is the same as the conflict-free merge of this branch and fix/cost-runs-together, which passes claude plugin test plugins/altimate-code with 1167 pass and 0 fail.

@hkaltai

hkaltai commented Nov 19, 2026

Copy link
Copy Markdown
Contributor Author

Reply to the consensus review of 55e9b1c and to Kilo's summary: I've replied in each inline thread with the fixing SHA or a file:line reason. All three Majors are fixed in a45d913, 8498e57 and f237e53, each with a regression test that fails before its fix:

  • an existing column was called new
  • a preview build got the upgrade nag
  • show_edit_impact could show a false zero

Of the Minors, all are fixed except two, which I declined with reasons in their threads:

  • when altimate --version fails, the check doesn't fall through to altimate-code (it matches runAltimate)
  • manifests from before dbt 1.5 don't count multi-parent tests in the per-column count

The head is a7c7b3f, which is f237e53 merged with main (#37). The PR body lists the full set.

@hkaltai
hkaltai requested a review from sahrizvi November 19, 2026 08:15
// read only in part, make it unknown: counted from the engine's counts, its unread list or its may-carry reasons,
// whichever names more.
const partly = Array.isArray(answer.may_carry) ? answer.may_carry.filter(one => PARTLY_READ.has(String((one as any)?.reason ?? ''))).length : 0
const unread = Math.max(r.unresolved, answer.unresolved?.length ?? 0, partly)

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

WARNING: Partly read models make a column's reach unknown here, but the summary's lower bound and its success line still count only answer.unresolved

previously (the previous round) added the partial-read may-carry reasons to this count, so unknownReach can now return "not traced: N downstream models could not be read" for an answer whose unresolved list is empty and whose only unread readers are may_carry with read_in_part, read_columns_unknown, unclear_sql or capped (counts columns: 0, models: 0).

summaryOf still fills view.unresolved only from one.down.unresolved (impact-report.ts:264), and summaryLines prints ✓ Every downstream model was read whenever view.unresolved === 0 && !view.truncated and some other column has a reach (:294-299). So in a task that changes two columns — one whose only unread reader was read in part, one with a real reach — the band shows:

  amount  not traced: 1 downstream model could not be read
  total   reaches 3 columns in 2 models (…) · 0 more may change
✓ Every downstream model was read

The footer asserts the opposite of the line above it. Count the partial-read may-carry models into view.unresolved (as this function now does), or suppress the ✓ line when any column carries an unknown/note.

(Note: the word previously at the start is a typo in my own wording; it should read "This change".)

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in 3f40e70. When a column's reach is unknown, summaryOf (hooks/impact-report.ts) now counts its partly-read may-carry models (read_in_part, read_columns_unknown, unclear_sql, capped) in view.unresolved. The footer then says "⚠ Lower bound: 1 model could not be read" and never "✓ Every downstream model was read". Test: "a reach left unknown by a model read only in part keeps the footer a lower bound, never "every downstream model was read"".

;(one ? traced : unchecked).push(touched[i]!)
if (one) answered.push({ column: touched[i]!, answer: one })
const reached = !!one && one.columns.some(col => col.hop === 0)
;(reached ? traced : unchecked).push(touched[i]!)

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

SUGGESTION: A column whose answer never reached it is now told to be "over the limit or no answer in time"

A no-hop-0 answer is pushed into unchecked, which also holds the columns skipped by MAX_EDIT_COLUMNS and the ones that timed out (:918). The note Claude gets renders that list as columns not checked (over the limit or no answer in time) (:1014). For the common "column added in this edit, so the manifest has no trace of it" case, the answer did arrive and nothing timed out, so the stated reason is wrong and suggests a retry would help. Consider a separate reason for this list (e.g. "no trace in the manifest") rather than folding it into the timeout bucket.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Addressed in b216dd2. The note Claude gets now gives all three reasons for that list: "columns not checked (over the limit, no answer in time, or not in the manifest: dbt compile adds a new one)" (hooks/lineage.tsx, impactFirst). The comment on unchecked names the never-reached case too.

result = await runTool($, 'dbt_health', toolArgs(options.healthConfigPath), { write: true, until })
} catch (error) {
// Only a binary that is not there: one that is there and refused to start keeps its own words.
if (/ENOENT|not found|no such file/i.test(String(error))) return { problem: NO_CLI }

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

SUGGESTION: The not-found pattern is now duplicated instead of narrowed in one place

The first three alternatives here are a copy of MISSING_BINARY (altimate-cli.ts:16), which also carries (cannot|could not|failed to) (start|spawn|run). The two patterns now encode "the binary is not there" separately, so a change to one (a new platform's not-found wording, say) will not reach the other. Consider exporting a narrow NOT_FOUND from altimate-cli.ts and building MISSING_BINARY from it (new RegExp(${NOT_FOUND.source}|...)), so this check and runAltimate's retry decision share one definition.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in 3f40e70. hooks/altimate-cli.ts exports NOT_FOUND, MISSING_BINARY is built from it, and the health check uses NOT_FOUND (hooks/features/health.tsx check). The not-found wording now lives in one place.

…t note names a column missing from the manifest, comment wrap

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@hkaltai

hkaltai commented Nov 19, 2026

Copy link
Copy Markdown
Contributor Author

@sahrizvi thanks for the consensus review. All three majors and the six minors from review 5970928509 are fixed at head b216dd2, and each inline comment has a reply.

Majors

  • select * columns treated as new: every column is now asked by name, and one is called new only when the manifest lacks it too.
  • 0.0.0-* preview builds nagged: they now count as preview builds and get no notice.
  • show_edit_impact false zero: the per-edit note goes through unknownReach.

Minors: test columns matched ignoring case and quotes; the docs message gives the install command; the version is read from stdout's last match, with stderr as a fallback; the notice comes last on the status line; the healthBlocksPush text names the holds.

Kept as is, with the reason: the version check names the binary runAltimate actually runs. The docstring now says this.

Checks: this branch, with current main (which includes #37) merged in, passes claude plugin test: 1169 pass, 0 fail. validate --strict . and tests/*.sh pass. A fresh claude -p + codex exec panel on f237e53 found no blockers, and its three minors are fixed in b216dd2. The other edge cases from that panel, plus a pre-existing MISSING_BINARY duplication, are listed under Follow-ups in the PR description.

@hkaltai

hkaltai commented Nov 19, 2026

Copy link
Copy Markdown
Contributor Author

review-loop: APPROVED at b216dd2 (reviewers: claude, codex gpt-6.1-sol)

Fresh reviewers looked at the whole PR diff against origin/main (merge base e014863, which includes #37) and found no CRITICAL or MAJOR issues. claude plugin test plugins/altimate-code at this head gives 1169 pass and 0 fail. One NIT is left as is: the binary-name notes in commands/review.md:22, commands/altimate.md:16 and skills/review/SKILL.md:15 only say which command names each install puts on PATH. Every install instruction is npm i -g @altimateai/altimate-code.

…oter a lower bound; one not-found pattern shared by the CLI fallback and the health check

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@hkaltai

hkaltai commented Nov 19, 2026

Copy link
Copy Markdown
Contributor Author

review-loop: APPROVED at 3f40e70 (reviewers: claude, codex gpt-6.1-sol)

Fresh reviewers looked at the whole PR diff against origin/main (merge base e014863, which includes #37) and found no CRITICAL or MAJOR issues. This head also fixes Kilo's three threads on a7c7b3f, with a regression test for the band footer. claude plugin test plugins/altimate-code gives 1171 pass and 0 fail, and claude plugin validate --strict . passes.

@sahrizvi sahrizvi left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Round 2 re-review of 3f40e70: APPROVE. Panel: Claude (lead) and Codex (codex exec, read-only, default model). Codex's independent pass and its cross-check of the lead's findings both finished.

All three round-1 majors are fixed. I checked each one in the code, by reverting the fix to see its new test fail, and with the real CLI (npm 0.12.11 and a local build of altimate-code main) on a small dbt-duckdb project after dbt parse and after dbt compile:

  • M1: a select * or dbt_utils.star rewrite and an unaliased cast now show their real reach. Round 1's head called them "new in this task".
  • M2: no 0.0.0-* preview build nags.
  • M3: the per-edit note no longer gives a false 0 on a parse-only manifest.

Five of the six round-1 minors are fixed. The sixth, m4, was declined with a reason I accept. The push gate's code is unchanged, and the asks per task are the same as on main (at most 3 columns per model and 5 models, 4 at a time). The full results are in the combined comment.

Five minors remain, each inline. None blocks:

  1. An engine exception is read as "column not in the manifest". Edge input: it needs a column-answer exception during a select * rewrite.
  2. A "not in the manifest" result is cached against a live manifest. Edge: it needs the task's manifest copy to be missing.
  3. A positive reach next to a partly read reader keeps "✓ Every downstream model was read". Wording, and main does the same.
  4. Last-match version parsing reads a version that comes after the CLI's own. Edge: no real CLI output looks like that.
  5. A real 0 becomes "not traced" when a downstream model names no column, such as select count(*). Edge, safe, and dates from round 1; an engine-side follow-up fits.

const answer = answerOf(meta)
// An answer that never reached the column (no hop 0) traced nothing: it could not be traced.
const down = answer && answer.columns.some(one => one.hop === 0) ? answer : null
const lacks = typeof (meta as any)?.column_answer_error === 'string' || (!!answer && !down)

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor (Codex; edge input): any column_answer_error is read as "the manifest lacks the column".

The engine puts every exception from the column answer into column_answer_error (altimate-code impact-analysis.ts, the catch around columnAnswer). Here is a failure case: a select * is rewritten into explicit columns (before: null), and the engine throws, for example RangeError: Maximum call stack size exceeded. Then lacks is true and unchecked is true. The band says "not in the manifest from before the task (new in it?)" for a column the manifest has. traceFull also skips its upstream trace, and allRead caches the result.

The reach is still shown as unknown and never as 0, so this does not block. A fix: treat only the engine's own absence message (… has no column X; its columns are …) as "lacks", and any other error as failed, which main reads as "could not be traced".

const traces = await (done.full ??= traceFull($, done))
const allRead = traces.every(one => !one.column || (one.down && one.up))
// A column added in the task has no trace to ask again for: it is read as far as it can be.
const allRead = traces.every(one => !one.column || one.unchecked || (one.down && one.up))

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor (Codex; edge): an unchecked column is now cached even when the answer came from the live target/manifest.json.

When the task's manifest copy was never made or has gone, manifestOf falls back to target/manifest.json. Here is a failure case: the person opens the report while the added column is missing from that manifest, runs dbt compile, and opens the report again. The second open asks the CLI nothing and still says the column is not in the manifest. Columns that were traced in both directions were already cached that way, so this only matters when no copy exists.

A fix: count one.unchecked as read only when Object.values(done.manifests).every(Boolean).

const reach = one.down && !one.unknown ? 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))
// A reach left unknown by models read only in part: those count as unread too, so the footer never says all were read.
if (one.unknown) for (const entry of Array.isArray(one.down?.may_carry) ? one.down!.may_carry : []) if (PARTLY_READ.has(String((entry as any)?.reason ?? ''))) unresolved.add(String((entry as any)?.id ?? (entry as any)?.name))

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor (Codex; wording; main does the same for a positive reach): the partly read readers reach the footer only when the reach is unknown.

Here is a failure case: an answer has one reached column, and another reader with may-carry reason unclear_sql (or capped), with unresolved: []. The engine lists unclear_sql only in may_carry, never in unresolved. The band and the report then say "✓ Every downstream model was read". Yet the same reader would make a zero reach "not traced". The count itself is right, and the reader is still counted under "may change".

A fix: add the PARTLY_READ may-carry entries to unresolved whatever the reach. Nit on the same line: an entry with neither id nor name adds the string "undefined". Two such entries then count as 1 in the footer. The engine always sends an id.

/** The version a `--version` output names ("0.12.11", "altimate-code 0.12.11", "v0.13.0-beta.2"), or null; the last one when it names several. Read stdout first: stderr carries runtime notes. */
export function parseVersion(text: string): string | null {
// The last one printed: a wrapper may name its own runtime (node v22.1.0) before the CLI's version.
const found = [...text.matchAll(new RegExp(SEMVER.source, 'g'))].pop()

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor (Codex; edge: an output format no real CLI prints): the last match can be a version that comes after the CLI's own.

Here is a failure case: altimate-code 0.12.8 (built with bun 1.2.3) parses as 1.2.3, so the upgrade notice stays quiet. Round 1's head read 0.12.8 there. The real binaries print a bare version: npm 0.12.9, npm 0.12.11 and the local 0.0.0--… build all read correctly at this head. The stdout and stderr cases from round 1 are right too.

A fix: prefer a version on a line of its own, or one after altimate/altimate-code, and fall back to the last match.

// read only in part, make it unknown: counted from the engine's counts, its unread list or its may-carry reasons,
// whichever names more.
const partly = Array.isArray(answer.may_carry) ? answer.may_carry.filter(one => PARTLY_READ.has(String((one as any)?.reason ?? ''))).length : 0
const unread = Math.max(r.unresolved, answer.unresolved?.length ?? 0, partly)

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor (Claude, Codex accepts; edge; dates from round 1's head; engine-side): a real zero becomes "not traced" when a downstream model names no column of the edited model.

Here is a real CLI answer, from npm 0.12.11 and the local main build, on a compiled dbt-duckdb project. One reader is select count(*) as n from {{ ref('stg_payments') }}, and nothing reads stg_payments.note. The engine lists cnt in unresolved as "reads 1 table but the engine traced no column (select * over columns it can't see?)". So the band and the per-edit note say note not traced: 1 downstream model could not be read (…). Main said "reaches 0 columns in 0 models · 5 more may change". Without the count(*) model, head keeps the real "reaches 0 · 4 more may change".

This errs on the safe side: it never shows a false 0, and it hides no reach. It is the engine's call that such a model is unread. A follow-up: have altimate-code treat a model it parsed that reads no column by name as read in full.

@sahrizvi

Copy link
Copy Markdown
Collaborator

Round 2 re-review of 3f40e70 (Claude + Codex): findings not tied to a diff line, the nits, and what I ran. The approval and the five inline minors are in the formal review.

What changed since round 1

I read the whole diff from 55e9b1c to 3f40e70. Leaving out main's files, the PR's own change is 20 files, +264/−64. The merge a7c7b3f brings main's #37 and nothing else: its diff against its first parent equals 5d8fb04..e014863 apart from index lines and hunk offsets. That covers cost.tsx, cost.test.tsx, runs.test.tsx, defer.test.ts and one line of tool-chain.test.ts. git merge-base with current main is e014863, so this head already is the merge with main.

Each round-1 item

"Reverted" means I undid the fix by hand and ran the suite again; the named new test failed each time.

Round-1 item Fixed in How I checked it State
M1 existing column called "new in this task" f237e53 Reverted: "a select * spelled out … traced by name" fails. Real CLI: select * and dbt_utils.star rewrites and an unaliased Postgres cast show their real reach (table below) fixed
M2 preview build nagged f237e53 Reverted: 2 tests fail. 0.0.0--…, 0.0.0-main-…, 0.0.0-dev and the real local build are all quiet fixed
M3 per-edit false 0 with show_edit_impact a45d913, 8498e57 Reverting unknownReach fails 1 test, and reverting the hop-0 gate fails another. Real parse-only answers give "not traced: 5 downstream models have no compiled SQL" fixed
m1 test column case and quotes f5565b0, f237e53 Reverted bareName: the case test fails fixed
m2 docs message without the install command f237e53 The text now ends with npm i -g @altimateai/altimate-code fixed
m3 first x.y.z read f237e53, b216dd2 Last match reverted: 1 test fails. Round-1 stdout-then-stderr order restored: the stderr-note test fails fixed (new edge in the inline comment)
m4 no fall-through after a failing --version — Declined accepted: the notice describes the binary runAltimate runs, the first name that starts. It's an unusual PATH setup
m5 notice second on the status line f237e53 Reverted: "comes after every other part" fails fixed
m6 healthBlocksPush text f237e53 The text now matches decide() in health.tsx: held while a changed model's check can't run or hasn't finished fixed

Other fixes I reverted, each failing its own test: the partly-read count (partly), the partly-read footer, missing >= unread, NOT_FOUND in health, and the report's allRead. The other declined item, pre-dbt-1.5 manifests without attached_node not counting multi-parent tests, is reasonable. It is an edge case: an old manifest gives a lower test count, never a crash. The PR body lists it under its limits.

Band per real engine answer

This uses a dbt-duckdb project (seed → stg_payments → 6 readers, including a select * and a count(*)). For the cast row it uses a dbt-postgres project. Each real CLI answer was played back through the actual task-impact hooks at each version, with the plugin's own test harness. Both npm 0.12.11 and a local build of altimate-code main gave the same text for every row.

Change (manifest) main round-1 head this head
edit amount (compiled) 4 columns in 4 models same same
edit amount (parse-only) 0 columns in 0 models not traced: 5 … no compiled SQL same as round 1
select * spelled out (compiled) real reach (id 3, amount 4, status 1) new in this task: unknown real reach, as main
select * spelled out (parse-only) 0 new in this task not traced: 5 … no compiled SQL
dbt_utils.star spelled out (compiled) real reach (4, 4, 2) new in this task real reach
unaliased amount::int given its name (Postgres, compiled) 2 columns in 2 models new in this task 2 columns in 2 models
column added (compiled) could not be traced new in this task not in the manifest from before the task (new in it?): unknown
column added (parse-only) 0 new in this task not traced: 5 … no compiled SQL
rename memo → remark (compiled) memo 2/2; remark could not be traced memo 2/2; remark new memo 2/2; remark not in the manifest
real zero, note (compiled, every reader read) 0 · 4 may change same same
real zero, plus a count(*) reader 0 · 5 may change not traced: 1 … could not be read same as round 1 (inline minor)
read_in_part reader (Snowflake ::variant: filter), note 0 0 · 5 may change not traced: 1 … read in part
read_in_part reader, customer_id (real reach) 1 column in 1 model same same

For each row, the per-edit note at this head (what show_edit_impact shows) says the same as the band. Columns the manifest lacks are listed as unchecked. Where the per-edit note and the band agree is computed with the plugin's own answerOf, reachOf and unknownReach.

Engine calls

Each changed column gets one call, as on main. Round 1's head made the same call without the column. changedColumns keeps 3 columns per model (MAX_TASK_COLUMNS) and the task keeps 5 models, run 4 at a time. So a 10-column select * expansion makes 3 calls, the same as on main, and the per-call timeouts are main's.

Version check (altimateCodeNotice, real processes)

--version prints round-1 head this head
0.0.0--202611190701, 0.0.0-main-202611191200, 0.0.0-dev, real local build 0.0.0--202611190944 nag quiet
real npm 0.12.11, 0.12.11 on stderr only, 0.13.0-beta.1 quiet quiet
real npm 0.12.9, 0.12.9, 0.12.8 on stderr only nag nag
stdout 0.12.8, stderr Using node v22.1.0 nag nag
Using node v22.1.0 then 0.12.8, both on stdout quiet nag
altimate-code 0.12.8 (built with bun 1.2.3) nag quiet (inline minor)
exits 3, or prints nothing quiet quiet
none on PATH "not installed …" same

Suites (one after the other)

Check main e014863 this head
claude plugin validate plugins/altimate-code pass pass
claude plugin validate --strict . pass pass
claude plugin test plugins/altimate-code 1128 pass, 0 fail 1171 pass, 0 fail (a second run: 1169/2, both known flakes, see the nits)
tests/*.sh (8) all pass all pass
pytest tests/ 65 pass 65 pass

CONTRIBUTING.md names no type-check step.

Nits

  • runs.test.tsx "a dbt call that starts while another call reads its artifact …" is flaky. It fails about one run in two even with only cost.test.tsx and runs.test.tsx loaded, on main and on this head. Its file is the same as main's (from test: cost and runs tests pass with both features on #37), and it waits on fixed 20 ms sleeps. "a line with a great many dbt calls" timed out once under load. Neither comes from this PR.
  • The CHANGELOG still has no entry that introduces /health or team comments (carried from round 1).
  • claude plugin validate --strict plugins/altimate-code fails with ICON_MISSING on main and on this head. Not from this PR.
  • The author's reply says the PR description lists follow-ups, but the body has only "Notes and limits", with no follow-ups list.

@hkaltai
hkaltai merged commit d932a0f into main Nov 19, 2026
4 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants