@dzhechkov/harness-core 0.8.39 → 0.8.41

package/src/compounding.ts

@@ -15,7 +15,8 @@
  * Everything here is PURE: callers gather facts (files, store rows); this module only computes.
  */
 
-import { EVENT_CHAIN_SCOPE, verifyEventChainText } from './event-chain.js';
+import { EVENT_CHAIN_SCOPE, classifyChainDefects, verifyEventChainText } from './event-chain.js';
+import type { GuardOp } from './guard.js';
 import {
   isOffsetIsoTimestamp,
   type PromotionAcceptanceEvidence,
@@ -156,19 +157,41 @@ export function replayableInstances(
 
 export interface GuardEvent {
   readonly ts: string;
-  readonly op?: 'publish' | 'teach' | 'consolidate' | 'reindex';
+  // Includes 'code': the code guard writes audit rows for this operation too.
+  readonly op?: GuardOp;
   readonly verdict: string;
   readonly rules: readonly string[]; // violated rule ids
   readonly violations?: readonly { readonly rule: string; readonly contentAnchor?: string }[];
+  /**
+   * 1-based position of this record among the log's non-empty lines — the ONLY thing that can place
+   * it relative to a chain defect. Absent when the caller read the rows without a chain.
+   */
+  readonly chainLine?: number;
 }
 
 export type FunnelEvidenceSource<T> =
   | { readonly status: 'measured'; readonly rows: readonly T[] }
   | { readonly status: 'not-measured'; readonly reason: string };
 
+/**
+ * Where the guard journal's chain damage sits, so a PERIOD can be judged instead of the whole FILE.
+ *
+ * A log damaged once in March and unbroken since is not evidence against September's rows, and
+ * refusing to measure September because of March is the same "verdict answers a different question"
+ * defect the chain headline was fixed for (backlog b38dd3ba, MEASURED 2026-09-21: 28 defects, all
+ * before a run of 1169 unbroken records, suppressed BOTH measured months).
+ */
+export interface GuardAuditChainWindow {
+  /** First non-empty line of the current unbroken run: one past the last defect. */
+  readonly runFrom: number;
+  /** Total defects in the file. Zero means the window imposes nothing. */
+  readonly defects: number;
+}
+
 export interface LessonToRuleFunnelFacts {
   readonly promotionRuns: FunnelEvidenceSource<PromotionRunEvidence>;
   readonly guardAudits: FunnelEvidenceSource<GuardEvent>;
+  readonly guardAuditChain?: GuardAuditChainWindow;
   readonly promotionAcceptances?: readonly PromotionAcceptanceEvidence[];
   readonly truncatedPromotionPeriods?: readonly string[];
   readonly acceptanceHistoryComplete?: boolean;
@@ -274,6 +297,20 @@ export interface EvidenceChainHealth {
   readonly preChainPrefix: number;
   readonly defects: number;
   readonly defectKinds: readonly string[];
+  /**
+   * WHERE the defects sit relative to the log's current unbroken run, and HOW MUCH of a run that is.
+   * Without this a bare `FAILED` over a log whose damage is entirely historical reads as "today's
+   * numbers are garbage", while `dz chain` over the SAME file says "healed … verdicts over those are
+   * sound" — MEASURED 2026-09-20 on `.dz/guard-audit.jsonl`: 28 defects, all before the current run,
+   * 1095 unbroken records after them; one instrument printed FAILED, the other healed, both exit 0
+   * (backlog 79ce6262). Neither was lying; neither named its WINDOW. `event-chain.ts` says it
+   * outright: a caller that reports soundness without printing the run size overclaims on its behalf,
+   * and the same holds for a caller that reports damage without printing where the damage sits.
+   */
+  readonly defectsBeforeRun: number;
+  readonly defectsInRun: number;
+  /** Records in the current unbroken run — the evidence behind any "sound for today" reading. */
+  readonly runRecords: number;
 }
 
 export interface InstrumentationHealth {
@@ -394,6 +431,13 @@ function executionMeasurement(
   if (periodAudits.length === 0) {
     return LESSON_TO_RULE_FUNNEL_POLICY.unavailable(`guard-audit-not-recorded:${period}`);
   }
+  // Damage that PRECEDES this period's rows says nothing about them; damage that touches them does.
+  // A row with no position cannot be placed, and unplaceable is not the same as sound — it refuses.
+  const chain = facts.guardAuditChain;
+  if (chain !== undefined && chain.defects > 0
+    && periodAudits.some((row) => row.chainLine === undefined || row.chainLine < chain.runFrom)) {
+    return LESSON_TO_RULE_FUNNEL_POLICY.unavailable(`guard-audit-chain-damaged:${period}`);
+  }
   const audits = periodAudits.filter((row) => row.op === 'publish');
   if (audits.length === 0) {
     return LESSON_TO_RULE_FUNNEL_POLICY.unavailable(`guard-publish-not-recorded:${period}`);
@@ -594,6 +638,11 @@ export function assembleCompoundingReport(facts: CompoundingFacts): CompoundingR
       preChainPrefix: v.preChainPrefix,
       defects: v.defects.length,
       defectKinds: [...new Set(v.defects.map((d) => d.kind))],
+      ...((age) => ({
+        defectsBeforeRun: age.beforeRun.length,
+        defectsInRun: age.inRun.length,
+        runRecords: age.runRecords,
+      }))(classifyChainDefects(v, v.lines)),
     };
   });
 
@@ -623,13 +672,7 @@ export function assembleCompoundingReport(facts: CompoundingFacts): CompoundingR
     trajectory.length > 0 ? `guard: ${improvedRules}/${trajectory.length} rules recur less in the later half` : 'guard: not enough history',
     `cold-vs-warm: ${replay.verdict === 'insufficient-data' ? 'INSUFFICIENT DATA (accruing)' : 'READY to measure'}`,
     instrumentation.applyLegLive ? 'apply leg: live' : 'apply leg: STALE — fix the instrumentation before trusting anything above',
-    ...(chains.length === 0
-      ? []
-      : [
-          instrumentation.chainsOk
-            ? 'evidence chain: verified'
-            : 'evidence chain: CORRUPT — the numbers above are computed from a damaged log',
-        ]),
+    ...(chains.length === 0 ? [] : [chainHeadline(chains)]),
   ].join(' · ');
 
   return { pool, guardTrajectory: trajectory, replay, instrumentation, lessonToRuleFunnel, verdict };
@@ -671,6 +714,68 @@ function renderFunnelPeriodMeasurements(row: LessonToRuleFunnelPeriod): string {
   return `${renderPromotionMeasurements(row)} · ${renderFunnelMeasurement('executions', row.executions)}`;
 }
 
+/**
+ * The HEADLINE verdict over every evidence log — three-valued, because two values lied.
+ *
+ * MEASURED 2026-09-21 on `.dz/guard-audit.jsonl`: 28 defects, the LAST of them dated 2026-09-05,
+ * followed by more than a thousand unbroken records. The old headline read
+ * "CORRUPT — the numbers above are computed from a damaged log", which is true of the FILE'S
+ * HISTORY and false about the numbers it was printed next to. The distinction already existed one
+ * function below, in {@link chainVerdictPhrase}; it simply never reached the line a reader sees
+ * first. That is the same defect class this report exists to find: a verdict answering a different
+ * question than the one it appears to answer.
+ */
+/**
+ * Whether the report's OWN numbers may be trusted, as a value the caller can turn into an exit code.
+ *
+ * Backlog 79ce6262 named the defect: the report printed "the numbers above are computed from a
+ * damaged log" and exited 0 anyway — a tool announcing its own output untrustworthy and reporting
+ * success. That record offered two lawful cures and asked which applies. Both do, on different
+ * branches, and only the three-valued verdict lets them coexist: damage BEHIND the current run
+ * narrows the WORDING (the numbers stand, exit 0), damage INSIDE it makes the numbers genuinely
+ * unreliable and must reach the exit code.
+ *
+ * `'trusted'` ⇒ 0. `'unreliable'` ⇒ a non-zero the caller chooses — the run succeeded, the verdict
+ * cannot be relied on, which is this repository's INCONCLUSIVE shape, not its failure shape.
+ */
+export function chainTrust(chains: readonly EvidenceChainHealth[]): 'trusted' | 'unreliable' {
+  return chains.some((c) => !c.ok && c.defectsInRun > 0) ? 'unreliable' : 'trusted';
+}
+
+export function chainHeadline(chains: readonly EvidenceChainHealth[]): string {
+  const broken = chains.filter((c) => !c.ok);
+  if (broken.length === 0) return 'evidence chain: verified';
+  const live = broken.filter((c) => c.defectsInRun > 0);
+  if (live.length === 0) {
+    const runs = broken.reduce((n, c) => n + c.runRecords, 0);
+    const defects = broken.reduce((n, c) => n + c.defects, 0);
+    return `evidence chain: damaged EARLIER — ${defects} defect(s), none inside the current run of `
+      + `${runs} unbroken record(s); the numbers above stand, the file's history does not`;
+  }
+  const inRun = live.reduce((n, c) => n + c.defectsInRun, 0);
+  return `evidence chain: CORRUPT — ${inRun} defect(s) INSIDE the current run; the numbers above are `
+    + 'computed from a damaged log';
+}
+
+/**
+ * The verdict phrase for one evidence log, with its WINDOW named. A bare `FAILED` over damage that an
+ * unbroken run has already followed is true of the FILE and misleading about TODAY — see
+ * {@link EvidenceChainHealth.defectsBeforeRun}.
+ */
+export function chainVerdictPhrase(c: EvidenceChainHealth): string {
+  if (c.ok) return 'verified';
+  const kinds = `[${c.defectKinds.join(', ')}]`;
+  if (c.defectsInRun === 0) {
+    return `DAMAGED EARLIER — ${c.defects} defect(s) ${kinds}, all BEFORE the current run of `
+      + `${c.runRecords} unbroken record(s); numbers over that run stand, the file's history does not`;
+  }
+  if (c.defectsBeforeRun === 0) {
+    return `FAILED — ${c.defects} defect(s) ${kinds} with NO sound records after them`;
+  }
+  return `FAILED — ${c.defects} defect(s) ${kinds}: ${c.defectsInRun} inside the current run of `
+    + `${c.runRecords} record(s), ${c.defectsBeforeRun} before it`;
+}
+
 export function renderCompoundingReport(r: CompoundingReport): string {
   const out: string[] = [];
   out.push('dz compounding — does the learning loop pay? (honest report: gates without data say so)');
@@ -695,7 +800,7 @@ export function renderCompoundingReport(r: CompoundingReport): string {
   );
   for (const c of r.instrumentation.chains) {
     out.push(
-      `  EVIDENCE CHAIN ${c.log}: ${c.ok ? 'verified' : `FAILED — ${c.defects} defect(s) [${c.defectKinds.join(', ')}]`}` +
+      `  EVIDENCE CHAIN ${c.log}: ${chainVerdictPhrase(c)}` +
         ` · ${c.chained} chained · ${c.preChainPrefix} pre-chain (uncovered)`,
     );
   }
@@ -722,3 +827,132 @@ export function renderCompoundingReport(r: CompoundingReport): string {
   out.push(`  VERDICT: ${r.verdict}`);
   return out.join('\n');
 }
+
+// ── Доведённая работа: дополнительная метрика, не влияющая на отбор ──
+
+export interface LessonOutcomeRow {
+  readonly lessons?: readonly string[];
+  readonly outcome?: string;
+  readonly grade?: string | null;
+  readonly slug?: string;
+  readonly stage?: string;
+}
+
+export interface LessonOutcomeCounters {
+  pairs: number;
+  shipped: number;
+  refuted: number;
+  blocked: number;
+  other: number;
+  graded: number;
+  grades: Record<string, number>;
+}
+
+export interface LessonOutcomeCoverage {
+  readonly lessonsWithOutcome: number;
+  readonly pairsTotal: number;
+  readonly pairsUngraded: number;
+  readonly duplicateRowsDropped: number;
+}
+
+export interface JoinedLessonOutcomes {
+  readonly perLesson: ReadonlyMap<string, LessonOutcomeCounters>;
+  readonly totals: LessonOutcomeCounters;
+  readonly coverage: LessonOutcomeCoverage;
+}
+
+function emptyLessonOutcomeCounters(): LessonOutcomeCounters {
+  return {
+    pairs: 0, shipped: 0, refuted: 0, blocked: 0, other: 0, graded: 0,
+    grades: Object.create(null) as Record<string, number>,
+  };
+}
+
+/**
+ * Считает пары «урок ↔ исход работы» из уже прочитанных строк леджера.
+ * unknown допускает мусор после разбора JSON; поля проверяются перед использованием.
+ * Неизвестный или отсутствующий исход попадает в other, пустой грейд — в пары без грейда.
+ * Буквы грейдов сохраняются как категории, без перевода в единый балл пользы.
+ * Полные JSON-дубликаты строк и повторные id внутри одной строки не умножают пары.
+ */
+export function joinLessonOutcomes(rows: readonly unknown[]): JoinedLessonOutcomes {
+  const perLesson = new Map<string, LessonOutcomeCounters>();
+  const totals = emptyLessonOutcomeCounters();
+  const seenRows = new Set<string>();
+  let duplicateRowsDropped = 0;
+  for (const value of rows) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) continue;
+    const row = value as LessonOutcomeRow;
+    if (!Array.isArray(row.lessons)) continue;
+    // Compare ALL fields; object key order is irrelevant, array order is preserved.
+    const canonicalRow = JSON.stringify(value, (_key, part: unknown) => {
+      if (part === null || typeof part !== 'object' || Array.isArray(part)) return part;
+      const object = part as Record<string, unknown>;
+      return Object.fromEntries(Object.keys(object).sort().map((key) => [key, object[key]]));
+    });
+    if (seenRows.has(canonicalRow)) {
+      duplicateRowsDropped++;
+      continue;
+    }
+    seenRows.add(canonicalRow);
+    const outcome = row.outcome === 'shipped' || row.outcome === 'refuted' || row.outcome === 'blocked'
+      ? row.outcome : 'other';
+    const grade = typeof row.grade === 'string' ? row.grade.trim() : '';
+    for (const dzId of new Set(row.lessons)) {
+      if (typeof dzId !== 'string' || !dzId.startsWith('teach:')) continue;
+      const counts = perLesson.get(dzId) ?? emptyLessonOutcomeCounters();
+      perLesson.set(dzId, counts);
+      for (const target of [counts, totals]) {
+        target.pairs++;
+        target[outcome]++;
+        if (grade !== '') {
+          target.graded++;
+          target.grades[grade] = (target.grades[grade] ?? 0) + 1;
+        }
+      }
+    }
+  }
+  return {
+    perLesson,
+    totals,
+    coverage: {
+      lessonsWithOutcome: perLesson.size,
+      pairsTotal: totals.pairs,
+      pairsUngraded: totals.pairs - totals.graded,
+      duplicateRowsDropped,
+    },
+  };
+}
+
+/**
+ * Размер стора передаёт вызывающий код: в строках леджера этого знаменателя нет.
+ * Для доли покрытия набор joined должен относиться к урокам этого стора.
+ * Без знаменателя доля остаётся неизвестной, а не превращается в 100%.
+ */
+export function renderLessonOutcomes(joined: JoinedLessonOutcomes, storeLessonCount?: number): string {
+  const { totals, coverage } = joined;
+  const percent = (part: number, whole: number): string =>
+    `${(whole === 0 ? 0 : part / whole * 100).toFixed(1).replace('.', ',')}%`;
+  const validStoreCount = typeof storeLessonCount === 'number'
+    && Number.isSafeInteger(storeLessonCount)
+    && storeLessonCount >= coverage.lessonsWithOutcome;
+  const storeCoverage = validStoreCount
+    ? `${coverage.lessonsWithOutcome}/${storeLessonCount} (${percent(coverage.lessonsWithOutcome, storeLessonCount)})`
+    : `${coverage.lessonsWithOutcome}/неизвестно (доля неизвестна: размер стора не задан или некорректен)`;
+  const grades = Object.entries(totals.grades)
+    .sort(([a], [b]) => a.localeCompare(b, 'ru'))
+    .map(([grade, count]) => `${grade}: ${count}`)
+    .join(', ');
+  return [
+    'ДОВЕДЁННАЯ РАБОТА — дополнительная метрика пользы уроков',
+    `  Пар «урок ↔ исход работы»: ${totals.pairs}; доведено (shipped): ${totals.shipped}; `
+      + `опровергнуто (refuted): ${totals.refuted}; заблокировано (blocked): ${totals.blocked}; прочие исходы: ${totals.other}.`,
+    `  Грейды (${totals.graded} пар): ${grades || 'нет'}; самоотчёт — грейд ставит ведущий при закрытии круга, это не независимая оценка.`,
+    `  Доля пар без грейда: ${coverage.pairsUngraded}/${coverage.pairsTotal} (${percent(coverage.pairsUngraded, coverage.pairsTotal)}).`,
+    `  Покрытие уроков стора хотя бы одной парой: ${storeCoverage}.`,
+    ...(coverage.duplicateRowsDropped > 0
+      ? [`  Отброшено дубликатов строк леджера: ${coverage.duplicateRowsDropped}.`]
+      : []),
+    '  Отбор уроков по-прежнему использует оценку намерения.',
+  ].join('\n');
+}

package/src/discrimination-gate.ts

@@ -394,9 +394,6 @@ export interface DiscriminationResult {
   /** compat scalar: worst-of via RANK. A total order can only answer "worst thing present" —
    *  everything it destroys travels in findings[] / measurementValid / primaryAction. */
   readonly aggregate: DiscriminationVerdict;
-  /** @deprecated compat alias for ONE release — always `findings[0] ?? null` (worst first).
-   *  Removal in the next minor is a recorded release obligation (ADR-002 Decision item 6). */
-  readonly finding: DiscriminationFinding | null;
   /** one per distinct non-clean verdict present, worst-first. */
   readonly findings: readonly DiscriminationFinding[];
   readonly measurementValid: MeasurementValid;
@@ -821,7 +818,7 @@ export function classifyDiscrimination(input: ClassifyInput): DiscriminationResu
       detail:
         'No test was mapped to the ADR safety property, so discrimination could not be evaluated — this is the existing "property untested" finding. Action: map-a-test.',
     };
-    return { perTest: [], aggregate: 'CANNOT_ISOLATE', finding, findings: [finding], measurementValid: false, primaryAction: 'map-a-test' };
+    return { perTest: [], aggregate: 'CANNOT_ISOLATE', findings: [finding], measurementValid: false, primaryAction: 'map-a-test' };
   }
 
   let missingRow = false;
