diff --git a/app/src/api/billFeed.ts b/app/src/api/billFeed.ts
index 39db3083e..cf82fe144 100644
--- a/app/src/api/billFeed.ts
+++ b/app/src/api/billFeed.ts
@@ -189,6 +189,13 @@ function totalRows(response: Response): number | undefined {
 async function trackerSelect(
   table: string,
   select: string,
+  /**
+   * A unique column that puts the rows in one fixed order ("bill_id").
+   * With no order, the database can give each page its rows in another
+   * order, so the pages repeat some rows and drop others, and different
+   * ones on each load.
+   */
+  order: string,
   /** A PostgREST row filter, e.g. "id=eq.ks-hb2620". */
   filter?: string
 ): Promise<any[] | null> {
@@ -199,7 +206,7 @@ async function trackerSelect(
   // Read page by page: one request stops at the cap and drops the rest.
   const rows: any[] = [];
   for (;;) {
-    const query = `select=${select}${filter ? `&${filter}` : ''}&limit=${TRACKER_PAGE_SIZE}&offset=${rows.length}`;
+    const query = `select=${select}${filter ? `&${filter}` : ''}&order=${order}&limit=${TRACKER_PAGE_SIZE}&offset=${rows.length}`;
     const response = await fetch(`${config.url}/rest/v1/${table}?${query}`, {
       headers: {
         apikey: config.anonKey,
@@ -500,6 +507,7 @@ export async function fetchTrackerBillDistricts(
   const rows = await trackerSelect(
     'reform_impacts',
     'district_impacts',
+    'id',
     `id=eq.${encodeURIComponent(billId)}`
   );
   const raw = rows?.[0]?.district_impacts;
@@ -560,11 +568,74 @@ function normalizeBillNumber(value: string): string {
 const processedBillKey = (state: string, billNumber: string) =>
   `${state.toUpperCase()}:${normalizeBillNumber(billNumber)}`;
 
+/** A status row's last action day ("2026-03-04"), or "" when it has none. */
+const lastActionDay = (bill: any): string => {
+  const day = typeof bill.last_action_date === 'string' ? bill.last_action_date.slice(0, 10) : '';
+  return /^\d{4}-\d{2}-\d{2}$/.test(day) ? day : '';
+};
+
+/**
+ * Whether a status row came from LegiScan, read from its link: the
+ * OpenStates and Congress monitors store their own sites' links in the
+ * same column, and the row's source column defaults to "legiscan".
+ */
+const isLegiscanRow = (bill: any): boolean =>
+  /^https?:\/\/(www\.)?legiscan\.com\//i.test(String(bill.legiscan_url ?? ''));
+
+/** A status row's bill id as a number, lowest when it has none. */
+const statusRowId = (bill: any): number => {
+  const id = Number(bill.bill_id ?? NaN);
+  return Number.isFinite(id) ? id : -Infinity;
+};
+
+const statusRowText = (bill: any) =>
+  JSON.stringify([
+    bill.bill_id,
+    bill.state,
+    bill.bill_number,
+    bill.status,
+    bill.legiscan_url,
+    bill.last_action_date,
+  ]);
+
+const ascending = (a: number | string, b: number | string) => (a < b ? -1 : a > b ? 1 : 0);
+
+/**
+ * Orders two status rows for one bill number, the preferred row last.
+ * The tracker can hold a bill twice under two spellings of its number:
+ * LegiScan's (NY "S04487") and OpenStates' ("S 4487"). The row with the
+ * later last action wins. On the same day, or with no dates, the LegiScan
+ * row wins: it names the stage more finely ("In Committee", where
+ * OpenStates says "Introduced") and links to LegiScan. The bill id and
+ * then the row's contents only fix the order of what is left. They do
+ * not date a bill: OpenStates and Congress ids are hashes, all above
+ * LegiScan's. The same row wins in any read order.
+ */
+function compareStatusRows(a: any, b: any): number {
+  return (
+    ascending(lastActionDay(a), lastActionDay(b)) ||
+    ascending(Number(isLegiscanRow(a)), Number(isLegiscanRow(b))) ||
+    ascending(statusRowId(a), statusRowId(b)) ||
+    ascending(statusRowText(a), statusRowText(b))
+  );
+}
+
+/**
+ * The bill number a title names, as the tracker reads it: the first
+ * letters-then-number ("SB3125", "H. 3492", "A 1185"), not a fiscal year.
+ */
+function titleBillNumber(title: unknown): string | undefined {
+  return typeof title === 'string' ? title.match(/\b(?!FY)([A-Z]{1,3}\.?\s*\d+)/i)?.[1] : undefined;
+}
+
 /**
  * The tracker's status row (processed_bills) for a research entry. The
  * entry's LegiScan link (legiscan_bill_id) names the row when it is set.
  * Otherwise the entry's id names the bill: "ut-sb0060", "ny-s-4487", or
  * "ga-hb463-2026", where a trailing year names the session, not the bill.
+ * An id with words after the number ("hi-sb3125-hd1", "ut-sb60-bill")
+ * finds its row as the tracker does: by the bill number in the title,
+ * then by the id's first part.
  */
 function processedBillFor(
   record: any,
@@ -581,11 +652,24 @@ function processedBillFor(
   if (!state || parts.length === 0) {
     return undefined;
   }
-  const exact = byKey.get(processedBillKey(state, parts.join('')));
-  if (exact || parts.length < 2 || !/^\d{4}$/.test(parts[parts.length - 1])) {
-    return exact;
+  const candidates = [parts.join('')];
+  if (parts.length >= 2 && /^\d{4}$/.test(parts[parts.length - 1])) {
+    candidates.push(parts.slice(0, -1).join(''));
+  }
+  const titled = titleBillNumber(record.title);
+  if (titled) {
+    candidates.push(titled);
+  }
+  if (parts.length >= 2 && /^[a-z]+\d+$/i.test(parts[0])) {
+    candidates.push(parts[0]);
   }
-  return byKey.get(processedBillKey(state, parts.slice(0, -1).join('')));
+  for (const billNumber of candidates) {
+    const row = byKey.get(processedBillKey(state, billNumber));
+    if (row) {
+      return row;
+    }
+  }
+  return undefined;
 }
 
 /**
@@ -595,19 +679,25 @@ function processedBillFor(
 export async function fetchTrackerBills(): Promise<TrackedBill[] | null> {
   const [research, impacts, processed, validations, baselines] = await Promise.all([
     // Titled as the tracker shows them: an entry with no title reads as its bill number.
-    trackerSelect('research', '*').then((rows) => rows?.map(withTrackerTitle) ?? null),
+    trackerSelect('research', '*', 'id').then((rows) => rows?.map(withTrackerTitle) ?? null),
     trackerSelect(
       'reform_impacts',
-      'id,reform_params,provisions,computed,budgetary_impact,poverty_impact,child_poverty_impact,winners_losers,decile_impact,policyengine_us_version,dataset_name,dataset_version,computed_at'
+      'id,reform_params,provisions,computed,budgetary_impact,poverty_impact,child_poverty_impact,winners_losers,decile_impact,policyengine_us_version,dataset_name,dataset_version,computed_at',
+      'id'
+    ),
+    trackerSelect(
+      'processed_bills',
+      'bill_id,state,bill_number,status,legiscan_url,last_action_date',
+      'bill_id'
     ),
-    trackerSelect('processed_bills', 'bill_id,state,bill_number,status,legiscan_url'),
     trackerSelect(
       'validation_metadata',
-      'id,fiscal_note_source,fiscal_note_url,fiscal_note_estimate,pe_estimate,target_range_low,target_range_high,within_range,difference_from_fiscal_note_pct,discrepancy_explanation,external_analyses,verification,verified_at,validated_against'
+      'id,fiscal_note_source,fiscal_note_url,fiscal_note_estimate,pe_estimate,target_range_low,target_range_high,within_range,difference_from_fiscal_note_pct,discrepancy_explanation,external_analyses,verification,verified_at,validated_against',
+      'id'
     ),
     // The law each bill was compared with. Read on its own, so a tracker
     // without the column yet still serves the rest of the feed.
-    trackerSelect('reform_impacts', 'id,baseline_params').catch(() => null),
+    trackerSelect('reform_impacts', 'id,baseline_params', 'id').catch(() => null),
   ]);
   if (!research) {
     return null;
@@ -621,12 +711,15 @@ export async function fetchTrackerBills(): Promise<TrackedBill[] | null> {
       bill.bill_id === null || bill.bill_id === undefined ? [] : [[String(bill.bill_id), bill]]
     )
   );
-  const processedByKey = new Map(
-    (processed ?? []).map((bill) => [
-      processedBillKey(String(bill.state), String(bill.bill_number)),
-      bill,
-    ])
-  );
+  // Two rows can share a bill number's key: the preferred one holds it.
+  const processedByKey = new Map<string, any>();
+  for (const bill of processed ?? []) {
+    const key = processedBillKey(String(bill.state), String(bill.bill_number));
+    const held = processedByKey.get(key);
+    if (!held || compareStatusRows(held, bill) < 0) {
+      processedByKey.set(key, bill);
+    }
+  }
 
   return research
     .filter((record) => isBillRecord(record))
diff --git a/app/src/components/flagship/ValidationPanel.tsx b/app/src/components/flagship/ValidationPanel.tsx
index 1e24efaa9..27b7e86bd 100644
--- a/app/src/components/flagship/ValidationPanel.tsx
+++ b/app/src/components/flagship/ValidationPanel.tsx
@@ -6,6 +6,7 @@ import { colors, spacing, typography } from '@/designTokens';
 import { relevantComparisons, type ReformScope } from '@/libs/flagship/comparisonRelevance';
 import {
   claimsFromBillValidation,
+  fiscalNoteLabel,
   METRIC_LABELS,
   ModelValidationRow,
   PROGRAM_LABELS,
@@ -124,9 +125,27 @@ const VERIFICATION_COPY: Record<NonNullable<BillValidation['verification']>['ove
   unverifiable: 'Sources could not be independently re-verified',
 };
 
+/** A link to an estimate's source, under its name. */
+function ReadSource({ href }: { href: string }) {
+  return (
+    <CellNote>
+      <a
+        href={href}
+        target="_blank"
+        rel="noreferrer"
+        style={{ ...linkStyle, fontSize: typography.fontSize.xs }}
+      >
+        Read source
+      </a>
+    </CellNote>
+  );
+}
+
 /**
  * A bill's external estimates beside PolicyEngine's, in one table, with
  * the range verdict and what the pipeline noted about the comparison.
+ * A fiscal note stored without a single estimate still names and links
+ * its source: under the accepted range it sets, or in a row of its own.
  */
 export function BillExternalEstimates({
   billId,
@@ -143,6 +162,11 @@ export function BillExternalEstimates({
     typeof validation.targetRangeLow === 'number' && typeof validation.targetRangeHigh === 'number'
       ? [validation.targetRangeLow, validation.targetRangeHigh].sort((a, b) => a - b)
       : null;
+  const noteSource = validation.fiscalNoteSource?.trim();
+  // An empty stored link is no link.
+  const noteUrl = validation.fiscalNoteUrl?.trim() || undefined;
+  const noteWithoutEstimate =
+    typeof validation.fiscalNoteEstimate !== 'number' && Boolean(noteUrl || noteSource);
   return (
     <Stack style={{ gap: spacing.md }}>
       <EvidenceTable label="Estimates for this bill" columns={['Source', 'Estimate', 'Gap']}>
@@ -157,31 +181,32 @@ export function BillExternalEstimates({
             <td style={numberCellStyle}>—</td>
           </tr>
         )}
-        {claims.map((claim) => (
-          <tr key={claim.source} style={rowStyle}>
+        {claims.map((claim, index) => (
+          <tr key={`${index}-${claim.source}`} style={rowStyle}>
             <th scope="row" style={labelCellStyle}>
               <span>{claim.source}</span>
-              {claim.sourceUrl && (
-                <CellNote>
-                  <a
-                    href={claim.sourceUrl}
-                    target="_blank"
-                    rel="noreferrer"
-                    style={{ ...linkStyle, fontSize: typography.fontSize.xs }}
-                  >
-                    Read source
-                  </a>
-                </CellNote>
-              )}
+              {claim.sourceUrl && <ReadSource href={claim.sourceUrl} />}
             </th>
             <td style={numberCellStyle}>{compactMoney(claim.externalValue)}</td>
             <td style={numberCellStyle}>{gapText(peEstimate, claim.externalValue)}</td>
           </tr>
         ))}
+        {noteWithoutEstimate && !range && (
+          <tr style={rowStyle}>
+            <th scope="row" style={labelCellStyle}>
+              <span>{fiscalNoteLabel(validation)}</span>
+              {noteUrl && <ReadSource href={noteUrl} />}
+            </th>
+            <td style={numberCellStyle}>No estimate</td>
+            <td style={numberCellStyle}>—</td>
+          </tr>
+        )}
         {range && (
           <tr style={rowStyle}>
             <th scope="row" style={labelCellStyle}>
-              Accepted range
+              <span>Accepted range</span>
+              {noteWithoutEstimate && noteSource && <CellNote>{noteSource}</CellNote>}
+              {noteWithoutEstimate && noteUrl && <ReadSource href={noteUrl} />}
             </th>
             <td style={numberCellStyle}>
               {compactMoney(range[0])} to {compactMoney(range[1])}
diff --git a/app/src/components/flagship/report/ReportChanges.tsx b/app/src/components/flagship/report/ReportChanges.tsx
index 1f0d68463..45716668a 100644
--- a/app/src/components/flagship/report/ReportChanges.tsx
+++ b/app/src/components/flagship/report/ReportChanges.tsx
@@ -6,6 +6,7 @@ import ProvisionSkeleton from '@/components/flagship/ProvisionSkeleton';
 import { CURRENT_YEAR, FOREVER } from '@/constants';
 import { colors, spacing, typography } from '@/designTokens';
 import { sameParameterValue } from '@/libs/draftReform';
+import { changeNamesPath } from '@/libs/flagship/billProvisions';
 import { describeChange, reportProvisionName } from '@/libs/flagship/draftLabels';
 import type { RunReportProvision } from '@/libs/flagship/runReport';
 import { RootState } from '@/store';
@@ -83,15 +84,6 @@ function provisionDates(provision: Pick<RunReportProvision, 'intervals'>): Chang
   };
 }
 
-/** Whether a tracker parameter, which can hold "{filing_status}", names this path. */
-function namesPath(parameter: string, path: string): boolean {
-  const pattern = parameter
-    .split(/\{[^}]+\}/)
-    .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
-    .join('[^.]+');
-  return new RegExp(`^${pattern}$`).test(path);
-}
-
 const dateText = (date: string) => dayjs(date).format('MMM D, YYYY');
 const endText = (date: string) => (date === FOREVER ? 'No end date' : dateText(date));
 
@@ -138,7 +130,7 @@ export default function ReportChanges({
       : undefined;
   const changeDates = (change: BillChange): ChangeDates | undefined => {
     const named = change.parameter
-      ? provisions.filter((provision) => namesPath(change.parameter!, provision.path))
+      ? provisions.filter((provision) => changeNamesPath(change.parameter!, provision.path))
       : [];
     if (named.length > 0) {
       const dates = named.map(provisionDates);
diff --git a/app/src/components/flagship/report/StoredImpactCharts.tsx b/app/src/components/flagship/report/StoredImpactCharts.tsx
index e771851f0..c75e84f46 100644
--- a/app/src/components/flagship/report/StoredImpactCharts.tsx
+++ b/app/src/components/flagship/report/StoredImpactCharts.tsx
@@ -105,21 +105,19 @@ const storedRevenue = (budgetary: StoredBudgetary) =>
   budgetary?.stateRevenueImpact ?? budgetary?.netCost;
 
 /**
- * The tracker's annual state revenue change, as the report's own headline
- * words it: a number, not a chart, across the grid's full width.
+ * The tracker's annual revenue change, as the report's own headline words
+ * it: a number, not a chart, across the grid's full width. A state bill's
+ * figure is that state's revenue; a federal bill's is not.
  */
-function StoredBudget({ budgetary }: { budgetary: StoredBudgetary }) {
+function StoredBudget({ budgetary, state }: { budgetary: StoredBudgetary; state?: string }) {
   const value = storedRevenue(budgetary);
   if (typeof value !== 'number' || !Number.isFinite(value)) {
     return null;
   }
   const amount = formatCurrencyAbbr(Math.abs(value), 'us', { maximumFractionDigits: 1 });
-  const label =
-    value < 0
-      ? 'Annual state revenue loss'
-      : value > 0
-        ? 'Annual state revenue gain'
-        : 'Annual state revenue change';
+  const label = `Annual ${state ? 'state ' : ''}revenue ${
+    value < 0 ? 'loss' : value > 0 ? 'gain' : 'change'
+  }`;
   return (
     <section
       aria-label="Budgetary impact"
@@ -154,7 +152,14 @@ function StoredBudget({ budgetary }: { budgetary: StoredBudgetary }) {
  * a bill, in the same chart cards as a report's economic impacts. Shown
  * while the full results calculate, or instead of them when they cannot.
  */
-export default function StoredImpactCharts({ impact }: { impact: TrackedBill['impactData'] }) {
+export default function StoredImpactCharts({
+  impact,
+  state,
+}: {
+  impact: TrackedBill['impactData'];
+  /** The bill's state; absent for a federal bill. */
+  state?: TrackedBill['state'];
+}) {
   const [decileMode, setDecileMode] = useState<'average' | 'relative'>('average');
 
   const average = decileRows(impact?.decile?.average);
@@ -206,7 +211,7 @@ export default function StoredImpactCharts({ impact }: { impact: TrackedBill['im
       }}
     >
       {/* The budget leads, as it does in the full results. */}
-      <StoredBudget budgetary={impact?.budgetary} />
+      <StoredBudget budgetary={impact?.budgetary} state={state} />
 
       {(average.length > 0 || relative.length > 0) && (
         <ReportChartCard
diff --git a/app/src/libs/draftReform.ts b/app/src/libs/draftReform.ts
index 9b28df649..d12879874 100644
--- a/app/src/libs/draftReform.ts
+++ b/app/src/libs/draftReform.ts
@@ -271,18 +271,30 @@ export function clearDraftAfterRun(userReportId: string): void {
   }
 }
 
-/** A report's reform back in the draft, to edit and run again. */
+/**
+ * A report's reform back in the draft, to edit and run again — or a
+ * bill's, with the bill as its source.
+ */
 export function loadProvisionsIntoDraft(
   countryId: CountryId,
   provisions: DraftProvision[],
-  options: { label?: string; year?: number; region?: string; baselineReformId?: string | null } = {}
+  options: {
+    label?: string;
+    year?: number;
+    region?: string;
+    baselineReformId?: string | null;
+    /** Where the reform came from; hand-built when unset. */
+    source?: ReformSource;
+    sourceRef?: string;
+  } = {}
 ): void {
   writeDraft({
     countryId,
     label: options.label ?? '',
     provisions: provisions.map((provision) => ({ ...provision })),
     population: { scope: 'national', ...(options.region ? { region: options.region } : {}) },
-    source: 'manual',
+    source: options.source ?? 'manual',
+    ...(options.sourceRef ? { sourceRef: options.sourceRef } : {}),
     startedAt: Date.now(),
     ...(options.year ? { year: options.year } : {}),
     ...(options.baselineReformId ? { baselineReformId: options.baselineReformId } : {}),
diff --git a/app/src/libs/flagship/billProvisions.ts b/app/src/libs/flagship/billProvisions.ts
index 6ad2d081d..6c9469b4f 100644
--- a/app/src/libs/flagship/billProvisions.ts
+++ b/app/src/libs/flagship/billProvisions.ts
@@ -1,4 +1,4 @@
-import { intervalValueAt, type TrackedBillProvision } from '@/api/billFeed';
+import { intervalValueAt, type BillChange, type TrackedBillProvision } from '@/api/billFeed';
 import { isAlreadyCurrentLaw, lawValuesFrom } from '@/libs/flagship/billMetrics';
 import type { RunReportProvision } from '@/libs/flagship/runReport';
 import type { ParameterMetadataCollection } from '@/types/metadata/parameterMetadata';
@@ -89,3 +89,96 @@ export function billAlreadyCurrentLaw(
     })
   );
 }
+
+/** A write-up value read as one number, with the rounding its digits allow. */
+interface WriteUpNumber {
+  value: number;
+  /** How far the true value can lie from the written one: half its last digit. */
+  tolerance: number;
+  /** Whether the text has its own sign ("+1%", "−0.25%"). */
+  signed: boolean;
+}
+
+/**
+ * A write-up value that is one plain number — "4.45%", "$2,000", "-0.5".
+ * Anything else (words, ranges, several values) reads as nothing.
+ */
+function writeUpNumber(text: string): WriteUpNumber | undefined {
+  const match = text.trim().match(/^([-−+]?)\s*\$?\s*(\d{1,3}(?:,\d{3})+|\d+)(?:\.(\d+))?\s*%?$/);
+  if (!match) {
+    return undefined;
+  }
+  const [, sign, whole, decimals = ''] = match;
+  const magnitude = Number(`${whole.replace(/,/g, '')}.${decimals || '0'}`);
+  return {
+    value: sign === '-' || sign === '−' ? -magnitude : magnitude,
+    tolerance: 0.5 * 10 ** -decimals.length,
+    signed: sign !== '',
+  };
+}
+
+/**
+ * Whether a tracker change's parameter, which can hold a placeholder
+ * ("main.{filing_status}.brackets[5].rate"), names this path.
+ */
+export function changeNamesPath(parameter: string, path: string): boolean {
+  const pattern = parameter
+    .split(/\{[^}]+\}/)
+    .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+    .join('[^.]+');
+  return new RegExp(`^${pattern}$`).test(path);
+}
+
+/** A stored value as a write-up can give it: as stored, or as a percent either way. */
+const writtenForms = (value: number) => [value, value * 100, value / 100];
+
+/**
+ * Whether a bill's run would score the law before the bill instead of the
+ * bill: the stored parameters hold the write-up's "before" value and none
+ * of its "after" value (a tracker row with its reform and baseline
+ * swapped, as UT SB60's is).
+ *
+ * A change is checked against the provisions it names, all of them
+ * together (one filing status can hold the written value), or against a
+ * bill's only provision when the write-up has one change. A change that
+ * cannot be paired, that is not two plain numbers, or whose "after" is a
+ * step ("+1%" from "4%") is not checked. A written value agrees with a
+ * stored one as written or as a percent ("4.45%" is 0.0445), within the
+ * write-up's rounding. A value in other units ("$1,000" a year for 83.33
+ * a month) agrees with neither, so it flags nothing.
+ */
+export function billScoresOtherThanWriteUp(
+  provisions: Array<Pick<TrackedBillProvision, 'path' | 'value' | 'intervals'>>,
+  changes: BillChange[] | undefined
+): boolean {
+  if (!changes || changes.length === 0) {
+    return false;
+  }
+  return changes.some((change) => {
+    const before = writeUpNumber(change.before);
+    const after = writeUpNumber(change.after);
+    if (!before || !after || (after.signed && !before.signed)) {
+      return false;
+    }
+    const described = change.parameter
+      ? provisions.filter((provision) => changeNamesPath(change.parameter!, provision.path))
+      : provisions.length === 1 && changes.length === 1
+        ? provisions
+        : [];
+    const scored = described
+      .flatMap((provision) => [
+        provision.value,
+        ...(provision.intervals ?? []).map((interval) => interval.value),
+      ])
+      .filter((value): value is number => typeof value === 'number' && Number.isFinite(value));
+    const holds = (written: WriteUpNumber) =>
+      scored.some((value) =>
+        writtenForms(value).some(
+          (form) =>
+            Math.abs(form - written.value) <=
+            written.tolerance + 1e-9 * Math.max(1, Math.abs(written.value))
+        )
+      );
+    return holds(before) && !holds(after);
+  });
+}
diff --git a/app/src/libs/flagship/modelValidation.ts b/app/src/libs/flagship/modelValidation.ts
index 9cbcbedc6..c4d827d4f 100644
--- a/app/src/libs/flagship/modelValidation.ts
+++ b/app/src/libs/flagship/modelValidation.ts
@@ -248,11 +248,17 @@ export interface ValidationClaim {
   notes?: string;
 }
 
+/** A fiscal note's label: who wrote it, as the tracker stored it, or the generic name. */
+export function fiscalNoteLabel(validation: { fiscalNoteSource?: string }): string {
+  return validation.fiscalNoteSource?.trim() || 'Official fiscal note';
+}
+
 /** Tracker validation_metadata → scorecard-shaped claims. */
 export function claimsFromBillValidation(
   billId: string,
   validation: {
     fiscalNoteEstimate?: number;
+    fiscalNoteSource?: string;
     fiscalNoteUrl?: string;
     peEstimate?: number;
     discrepancyExplanation?: string;
@@ -276,7 +282,9 @@ export function claimsFromBillValidation(
   return [
     ...(typeof validation.fiscalNoteEstimate === 'number'
       ? [
-          claim('Official fiscal note', validation.fiscalNoteEstimate, {
+          // Named by its source: a proxy note (another bill's score) must not
+          // read as this bill's own.
+          claim(fiscalNoteLabel(validation), validation.fiscalNoteEstimate, {
             sourceUrl: validation.fiscalNoteUrl,
             notes: validation.discrepancyExplanation,
           }),
diff --git a/app/src/pages/flagship/BillReport.page.tsx b/app/src/pages/flagship/BillReport.page.tsx
index 29fe2674c..cf4b51eae 100644
--- a/app/src/pages/flagship/BillReport.page.tsx
+++ b/app/src/pages/flagship/BillReport.page.tsx
@@ -24,7 +24,11 @@ import { useFlagshipMetadataStatus } from '@/hooks/useFlagshipMetadataStatus';
 import { useStoredBillDistricts } from '@/hooks/useStoredBillDistricts';
 import { useTrackedBills } from '@/hooks/useTrackedBills';
 import { storedBillMetrics } from '@/libs/flagship/billMetrics';
-import { billAlreadyCurrentLaw, billReportProvisions } from '@/libs/flagship/billProvisions';
+import {
+  billAlreadyCurrentLaw,
+  billReportProvisions,
+  billScoresOtherThanWriteUp,
+} from '@/libs/flagship/billProvisions';
 import { findTrackedBill, trackerUrlForBillId } from '@/libs/flagship/billTracker';
 import { RootState } from '@/store';
 
@@ -105,6 +109,7 @@ function BillOverviewLead({ bill }: { bill: TrackedBill }) {
 /** Why a bill has, or does not yet have, full results. */
 type RunState =
   | 'already-law'
+  | 'write-up-mismatch'
   | 'no-provisions'
   | 'no-metadata'
   | 'not-started'
@@ -116,6 +121,11 @@ const UNAVAILABLE_COPY: Partial<Record<RunState, { title: string; detail: string
     detail:
       "Scored against current law it changes nothing, so there are no full results to show. The estimates here are the legislative tracker's, against the law before the bill.",
   },
+  'write-up-mismatch': {
+    title: 'The full results are not available for this bill.',
+    detail:
+      "The model parameters the legislative tracker stored for this bill do not match its write-up of the changes, so a run would score a different change. The estimates here are the tracker's.",
+  },
   'no-provisions': {
     title: 'The full results cannot be calculated.',
     detail: 'None of this bill’s provisions are mapped to model parameters yet.',
@@ -212,6 +222,7 @@ function FullResultsStatus({
 
 const STORED_NOTE: Partial<Record<RunState, string>> = {
   'already-law': 'Estimates from the legislative tracker, against the law before this bill',
+  'write-up-mismatch': 'Stored estimates from the legislative tracker · full results unavailable',
   'no-provisions': 'Stored estimates from the legislative tracker · full results unavailable',
   'no-metadata': 'Stored estimates from the legislative tracker · full results unavailable',
   'not-started': 'Stored estimates from the legislative tracker',
@@ -253,22 +264,30 @@ export default function BillReportPage({ billId: propId }: BillReportPageProps)
     priorLaw: alreadyCurrentLaw,
   });
 
+  // The Policy changes table shows the tracker's write-up; a run scores the
+  // stored parameters. When they disagree (a tracker row with its reform
+  // and baseline swapped), a run would contradict the table above it.
+  const writeUpMismatch =
+    !alreadyCurrentLaw && billScoresOtherThanWriteUp(bill?.provisions ?? [], bill?.changes);
+
   const billPaths = provisions.map((p) => p.path);
   const trackRecord = useModelTrackRecord(billPaths);
   // Only a reader's request starts the run, and it waits for metadata so an
   // enacted bill is recognized before any run starts.
   const economy = useBillEconomy(bill, {
-    enabled: runRequested && metadataLoaded && !alreadyCurrentLaw,
+    enabled: runRequested && metadataLoaded && !alreadyCurrentLaw && !writeUpMismatch,
   });
   const runState: RunState = alreadyCurrentLaw
     ? 'already-law'
-    : provisions.length === 0
-      ? 'no-provisions'
-      : metadataError && !metadataLoaded
-        ? 'no-metadata'
-        : !runRequested
-          ? 'not-started'
-          : economy.status;
+    : writeUpMismatch
+      ? 'write-up-mismatch'
+      : provisions.length === 0
+        ? 'no-provisions'
+        : metadataError && !metadataLoaded
+          ? 'no-metadata'
+          : !runRequested
+            ? 'not-started'
+            : economy.status;
   const startRun = () => setRunRequestedFor(billId);
   // A state bill's data check is against that state's calibration targets.
   const calibration = useCalibrationMatches(
@@ -322,7 +341,7 @@ export default function BillReportPage({ billId: propId }: BillReportPageProps)
       economyPending={
         <Stack style={{ gap: spacing.lg }}>
           <FullResultsStatus runState={runState} economy={economy} onStart={startRun} />
-          <StoredImpactCharts impact={bill.impactData} />
+          <StoredImpactCharts impact={bill.impactData} state={bill.state} />
         </Stack>
       }
       districtsPending={
diff --git a/app/src/pages/flagship/Reforms.page.tsx b/app/src/pages/flagship/Reforms.page.tsx
index 4667dccfb..ac23dc763 100644
--- a/app/src/pages/flagship/Reforms.page.tsx
+++ b/app/src/pages/flagship/Reforms.page.tsx
@@ -39,14 +39,13 @@ import { billRegion } from '@/hooks/useBillEconomy';
 import { useCurrentCountry } from '@/hooks/useCurrentCountry';
 import { useRunFlagshipReport } from '@/hooks/useRunFlagshipReport';
 import { useTrackedBills } from '@/hooks/useTrackedBills';
-import {
-  addDraftProvision,
-  clearDraftReform,
-  loadReformIntoDraft,
-  setDraftLabel,
-} from '@/libs/draftReform';
+import { loadProvisionsIntoDraft, loadReformIntoDraft } from '@/libs/draftReform';
 import { BillFilters, billPlace, filterBills, NO_BILL_FILTERS } from '@/libs/flagship/billFilters';
-import { billAlreadyCurrentLaw, billReportProvisions } from '@/libs/flagship/billProvisions';
+import {
+  billAlreadyCurrentLaw,
+  billReportProvisions,
+  billScoresOtherThanWriteUp,
+} from '@/libs/flagship/billProvisions';
 import { periodLabel, summarizeIntervals } from '@/libs/flagship/draftLabels';
 import { RootState } from '@/store';
 import { Reform, ReformSource } from '@/types/ingredients/Reform';
@@ -385,6 +384,13 @@ export default function ReformsPage() {
     });
   };
 
+  // As on the bill's report: stored parameters that contradict the bill's
+  // write-up (UT SB60's reform and baseline are swapped) would score
+  // another change, so neither a report nor a draft starts from them.
+  const billScoresOtherChange = (bill: TrackedBill) =>
+    !billAlreadyCurrentLaw(bill.provisions, parameters, billRunYear(bill.provisions)) &&
+    billScoresOtherThanWriteUp(bill.provisions, bill.changes);
+
   /** Current law for a parameter on 1 January of `year`. */
   const currentLawAt = (path: string, year: number) => {
     const values = parameters?.[path]?.values;
@@ -470,11 +476,14 @@ export default function ReformsPage() {
   };
 
   const openBillAsDraft = (bill: TrackedBill) => {
-    clearDraftReform();
-    billProvisions(bill).forEach((provision) =>
-      addDraftProvision(countryId, provision, 'bill', bill.id)
-    );
-    setDraftLabel(bill.title);
+    // The draft runs as the bill's report does: in its first year, on its state.
+    loadProvisionsIntoDraft(countryId, billProvisions(bill), {
+      label: bill.title,
+      year: billRunYear(bill.provisions),
+      region: bill.state ? billRegion(bill, countryId) : undefined,
+      source: 'bill',
+      sourceRef: bill.id,
+    });
     // The draft is Build's page now, not a panel beside this one.
     nav.push(`/${countryId}/build`);
   };
@@ -538,6 +547,7 @@ export default function ReformsPage() {
   // ---- Detail: a tracked bill ----
   if (selectedBill) {
     const provisions = billProvisions(selectedBill);
+    const scoresOtherChange = billScoresOtherChange(selectedBill);
     const impact = selectedBill.impactData;
     const winners = impact?.winnersLosers;
     const betterOff = winners && ((winners.gainMore5Pct ?? 0) + (winners.gainLess5Pct ?? 0)) * 100;
@@ -600,6 +610,13 @@ export default function ReformsPage() {
               unlock when it lands.
             </Text>
           )}
+          {scoresOtherChange && (
+            <Text style={{ fontSize: typography.fontSize.sm, color: colors.text.secondary }}>
+              The model parameters the legislative tracker stored for this bill do not match its
+              write-up of the changes, so a report or draft from them would score a different
+              change.
+            </Text>
+          )}
           <Stack
             style={{
               flexDirection: 'row',
@@ -627,7 +644,7 @@ export default function ReformsPage() {
                     { region: billRegion(selectedBill, countryId) }
                   )
                 }
-                disabled={runReport.isRunning || provisions.length === 0}
+                disabled={runReport.isRunning || provisions.length === 0 || scoresOtherChange}
               >
                 <IconChartBar size={16} />
                 {runReport.isRunning ? 'Starting report…' : 'Run impact report'}
@@ -636,7 +653,7 @@ export default function ReformsPage() {
             <Button
               variant="outline"
               onClick={() => openBillAsDraft(selectedBill)}
-              disabled={provisions.length === 0}
+              disabled={provisions.length === 0 || scoresOtherChange}
             >
               <IconPencil size={16} />
               Open as draft reform
diff --git a/app/src/tests/fixtures/api/billFeedMocks.ts b/app/src/tests/fixtures/api/billFeedMocks.ts
index 1c4dc74bb..ec2fbf2fb 100644
--- a/app/src/tests/fixtures/api/billFeedMocks.ts
+++ b/app/src/tests/fixtures/api/billFeedMocks.ts
@@ -45,3 +45,171 @@ export const NET_COST_DRIFT_ROWS: TrackerTableRows = {
     },
   ],
 };
+
+/** The most rows one tracker read returns, as the Supabase cap sets it. */
+export const TRACKER_PAGE_LIMIT = 1000;
+
+/** The tracker's bill-status table holds more rows than one read returns. */
+export const STATUS_TABLE_ROWS = 1418;
+
+/** The first column a PostgREST `order` names ("bill_id" in "bill_id.asc"). */
+const orderColumn = (order: string) => order.split(',')[0].split('.')[0];
+
+const byColumn = (column: string) => (a: any, b: any) =>
+  a[column] < b[column] ? -1 : a[column] > b[column] ? 1 : 0;
+
+/**
+ * A fetch that serves each tracker table a page at a time, as PostgREST
+ * does. A read that names an `order` gets its rows in that order. A read
+ * with none has no fixed row order: as on the live tracker, every page
+ * starts from the table's first rows again, so a later page repeats rows
+ * already read and the rest never arrive.
+ */
+export const mockPagedTrackerFetch = (rows: TrackerTableRows) =>
+  vi.fn(async (url: string) => {
+    const { pathname, searchParams } = new URL(url);
+    const all = rows[pathname.split('/').pop() ?? ''] ?? [];
+    const order = searchParams.get('order');
+    const offset = Number(searchParams.get('offset') ?? 0);
+    const limit = Number(searchParams.get('limit') ?? all.length);
+    const count = Math.max(0, Math.min(limit, all.length - offset));
+    const page = order
+      ? [...all].sort(byColumn(orderColumn(order))).slice(offset, offset + count)
+      : all.slice(0, count);
+    return {
+      ok: true,
+      headers: new Headers({
+        'content-range': `${offset}-${offset + page.length - 1}/${all.length}`,
+      }),
+      json: async () => page,
+    };
+  });
+
+/** WV SB 392, whose one status row is the bill-status table's last. */
+export const LATE_STATUS_BILL = {
+  id: 'wv-sb392',
+  state: 'WV',
+  type: 'bill',
+  title: 'WV SB 392',
+} as const;
+export const LATE_STATUS = {
+  status: 'Signed into Law',
+  legiscanUrl: 'https://legiscan.com/WV/bill/SB392/2026',
+} as const;
+
+/** A full bill-status table with WV SB 392's row past the first page. */
+export const LATE_STATUS_ROWS: TrackerTableRows = {
+  research: [LATE_STATUS_BILL],
+  processed_bills: Array.from({ length: STATUS_TABLE_ROWS }, (_, index) =>
+    index === STATUS_TABLE_ROWS - 1
+      ? {
+          bill_id: 2_000_000 + index,
+          state: 'WV',
+          bill_number: 'SB392',
+          status: LATE_STATUS.status,
+          legiscan_url: LATE_STATUS.legiscanUrl,
+        }
+      : {
+          bill_id: 2_000_000 + index,
+          state: 'OK',
+          bill_number: `HB${1000 + index}`,
+          status: 'Introduced',
+        }
+  ),
+};
+
+/** Bills enough that every tracker table runs past one page. */
+export const MANY_BILLS = TRACKER_PAGE_LIMIT + 1;
+export const MANY_BILLS_STATUS = 'In Committee';
+/** The rate each of those bills changes, and the law it was compared with. */
+const MANY_BILLS_RATE_PATH = 'gov.states.ok.tax.income.rate';
+export const MANY_BILLS_BASELINE_RATE = 0.0475;
+
+const MANY_BILL_NUMBERS = Array.from({ length: MANY_BILLS }, (_, index) => 1000 + index);
+
+/** Every table past one page: each bill has its entry, run, check and status row. */
+export const MANY_BILL_ROWS: TrackerTableRows = {
+  research: MANY_BILL_NUMBERS.map((number) => ({
+    id: `ok-hb${number}`,
+    state: 'OK',
+    type: 'bill',
+    title: `OK HB ${number}`,
+  })),
+  // One row serves both reform_impacts reads: the run and its baseline.
+  reform_impacts: MANY_BILL_NUMBERS.map((number) => ({
+    id: `ok-hb${number}`,
+    computed: true,
+    budgetary_impact: { stateRevenueImpact: -number * 1000 },
+    reform_params: { [MANY_BILLS_RATE_PATH]: 0.04 },
+    baseline_params: { [MANY_BILLS_RATE_PATH]: MANY_BILLS_BASELINE_RATE },
+  })),
+  validation_metadata: MANY_BILL_NUMBERS.map((number) => ({
+    id: `ok-hb${number}`,
+    pe_estimate: -number * 1000,
+    fiscal_note_estimate: -number * 1000,
+    within_range: true,
+  })),
+  processed_bills: MANY_BILL_NUMBERS.map((number) => ({
+    bill_id: 3_000_000 + number,
+    state: 'OK',
+    bill_number: `HB ${number}`,
+    status: MANY_BILLS_STATUS,
+  })),
+};
+
+/** NY S 4487, held twice in the status table under two spellings of its number. */
+export const TWICE_FILED_BILL = {
+  id: 'ny-s-4487',
+  state: 'NY',
+  type: 'bill',
+  title: 'NY S 4487',
+} as const;
+/** LegiScan's row: a LegiScan bill id (about 2 million) and its finer stage. */
+export const TWICE_FILED_LEGISCAN = {
+  bill_id: 1_987_654,
+  state: 'NY',
+  bill_number: 'S04487',
+  status: 'In Committee',
+  legiscan_url: 'https://legiscan.com/NY/bill/S04487/2025',
+} as const;
+/** OpenStates' row: the monitor hashes its bill id to 10,000,000 or more. */
+export const TWICE_FILED_OPENSTATES = {
+  bill_id: 47_123_456,
+  state: 'NY',
+  bill_number: 'S 4487',
+  status: 'Introduced',
+  legiscan_url: 'https://openstates.org/ny/bills/2025-2026/S4487/',
+} as const;
+
+/** The two rows' last action dates, and the row that keeps the bill number. */
+export const TWICE_FILED_CASES = [
+  {
+    when: 'the LegiScan row acted last',
+    winnerName: 'LegiScan',
+    legiscanDate: '2025-05-02',
+    openstatesDate: '2025-03-10',
+    winner: TWICE_FILED_LEGISCAN,
+  },
+  {
+    when: 'the OpenStates row acted last',
+    winnerName: 'OpenStates',
+    legiscanDate: '2025-03-10',
+    openstatesDate: '2025-05-02',
+    winner: TWICE_FILED_OPENSTATES,
+  },
+  {
+    // A timestamp still reads as its day.
+    when: 'both acted the same day',
+    winnerName: 'LegiScan',
+    legiscanDate: '2025-03-10',
+    openstatesDate: '2025-03-10T14:30:00+00:00',
+    winner: TWICE_FILED_LEGISCAN,
+  },
+  {
+    when: 'neither has a date',
+    winnerName: 'LegiScan',
+    legiscanDate: null,
+    openstatesDate: null,
+    winner: TWICE_FILED_LEGISCAN,
+  },
+];
diff --git a/app/src/tests/unit/api/billFeed.test.ts b/app/src/tests/unit/api/billFeed.test.ts
index fd0c4da9b..1f49ba305 100644
--- a/app/src/tests/unit/api/billFeed.test.ts
+++ b/app/src/tests/unit/api/billFeed.test.ts
@@ -9,10 +9,21 @@ import {
 } from '@/api/billFeed';
 import { CURRENT_YEAR } from '@/constants';
 import {
+  LATE_STATUS,
+  LATE_STATUS_ROWS,
+  MANY_BILL_ROWS,
+  MANY_BILLS,
+  MANY_BILLS_BASELINE_RATE,
+  MANY_BILLS_STATUS,
+  mockPagedTrackerFetch,
   mockTrackerFetch,
   NET_COST_DRIFT_ROWS,
   NET_COST_ONLY_ROWS,
   TRACKER_NAMING_ROWS,
+  TWICE_FILED_BILL,
+  TWICE_FILED_CASES,
+  TWICE_FILED_LEGISCAN,
+  TWICE_FILED_OPENSTATES,
 } from '@/tests/fixtures/api/billFeedMocks';
 import { TRACKER_HOME } from '@/tests/fixtures/libs/flagship/billTrackerMocks';
 
@@ -300,6 +311,70 @@ describe('tracker reads', () => {
       '1000',
     ]);
   });
+
+  test('given a status row past the first page then every load finds its stage and link', async () => {
+    vi.stubEnv('NEXT_PUBLIC_TRACKER_SUPABASE_URL', 'https://tracker.example.supabase.co');
+    vi.stubEnv('NEXT_PUBLIC_TRACKER_SUPABASE_ANON_KEY', 'anon-key');
+    // Pages read with no fixed order repeat rows and skip the rest.
+    vi.stubGlobal('fetch', mockPagedTrackerFetch(LATE_STATUS_ROWS));
+
+    const [bill] = (await fetchTrackerBills())!;
+
+    expect([bill.status, bill.legiscanUrl]).toEqual([LATE_STATUS.status, LATE_STATUS.legiscanUrl]);
+  });
+
+  test('given every table past one page then each bill reads once, with its run, baseline, check and stage', async () => {
+    vi.stubEnv('NEXT_PUBLIC_TRACKER_SUPABASE_URL', 'https://tracker.example.supabase.co');
+    vi.stubEnv('NEXT_PUBLIC_TRACKER_SUPABASE_ANON_KEY', 'anon-key');
+    vi.stubGlobal('fetch', mockPagedTrackerFetch(MANY_BILL_ROWS));
+
+    const bills = (await fetchTrackerBills())!;
+
+    const billsWith = (has: (bill: (typeof bills)[number]) => boolean) =>
+      new Set(bills.filter(has).map((bill) => bill.id)).size;
+    expect({
+      listed: bills.length,
+      unique: billsWith(() => true),
+      withRun: billsWith((bill) => bill.impacts?.revenue !== undefined),
+      withBaseline: billsWith(
+        (bill) => bill.provisions[0]?.baselineIntervals?.[0]?.value === MANY_BILLS_BASELINE_RATE
+      ),
+      withCheck: billsWith((bill) => bill.validation?.withinRange === true),
+      withStage: billsWith((bill) => bill.status === MANY_BILLS_STATUS),
+    }).toEqual({
+      listed: MANY_BILLS,
+      unique: MANY_BILLS,
+      withRun: MANY_BILLS,
+      withBaseline: MANY_BILLS,
+      withCheck: MANY_BILLS,
+      withStage: MANY_BILLS,
+    });
+  });
+
+  test.each(TWICE_FILED_CASES)(
+    'given two status rows under one bill number when $when then the $winnerName row wins in any read order',
+    async ({ legiscanDate, openstatesDate, winner }) => {
+      vi.stubEnv('NEXT_PUBLIC_TRACKER_SUPABASE_URL', 'https://tracker.example.supabase.co');
+      vi.stubEnv('NEXT_PUBLIC_TRACKER_SUPABASE_ANON_KEY', 'anon-key');
+      const legiscan = { ...TWICE_FILED_LEGISCAN, last_action_date: legiscanDate };
+      const openstates = { ...TWICE_FILED_OPENSTATES, last_action_date: openstatesDate };
+      const loads = [];
+      for (const processed of [
+        [legiscan, openstates],
+        [openstates, legiscan],
+      ]) {
+        vi.stubGlobal(
+          'fetch',
+          mockTrackerFetch({ research: [TWICE_FILED_BILL], processed_bills: processed })
+        );
+        const [bill] = (await fetchTrackerBills())!;
+        loads.push([bill.status, bill.legiscanUrl]);
+      }
+
+      const won = [winner.status, winner.legiscan_url];
+      expect(loads).toEqual([won, won]);
+    }
+  );
 });
 
 describe('fetchTrackerBills', () => {
@@ -508,6 +583,51 @@ describe('fetchTrackerBills', () => {
     expect(bills![3].legiscanUrl).toBe('https://legiscan.com/KS/bill/HB2620/2026');
   });
 
+  test('given an id with words after the bill number then the stage joins by the bill number', async () => {
+    vi.stubEnv('NEXT_PUBLIC_TRACKER_SUPABASE_URL', 'https://tracker.example.supabase.co');
+    vi.stubEnv('NEXT_PUBLIC_TRACKER_SUPABASE_ANON_KEY', 'anon-key');
+    vi.stubGlobal(
+      'fetch',
+      mockTrackerFetch({
+        research: [
+          // The title names the bill, as the tracker reads it.
+          {
+            id: 'hi-sb3125-hd1',
+            type: 'bill',
+            state: 'HI',
+            title: 'Hawaii SB3125 HD1: tax relief',
+          },
+          {
+            id: 'nj-a1185-marriage-penalty-elimination',
+            type: 'bill',
+            state: 'NJ',
+            title: 'New Jersey A1185: Marriage penalty elimination',
+          },
+          // No bill number in the title: the id's first token names it.
+          { id: 'ut-sb60-bill', type: 'bill', state: 'UT', title: 'Income tax rate reduction' },
+          // A number in the title that names no bill of the state.
+          { id: 'ok-tax-2026', type: 'bill', state: 'OK', title: 'Oklahoma FY 2026 tax plan' },
+        ],
+        processed_bills: [
+          { bill_id: 1, state: 'HI', bill_number: 'SB3125', status: 'Passed Both Chambers' },
+          { bill_id: 2, state: 'NJ', bill_number: 'A1185', status: 'In Committee' },
+          { bill_id: 3, state: 'UT', bill_number: 'SB0060', status: 'Signed into Law' },
+          // The same number in another state is not this bill.
+          { bill_id: 4, state: 'UT', bill_number: 'A1185', status: 'Vetoed' },
+        ],
+      })
+    );
+
+    const bills = await fetchTrackerBills();
+
+    expect(bills!.map((bill) => [bill.id, bill.status])).toEqual([
+      ['hi-sb3125-hd1', 'Passed Both Chambers'],
+      ['nj-a1185-marriage-penalty-elimination', 'In Committee'],
+      ['ut-sb60-bill', 'Signed into Law'],
+      ['ok-tax-2026', UNTRACKED_BILL_STATUS],
+    ]);
+  });
+
   test('given the tracker stores baseline params then the bills carry them', async () => {
     vi.stubEnv('NEXT_PUBLIC_TRACKER_SUPABASE_URL', 'https://tracker.example.supabase.co');
     vi.stubEnv('NEXT_PUBLIC_TRACKER_SUPABASE_ANON_KEY', 'anon-key');
diff --git a/app/src/tests/unit/components/flagship/ValidationPanel.test.tsx b/app/src/tests/unit/components/flagship/ValidationPanel.test.tsx
index 990e3e827..5130d9220 100644
--- a/app/src/tests/unit/components/flagship/ValidationPanel.test.tsx
+++ b/app/src/tests/unit/components/flagship/ValidationPanel.test.tsx
@@ -1,5 +1,6 @@
 import { render, screen, within } from '@test-utils';
 import { describe, expect, test } from 'vitest';
+import type { BillValidation } from '@/api/billFeed';
 import {
   BaselineComparisons,
   BillExternalEstimates,
@@ -73,6 +74,17 @@ const SNAP_AND_CTC_TRACK_RECORD: ScorecardMatches = {
   ],
 };
 
+/** A fiscal note stored as a range with its source and link, but no point estimate. */
+const RANGE_ONLY_FISCAL_NOTE: BillValidation = {
+  peEstimate: -800_583_615,
+  fiscalNoteSource: 'GA Dept. of Audits & Accounts / OPB',
+  fiscalNoteUrl: 'https://opb.georgia.gov/fiscal-notes/hb1001',
+  targetRangeLow: -840_000_000,
+  targetRangeHigh: -680_000_000,
+  withinRange: true,
+  differencePct: 5.3,
+};
+
 describe('BillExternalEstimates', () => {
   test('given a bill with a fiscal note then every estimate shares one aligned table', () => {
     render(
@@ -92,6 +104,81 @@ describe('BillExternalEstimates', () => {
     expect(screen.getByText(/later effective date/)).toBeInTheDocument();
   });
 
+  test('given a fiscal note with a range and no point estimate then the range names and links it', () => {
+    // As ga-hb1001 stores it: the note's range, its source and its link, no single number.
+    render(<BillExternalEstimates billId="ga-hb1001" validation={RANGE_ONLY_FISCAL_NOTE} />);
+
+    const table = screen.getByRole('table', { name: 'Estimates for this bill' });
+    const range = within(table).getByRole('row', { name: /^Accepted range/ });
+    expect(within(range).getByText(RANGE_ONLY_FISCAL_NOTE.fiscalNoteSource!)).toBeInTheDocument();
+    expect(within(range).getByRole('link', { name: 'Read source' })).toHaveAttribute(
+      'href',
+      RANGE_ONLY_FISCAL_NOTE.fiscalNoteUrl
+    );
+    expect(screen.getByText('Within fiscal-note range · Δ 5.3%')).toBeInTheDocument();
+  });
+
+  test('given a fiscal note with a link and no estimate or range then a row still links it', () => {
+    render(
+      <BillExternalEstimates
+        billId="ga-hb1001"
+        validation={{
+          ...RANGE_ONLY_FISCAL_NOTE,
+          targetRangeLow: undefined,
+          targetRangeHigh: undefined,
+        }}
+      />
+    );
+
+    const table = screen.getByRole('table', { name: 'Estimates for this bill' });
+    const row = within(table).getByRole('row', {
+      name: new RegExp(`^${RANGE_ONLY_FISCAL_NOTE.fiscalNoteSource}`),
+    });
+    expect(
+      within(row)
+        .getAllByRole('cell')
+        .map((cell) => cell.textContent)
+    ).toEqual(['No estimate', '—']);
+    expect(within(row).getByRole('link', { name: 'Read source' })).toHaveAttribute(
+      'href',
+      RANGE_ONLY_FISCAL_NOTE.fiscalNoteUrl
+    );
+  });
+
+  test('given an empty fiscal-note link and no estimate then no fiscal-note row shows', () => {
+    render(
+      <BillExternalEstimates
+        billId="ga-hb1001"
+        validation={{ peEstimate: -800_583_615, fiscalNoteUrl: '  ' }}
+      />
+    );
+
+    const table = screen.getByRole('table', { name: 'Estimates for this bill' });
+    expect(within(table).queryByText('Official fiscal note')).not.toBeInTheDocument();
+    expect(within(table).queryByText('No estimate')).not.toBeInTheDocument();
+  });
+
+  test('given a fiscal note with a named source then its row is called by that source', () => {
+    // A proxy note (ct-sb78: OFA's score of another bill) must not read as the bill's own.
+    render(
+      <BillExternalEstimates
+        billId="ct-sb78"
+        validation={{
+          peEstimate: -60_000_000,
+          fiscalNoteEstimate: -57_500_000,
+          fiscalNoteSource: 'OFA fiscal note for sSB-1 Sec. 6',
+          withinRange: true,
+        }}
+      />
+    );
+
+    const table = screen.getByRole('table', { name: 'Estimates for this bill' });
+    expect(
+      within(table).getByRole('row', { name: /^OFA fiscal note for sSB-1 Sec\. 6/ })
+    ).toHaveTextContent('-$57.5M');
+    expect(within(table).queryByText('Official fiscal note')).not.toBeInTheDocument();
+  });
+
   test('given a bill outside the range then the chip says so', () => {
     render(
       <BillExternalEstimates
diff --git a/app/src/tests/unit/components/flagship/report/StoredImpactCharts.test.tsx b/app/src/tests/unit/components/flagship/report/StoredImpactCharts.test.tsx
index 9765e9971..b712be296 100644
--- a/app/src/tests/unit/components/flagship/report/StoredImpactCharts.test.tsx
+++ b/app/src/tests/unit/components/flagship/report/StoredImpactCharts.test.tsx
@@ -8,6 +8,7 @@ describe('StoredImpactCharts', () => {
     render(
       <StoredImpactCharts
         impact={{ budgetary: { stateRevenueImpact: 11_482_293, netCost: 11_482_293 } }}
+        state="UT"
       />
     );
 
@@ -17,7 +18,9 @@ describe('StoredImpactCharts', () => {
   });
 
   test('given a stored revenue loss then it reads as a loss with a minus sign', () => {
-    render(<StoredImpactCharts impact={{ budgetary: { stateRevenueImpact: -282_165_820 } }} />);
+    render(
+      <StoredImpactCharts impact={{ budgetary: { stateRevenueImpact: -282_165_820 } }} state="GA" />
+    );
 
     const budget = screen.getByRole('region', { name: 'Budgetary impact' });
     expect(budget).toHaveTextContent('−$282.2m');
@@ -25,13 +28,23 @@ describe('StoredImpactCharts', () => {
   });
 
   test('given only a stored net cost then it stands in for the revenue change', () => {
-    render(<StoredImpactCharts impact={NET_COST_ONLY_IMPACT} />);
+    render(<StoredImpactCharts impact={NET_COST_ONLY_IMPACT} state="KS" />);
 
     const budget = screen.getByRole('region', { name: 'Budgetary impact' });
     expect(budget).toHaveTextContent('−$74.2m');
     expect(budget).toHaveTextContent('Annual state revenue loss');
   });
 
+  test('given a federal bill then its stored revenue change is not called state revenue', () => {
+    // As the Overview words it for HR 1425: the federal budget, not a state's.
+    render(<StoredImpactCharts impact={{ budgetary: { stateRevenueImpact: -225_500_000_000 } }} />);
+
+    const budget = screen.getByRole('region', { name: 'Budgetary impact' });
+    expect(budget).toHaveTextContent('−$225.5bn');
+    expect(budget).toHaveTextContent('Annual revenue loss');
+    expect(budget).not.toHaveTextContent(/state revenue/i);
+  });
+
   test('given no stored results then nothing shows', () => {
     const { container } = render(<StoredImpactCharts impact={{}} />);
 
diff --git a/app/src/tests/unit/libs/draftReform.test.ts b/app/src/tests/unit/libs/draftReform.test.ts
index 8af5babce..b120927e5 100644
--- a/app/src/tests/unit/libs/draftReform.test.ts
+++ b/app/src/tests/unit/libs/draftReform.test.ts
@@ -160,6 +160,22 @@ describe('draftReform', () => {
     expect(getDraftReform()).not.toHaveProperty('baselineReformId');
   });
 
+  it('given provisions loaded with no source then the draft is hand-built', () => {
+    loadProvisionsIntoDraft('us', [{ ...CTC_PROVISION, value: 3600 }]);
+
+    expect(getDraftReform()?.source).toBe('manual');
+    expect(getDraftReform()).not.toHaveProperty('sourceRef');
+  });
+
+  it('given provisions loaded from a bill then the draft keeps the bill as its source', () => {
+    loadProvisionsIntoDraft('us', [{ ...CTC_PROVISION, value: 3600 }], {
+      source: 'bill',
+      sourceRef: 'us-hr1425',
+    });
+
+    expect(getDraftReform()).toMatchObject({ source: 'bill', sourceRef: 'us-hr1425' });
+  });
+
   it('given a search entry and metadata values then provisionFromSearchEntry uses the current value as baseline', () => {
     const provision = provisionFromSearchEntry(
       { path: 'gov.x', breadcrumb: 'X', unit: 'currency-USD' },
diff --git a/app/src/tests/unit/libs/flagship/billProvisions.test.ts b/app/src/tests/unit/libs/flagship/billProvisions.test.ts
index 3468c6cc6..6cd90f7f4 100644
--- a/app/src/tests/unit/libs/flagship/billProvisions.test.ts
+++ b/app/src/tests/unit/libs/flagship/billProvisions.test.ts
@@ -1,5 +1,10 @@
 import { describe, expect, test } from 'vitest';
-import { billAlreadyCurrentLaw, billReportProvisions } from '@/libs/flagship/billProvisions';
+import {
+  billAlreadyCurrentLaw,
+  billReportProvisions,
+  billScoresOtherThanWriteUp,
+  changeNamesPath,
+} from '@/libs/flagship/billProvisions';
 import type { ParameterMetadataCollection } from '@/types/metadata/parameterMetadata';
 
 const RATE = 'gov.states.ga.tax.income.main.flat_rate';
@@ -127,3 +132,174 @@ describe('billAlreadyCurrentLaw', () => {
     ).toBe(true);
   });
 });
+
+describe('changeNamesPath', () => {
+  test('given a placeholder then it stands for one path segment', () => {
+    const parameter = 'gov.states.ga.tax.income.main.{filing_status}.brackets[5].rate';
+
+    expect(changeNamesPath(parameter, 'gov.states.ga.tax.income.main.joint.brackets[5].rate')).toBe(
+      true
+    );
+    expect(changeNamesPath(parameter, 'gov.states.ga.tax.income.main.joint.brackets[4].rate')).toBe(
+      false
+    );
+    expect(changeNamesPath(RATE, RATE)).toBe(true);
+  });
+});
+
+describe('billScoresOtherThanWriteUp', () => {
+  const UT_RATE = 'gov.states.ut.tax.income.rate';
+  const change = (before: string, after: string, parameter?: string) => ({
+    label: 'Income tax rate',
+    before,
+    after,
+    ...(parameter ? { parameter } : {}),
+  });
+
+  test('given the scored value is the write-up’s law before the bill then they disagree', () => {
+    // UT SB60 as stored: reform_params 0.045, a write-up of 4.5% → 4.45%.
+    const provisions = [dated(UT_RATE, ['2026-01-01', '2100-12-31', 0.045])];
+
+    expect(billScoresOtherThanWriteUp(provisions, [change('4.5%', '4.45%')])).toBe(true);
+  });
+
+  test('given the scored value is the write-up’s new value then they agree', () => {
+    const provisions = [dated(UT_RATE, ['2026-01-01', '2100-12-31', 0.0445])];
+
+    expect(billScoresOtherThanWriteUp(provisions, [change('4.5%', '4.45%')])).toBe(false);
+  });
+
+  test('given a write-up rounded to its last digit then it still reads the scored value', () => {
+    // Within the rounding of "4.5%": the law before the bill.
+    expect(
+      billScoresOtherThanWriteUp([{ path: UT_RATE, value: 0.04501 }], [change('4.5%', '4.45%')])
+    ).toBe(true);
+    // Within the rounding of "4.4%": the bill.
+    expect(
+      billScoresOtherThanWriteUp([{ path: RATE, value: 0.04449 }], [change('5.19%', '4.4%')])
+    ).toBe(false);
+  });
+
+  test('given amounts in dollars or bare numbers then they read as written', () => {
+    const provisions = [{ path: DEDUCTION, value: 2000 }];
+
+    expect(billScoresOtherThanWriteUp(provisions, [change('$1,500', '$2,000')])).toBe(false);
+    expect(billScoresOtherThanWriteUp(provisions, [change('$2,000', '$2,500')])).toBe(true);
+    expect(
+      billScoresOtherThanWriteUp([{ path: UT_RATE, value: 0.0445 }], [change('4.5', '4.45')])
+    ).toBe(false);
+  });
+
+  test('given a percent stored as a whole number then a write-up as a fraction reads it', () => {
+    expect(
+      billScoresOtherThanWriteUp([{ path: UT_RATE, value: 4.45 }], [change('0.045', '0.0445')])
+    ).toBe(false);
+    expect(
+      billScoresOtherThanWriteUp([{ path: UT_RATE, value: 4.5 }], [change('0.045', '0.0445')])
+    ).toBe(true);
+  });
+
+  test('given a phased bill then any value it sets can be the one written up', () => {
+    const provisions = [
+      dated(RATE, ['2026-01-01', '2026-12-31', 0.0519], ['2027-01-01', '2100-12-31', 0.0479]),
+    ];
+
+    // The first year keeps the law before the bill; the bill's value comes later.
+    expect(billScoresOtherThanWriteUp(provisions, [change('5.19%', '4.79%')])).toBe(false);
+  });
+
+  test('given a change that names its parameter then only that parameter is checked', () => {
+    const parameter = 'gov.states.ga.tax.income.main.{filing_status}.brackets[5].rate';
+    const swapped = [
+      { path: 'gov.states.ga.tax.income.main.single.brackets[5].rate', value: 0.0549 },
+      { path: 'gov.states.ga.tax.income.main.joint.brackets[5].rate', value: 0.0549 },
+      // Another provision that holds the written value does not count.
+      { path: DEDUCTION, value: 5.19 },
+    ];
+
+    expect(billScoresOtherThanWriteUp(swapped, [change('5.49%', '5.19%', parameter)])).toBe(true);
+  });
+
+  test('given one filing status holds the written value then the bill agrees', () => {
+    const parameter = 'gov.states.ga.tax.income.main.{filing_status}.brackets[5].rate';
+    const provisions = [
+      { path: 'gov.states.ga.tax.income.main.single.brackets[5].rate', value: 0.0519 },
+      // The joint rate stays at the written law before the bill.
+      { path: 'gov.states.ga.tax.income.main.joint.brackets[5].rate', value: 0.0575 },
+    ];
+
+    expect(billScoresOtherThanWriteUp(provisions, [change('5.75%', '5.19%', parameter)])).toBe(
+      false
+    );
+  });
+
+  test('given a threshold written as the joint amount then the bill agrees', () => {
+    // A filing-status threshold written up with one value: the joint one.
+    const parameter =
+      'gov.states.ut.tax.income.credits.taxpayer.phase_out.threshold.{filing_status}';
+    const provisions = [
+      {
+        path: 'gov.states.ut.tax.income.credits.taxpayer.phase_out.threshold.SINGLE',
+        value: 250_000,
+      },
+      {
+        path: 'gov.states.ut.tax.income.credits.taxpayer.phase_out.threshold.JOINT',
+        value: 500_000,
+      },
+    ];
+
+    expect(
+      billScoresOtherThanWriteUp(provisions, [change('$400,000', '$500,000', parameter)])
+    ).toBe(false);
+    // The single amount equals the written law before the bill; the joint one is the bill.
+    expect(
+      billScoresOtherThanWriteUp(provisions, [change('$250,000', '$500,000', parameter)])
+    ).toBe(false);
+  });
+
+  test('given a yearly write-up of a monthly parameter then nothing is flagged', () => {
+    // $1,000 a year is 83.33 a month; neither written value is the stored one.
+    const provisions = [{ path: 'gov.states.ut.benefit.monthly_amount', value: 83.33 }];
+
+    expect(billScoresOtherThanWriteUp(provisions, [change('$500', '$1,000')])).toBe(false);
+  });
+
+  test('given an after written as a step or a year then nothing is flagged', () => {
+    const phased = [
+      dated(UT_RATE, ['2026-01-01', '2026-12-31', 0.045], ['2027-01-01', '2100-12-31', 0.0425]),
+    ];
+
+    // "−0.25%" is the step from 4.5%, not the new rate.
+    expect(billScoresOtherThanWriteUp(phased, [change('4.5%', '−0.25%')])).toBe(false);
+    expect(
+      billScoresOtherThanWriteUp(
+        [dated(UT_RATE, ['2026-01-01', '2026-12-31', 0.04], ['2027-01-01', '2100-12-31', 0.05])],
+        [change('4%', '+1%')]
+      )
+    ).toBe(false);
+    expect(
+      billScoresOtherThanWriteUp([{ path: UT_RATE, value: 0.0445 }], [change('2026', '2027')])
+    ).toBe(false);
+  });
+
+  test('given a write-up that cannot be paired or read as a number then nothing is flagged', () => {
+    const two = [
+      { path: UT_RATE, value: 0.045 },
+      { path: DEDUCTION, value: 2000 },
+    ];
+
+    // Two provisions, no parameter named: which one the change describes is unknown.
+    expect(billScoresOtherThanWriteUp(two, [change('4.5%', '4.45%')])).toBe(false);
+    // Words, not one number.
+    expect(
+      billScoresOtherThanWriteUp(
+        [{ path: UT_RATE, value: 0.045 }],
+        [change('Under 7', 'Under 7 (2026) to Under 16 (2035)')]
+      )
+    ).toBe(false);
+    expect(billScoresOtherThanWriteUp([{ path: UT_RATE, value: 0.045 }], undefined)).toBe(false);
+    expect(billScoresOtherThanWriteUp([{ path: UT_RATE, value: true }], [change('No', '5%')])).toBe(
+      false
+    );
+  });
+});
diff --git a/app/src/tests/unit/libs/flagship/modelValidation.test.ts b/app/src/tests/unit/libs/flagship/modelValidation.test.ts
index a23126175..8acc07162 100644
--- a/app/src/tests/unit/libs/flagship/modelValidation.test.ts
+++ b/app/src/tests/unit/libs/flagship/modelValidation.test.ts
@@ -202,6 +202,16 @@ describe('claimsFromBillValidation', () => {
     expect(claims[1].source).toBe('GBPI');
   });
 
+  test('given the fiscal note names its source then the claim carries that source', () => {
+    const claims = claimsFromBillValidation('ct-sb78', {
+      fiscalNoteEstimate: -57_500_000,
+      fiscalNoteSource: '  OFA fiscal note for sSB-1 Sec. 6 ',
+      peEstimate: -60_000_000,
+    });
+
+    expect(claims[0].source).toBe('OFA fiscal note for sSB-1 Sec. 6');
+  });
+
   test('given no comparable estimates then no claims return', () => {
     expect(claimsFromBillValidation('x', { peEstimate: -5 })).toEqual([]);
   });
diff --git a/app/src/tests/unit/pages/flagship/BillReport.test.tsx b/app/src/tests/unit/pages/flagship/BillReport.test.tsx
index ef9423421..f3ca6de18 100644
--- a/app/src/tests/unit/pages/flagship/BillReport.test.tsx
+++ b/app/src/tests/unit/pages/flagship/BillReport.test.tsx
@@ -154,6 +154,34 @@ describe('BillReportPage', () => {
     ).toBeInTheDocument();
   });
 
+  test('given a federal bill then economic impacts word its stored budget as the overview does', async () => {
+    const user = userEvent.setup();
+    renderReport();
+
+    await user.click(await screen.findByRole('tab', { name: 'Economic impacts' }));
+
+    const budget = within(screen.getByRole('tabpanel')).getByRole('region', {
+      name: 'Budgetary impact',
+    });
+    expect(budget).toHaveTextContent('Annual revenue loss');
+    expect(budget).not.toHaveTextContent(/state revenue/i);
+  });
+
+  test('given a state bill then economic impacts word its stored budget as state revenue', async () => {
+    const user = userEvent.setup();
+    mockFetchTrackerBills.mockResolvedValue([
+      { ...TRACKED_BILL, id: 'ut-hb106', jurisdiction: 'Utah', state: 'UT' },
+    ]);
+    renderReport('ut-hb106');
+
+    await user.click(await screen.findByRole('tab', { name: 'Economic impacts' }));
+
+    const budget = within(screen.getByRole('tabpanel')).getByRole('region', {
+      name: 'Budgetary impact',
+    });
+    expect(budget).toHaveTextContent('Annual state revenue loss');
+  });
+
   test('given the overview then summary, date and bill text show; the verdict is in Validation', async () => {
     const user = userEvent.setup();
     renderReport();
@@ -366,6 +394,45 @@ describe('BillReportPage', () => {
     expect(screen.getByText('Winners and losers')).toBeInTheDocument();
   });
 
+  test('given the stored parameters disagree with the write-up then no run is offered and the tracker estimate stays', async () => {
+    const user = userEvent.setup();
+    // UT SB60 as the tracker stores it: a write-up of 4.5% → 4.45%, but
+    // reform params of 0.045, the law before the bill.
+    mockFetchTrackerBills.mockResolvedValue([
+      {
+        ...TRACKED_BILL,
+        id: 'ut-sb60-bill',
+        state: 'UT',
+        title: 'Utah SB60: Income tax rate reduction (enacted)',
+        provisions: [
+          {
+            path: 'gov.states.ut.tax.income.rate',
+            value: 0.045,
+            intervals: [{ startDate: '2026-01-01', endDate: '2100-12-31', value: 0.045 }],
+            baselineIntervals: [{ startDate: '2026-01-01', endDate: '2100-12-31', value: 0.0445 }],
+          },
+        ],
+        changes: [{ label: 'Income tax rate', before: '4.5%', after: '4.45%' }],
+      },
+    ]);
+    renderReport('ut-sb60-bill');
+
+    expect(
+      await screen.findByText(
+        'Stored estimates from the legislative tracker · full results unavailable'
+      )
+    ).toBeInTheDocument();
+    await user.click(screen.getByRole('tab', { name: 'Economic impacts' }));
+    const panel = screen.getByRole('tabpanel');
+    expect(
+      within(panel).getByText('The full results are not available for this bill.')
+    ).toBeInTheDocument();
+    expect(within(panel).queryByRole('button', { name: 'Load full results' })).toBeNull();
+    // The tracker's own estimate still shows.
+    expect(within(panel).getByRole('region', { name: 'Budgetary impact' })).toBeInTheDocument();
+    expect(mockUseBillEconomy).not.toHaveBeenCalledWith(expect.anything(), { enabled: true });
+  });
+
   test('given the tracker wrote up the changes then the overview lists them as scored', async () => {
     mockFetchTrackerBills.mockResolvedValue([
       {
diff --git a/app/src/tests/unit/pages/flagship/Reforms.test.tsx b/app/src/tests/unit/pages/flagship/Reforms.test.tsx
index f707afe4e..e82504136 100644
--- a/app/src/tests/unit/pages/flagship/Reforms.test.tsx
+++ b/app/src/tests/unit/pages/flagship/Reforms.test.tsx
@@ -1,7 +1,8 @@
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { render, renderWithCountry, screen, userEvent, waitFor, within } from '@test-utils';
 import { beforeEach, describe, expect, test, vi } from 'vitest';
-import { clearDraftReform, getDraftReform } from '@/libs/draftReform';
+import { CURRENT_YEAR } from '@/constants';
+import { clearDraftReform, draftYear, getDraftReform } from '@/libs/draftReform';
 import ReformsPage from '@/pages/flagship/Reforms.page';
 import {
   FEDERAL_ENACTED,
@@ -173,6 +174,48 @@ const FEED_BILLS = [
   },
 ];
 
+/** A state bill that first takes effect next year (live: RI S2364, from 2027). */
+const LATER_STATE_BILL = {
+  id: 'ri-s2364',
+  countryId: 'us' as const,
+  jurisdiction: 'Rhode Island',
+  state: 'RI',
+  title: 'Rhode Island S2364: income tax rate cut',
+  status: 'In Committee',
+  summary: 'Cuts the lowest income tax rate from 2027.',
+  provisions: [
+    {
+      path: 'gov.states.ri.tax.income.rates[0].rate',
+      value: 0.0375,
+      intervals: [{ startDate: '2027-01-01', endDate: '2100-12-31', value: 0.0375 }],
+      fallbackBreadcrumb: 'Rhode Island → Income tax → Lowest rate',
+    },
+  ],
+};
+
+/**
+ * UT SB60 as the tracker stores it: a write-up of 4.5% → 4.45%, but
+ * reform params of 0.045, the law before the bill.
+ */
+const SWAPPED_STATE_BILL = {
+  id: 'ut-sb60-bill',
+  countryId: 'us' as const,
+  jurisdiction: 'Utah',
+  state: 'UT',
+  title: 'Utah SB60: Income tax rate reduction',
+  status: 'Signed into Law',
+  summary: 'Cuts the income tax rate from 4.5% to 4.45%.',
+  provisions: [
+    {
+      path: 'gov.states.ut.tax.income.rate',
+      value: 0.045,
+      intervals: [{ startDate: '2026-01-01', endDate: '2100-12-31', value: 0.045 }],
+      fallbackBreadcrumb: 'Utah → Income tax → Rate',
+    },
+  ],
+  changes: [{ label: 'Income tax rate', before: '4.5%', after: '4.45%' }],
+};
+
 function renderReforms(path?: string) {
   const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
   const ui = (
@@ -289,6 +332,53 @@ describe('ReformsPage', () => {
     expect(draft?.provisions.length).toBeGreaterThan(0);
   });
 
+  test('given a state bill from a later year opens as a draft then the draft runs as its report does', async () => {
+    const user = userEvent.setup();
+    mockFetchTrackerBills.mockResolvedValue([...FEED_BILLS, LATER_STATE_BILL]);
+    renderReforms(`/us/reforms?bill=${LATER_STATE_BILL.id}`);
+
+    await user.click(await screen.findByRole('button', { name: /open as draft reform/i }));
+
+    // The bill's first year and its state, not this year and the whole country.
+    expect(getDraftReform()).toMatchObject({
+      label: LATER_STATE_BILL.title,
+      year: 2027,
+      population: { scope: 'national', region: 'state/ri' },
+      source: 'bill',
+      sourceRef: LATER_STATE_BILL.id,
+      provisions: [{ path: 'gov.states.ri.tax.income.rates[0].rate', value: 0.0375 }],
+    });
+  });
+
+  test('given a federal bill opens as a draft then the draft runs on the whole country', async () => {
+    const user = userEvent.setup();
+    renderReforms('/us/reforms?bill=us-ctc-expansion');
+
+    await user.click(await screen.findByRole('button', { name: /open as draft reform/i }));
+
+    const draft = getDraftReform();
+    expect(draftYear(draft)).toBe(Number(CURRENT_YEAR));
+    // No state region, and still the bill's draft.
+    expect(draft?.population).toEqual({ scope: 'national' });
+    expect(draft).toMatchObject({ source: 'bill', sourceRef: 'us-ctc-expansion' });
+  });
+
+  test('given stored parameters that contradict the write-up then no report or draft starts', async () => {
+    const user = userEvent.setup();
+    mockFetchTrackerBills.mockResolvedValue([...FEED_BILLS, SWAPPED_STATE_BILL]);
+    renderReforms(`/us/reforms?bill=${SWAPPED_STATE_BILL.id}`);
+
+    const draftButton = await screen.findByRole('button', { name: /open as draft reform/i });
+    expect(draftButton).toBeDisabled();
+    expect(screen.getByRole('button', { name: /run impact report/i })).toBeDisabled();
+    expect(screen.getByText(/do not match its write-up of the changes/)).toBeInTheDocument();
+
+    await user.click(draftButton);
+
+    expect(getDraftReform()).toBeNull();
+    expect(mockRun).not.toHaveBeenCalled();
+  });
+
   test('given the federal level then state bills leave', async () => {
     const user = userEvent.setup();
     renderReforms();