@@ -876,5 +873,5 @@ export function classifyDiscrimination(input: ClassifyInput): DiscriminationResu
   const primaryAction: PrimaryAction =
     aggregate === 'CANNOT_ISOLATE' && missingRow ? 'map-a-test' : ACTION_OF[aggregate];
 
-  return { perTest, aggregate, finding: findings[0] ?? null, findings, measurementValid, primaryAction };
+  return { perTest, aggregate, findings, measurementValid, primaryAction };
 }

package/src/doctor-instrument.ts

@@ -0,0 +1,153 @@
+import { isAbsolute, relative, sep } from 'node:path';
+
+export type InstrumentFreshness = 'same' | 'stale' | 'unknown';
+
+export interface InstrumentCheckInput {
+  /** realpath of the running binary, or null when it could not be resolved. */
+  readonly binPath: string | null;
+  /** version from the package.json that owns binPath, or null. */
+  readonly binVersion: string | null;
+  /** version from packages/@dzhechkov/harness-cli/package.json, or null outside the monorepo. */
+  readonly treeVersion: string | null;
+  /** absolute, realpath'd project root. */
+  readonly projectRoot: string;
+  /**
+   * Whether `projectRoot` above really IS realpath'd. The caller resolves it and falls back to a
+   * plain resolve when that throws; with a symlinked root that fallback compares a realpath'd
+   * binary against a non-realpath'd root, and an IN-TREE binary then looks external. Containment is
+   * undecidable in that state, so it is answered `unknown` rather than guessed either way.
+   * Named by independent review (Claude Sonnet, 2026-09-20).
+   */
+  readonly projectRootRealpathed: boolean;
+  readonly isMonorepo: boolean;
+}
+
+/**
+ * `level` is the WHOLE verdict — the caller renders it and never re-derives one of its own. That is
+ * deliberate: the first wiring of this module answered `unknown` with `ok: false` while this decider
+ * answered `ok`, and two answers to one question is the defect class this repo pays for most often.
+ *
+ * Three values, because two would lie: `ok` (the instrument is the tree's, or the check does not
+ * apply here), `warn` (measured stale — worth saying loudly, never worth failing a health command
+ * that gates other people's CI), `unknown` (the evidence could not be gathered — never rendered as
+ * a pass, and never as a failure either, since absence of evidence is not a defect).
+ */
+export interface InstrumentCheckResult {
+  readonly freshness: InstrumentFreshness;
+  readonly level: 'ok' | 'warn' | 'unknown';
+  readonly detail: string;
+}
+
+export interface RankingStateCheckInput {
+  readonly flagOn: boolean;
+  /** absolute path the state was looked for at. */
+  readonly statePath: string;
+  readonly stateExists: boolean;
+  /** resolved binary path, for the detail — null when unknown. */
+  readonly binPath: string | null;
+}
+
+/** Ranking state has no freshness concept, so it deliberately has its own result type. */
+export interface RankingStateCheckResult {
+  readonly level: 'ok' | 'warn';
+  readonly detail: string;
+}
+
+/** Strip semver build metadata: `0.8.32+a1b2c3` and `0.8.32` are the same release. */
+function withoutBuildMetadata(version: string): string {
+  const plus = version.indexOf('+');
+  return plus < 0 ? version : version.slice(0, plus);
+}
+
+function isInsideRoot(candidate: string, root: string): boolean {
+  const fromRoot = relative(root, candidate);
+  return fromRoot === '' || (!isAbsolute(fromRoot) && fromRoot !== '..' && !fromRoot.startsWith(`..${sep}`));
+}
+
+/**
+ * Decide whether the executable answering `dz doctor` is the workspace's current instrument.
+ *
+ * LIMITS NAMED BY INDEPENDENT REVIEW (Claude Sonnet, 2026-09-20), none of them hidden behind a
+ * passing test:
+ *  - Containment is a case-SENSITIVE path comparison. On a case-insensitive filesystem, or where the
+ *    same location is reachable under two path forms, an in-tree binary can read as external. This
+ *    repo runs on Linux; the cost of being wrong is one extra `warn` line and never an exit code.
+ *  - The caller attributes a version by walking up from the binary to the NEAREST `package.json`.
+ *    A shim in package A that loads package B's code is attributed to A, and a broken install with
+ *    no own manifest is attributed to whatever ancestor has one. The detail always prints the
+ *    resolved binary path so a reader can see which file was actually measured.
+ */
+export function checkInstrumentFreshness(input: InstrumentCheckInput): InstrumentCheckResult {
+  const binary = input.binPath ?? '(unresolved)';
+  const binaryVersion = input.binVersion ?? 'unknown';
+  const treeVersion = input.treeVersion ?? 'unknown';
+
+  if (!input.isMonorepo) {
+    return {
+      freshness: 'unknown',
+      level: 'ok',
+      detail: `not applicable in a consumer project: no packages/@dzhechkov tree version to compare; resolved binary ${binary}; binary version ${binaryVersion}; tree version ${treeVersion}`,
+    };
+  }
+
+  if (input.binPath !== null && input.projectRootRealpathed && isInsideRoot(input.binPath, input.projectRoot)) {
+    return {
+      freshness: 'same',
+      level: 'ok',
+      detail: `resolved binary ${input.binPath} is inside project root ${input.projectRoot}; binary version ${binaryVersion}; tree version ${treeVersion}; this binary is the tree instrument`,
+    };
+  }
+
+  if (!input.projectRootRealpathed) {
+    return {
+      freshness: 'unknown',
+      level: 'unknown',
+      detail: `project root ${input.projectRoot} could not be resolved through its symlinks, so it cannot be told whether the answering binary is the tree's own; version could not be determined safely; resolved binary ${binary}; binary version ${binaryVersion}; tree version ${treeVersion}`,
+    };
+  }
+
+  if (input.binPath === null || input.binVersion === null || input.treeVersion === null) {
+    return {
+      freshness: 'unknown',
+      level: 'unknown',
+      detail: `instrument version could not be determined; resolved binary ${binary}; binary version ${binaryVersion}; tree version ${treeVersion}`,
+    };
+  }
+
+  // Semver says build metadata after `+` does not participate in equality, so a pipeline that
+  // stamps a commit hash onto the version must not read as a stale instrument.
+  if (withoutBuildMetadata(input.binVersion) === withoutBuildMetadata(input.treeVersion)) {
+    return {
+      freshness: 'same',
+      level: 'ok',
+      detail: `resolved binary ${input.binPath}; binary version ${input.binVersion}; tree version ${input.treeVersion}; versions match`,
+    };
+  }
+
+  return {
+    freshness: 'stale',
+    level: 'warn',
+    detail: `resolved binary ${input.binPath}; binary version ${input.binVersion}; tree version ${input.treeVersion}; the answering instrument is stale`,
+  };
+}
+
+/** Decide whether enabled bandit re-ranking has the on-disk state needed to operate. */
+export function checkRankingState(input: RankingStateCheckInput): RankingStateCheckResult {
+  const binary = input.binPath ?? '(unresolved)';
+  if (!input.flagOn) {
+    return {
+      level: 'ok',
+      detail: `bandit re-ranking feature is off; no state is expected at ${input.statePath}; answering binary ${binary}`,
+    };
+  }
+  if (input.stateExists) {
+    return {
+      level: 'ok',
+      detail: `bandit re-ranking is on and state is present at ${input.statePath}; answering binary ${binary}`,
+    };
+  }
+  return {
+    level: 'warn',
+    detail: `bandit re-ranking is on but state is absent at ${input.statePath}; answering binary ${binary}`,
+  };
+}

package/src/feature-tier.ts

@@ -1,7 +1,20 @@
 import type { FeatureTier } from './guard-volume.js';
 
+/**
+ * Начало строки, на котором тир ещё считается ОБЪЯВЛЕННЫМ, а не упомянутым в прозе: необязательный
+ * маркер списка (`-`, `*`, `+`, `1.`), необязательный заголовок и необязательное выделение.
+ *
+ * Маркер списка добавлен 2026-09-21 по измерению: `00_complexity_assessment.md` фичи
+ * `amendment-seams` несёт строку `- **Tier: S** — …`, и парсер её НЕ видел. Следствие было не
+ * косметическим: `dz contract-check --slug amendment-seams` отвечал NOT-ESTABLISHED с диагнозом
+ * «required ADR directory cannot be resolved», хотя в самом приборе есть верная ветка «тиру S
+ * каталог ADR не требуется» — она просто никогда не исполнялась, потому что тир читался как
+ * неизвестный. То есть вердикт называл не ту причину и отправлял чинить не то (бэклог 5d436aa6).
+ */
+const TIER_LINE_START = /^\s*(?:[-*+]\s+|\d+[.)]\s+)?(?:##+\s*)?(?:\*\*)?(?:Tier|Тир)(?=$|[\s:*])/iu;
+
 function tiersAfterMarkers(line: string): FeatureTier[] {
-  if (!/^\s*(?:##\s*)?(?:\*\*)?(?:Tier|Тир)(?=$|[\s:*])/iu.test(line)) return [];
+  if (!TIER_LINE_START.test(line)) return [];
   const tiers: FeatureTier[] = [];
   for (const marker of line.matchAll(/Tier|Тир/giu)) {
     const markerIndex = marker.index ?? 0;