@dzhechkov/harness-core 0.8.11 → 0.8.21

package/dist/statusline.d.ts

@@ -13,6 +13,7 @@
  *
  * @packageDocumentation
  */
+import { type StoreHealthVerdict } from './store-guard.js';
 /**
  * Live learning state for one in-flight `/feature-adr` run — the per-run visibility panel
  * that surfaces the Pattern memory loop (POOL learned, RECALLED for this run, STORED this run).
@@ -36,13 +37,31 @@ export interface FeatureAdrState {
     readonly reinforced?: number;
     /** ISO timestamp of the write — drives the freshness window on the render path. */
     readonly ts: string;
+    /** Identity of one pipeline invocation. The monotonic guard never crosses two distinct runs. */
+    readonly runId?: string;
     /** Optional run mode (e.g. "reference", "full-qe", "full-qe-extended"). */
     readonly mode?: string;
+    /** Complexity tier of the run (S/M/L/XL) — drives done/total on the phase line. Carried forward
+     *  by the write path when a later record omits it. */
+    readonly tier?: string;
+    /** ISO timestamp of the CURRENT phase's start — reset by the write path when the step label
+     *  changes, carried forward while it stays the same. Drives the phase line's elapsed minutes. */
+    readonly phaseStartTs?: string;
 }
 /** A snapshot of dz's self-learning state for one project (all fields best-effort). */
 export interface StatuslineData {
     /** Count of learned patterns in the project's unified memory store. */
     readonly patterns: number;
+    /** Exact lexical-tier availability split; omitted when the enhanced readonly count cannot be established. */
+    readonly patternBreakdown?: {
+        readonly source: 'lexical';
+        readonly active: number;
+        readonly quarantined: number;
+        /** True once quarantine contains at least one third of the lexical pool. */
+        readonly attention: boolean;
+        /** Absolute lexical/vector quarantine-label delta, present only above the tolerated drift threshold. */
+        readonly tierDelta?: number;
+    };
     /** Count of learned patterns that the live recall hook has actually injected at least once. */
     readonly usedPatterns?: number;
     /** Number of sources registered in the durable cross-project knowledge brain. */
@@ -51,6 +70,18 @@ export interface StatuslineData {
     readonly consolidatedAgeH?: number;
     /** Live `/feature-adr` learning state — present ONLY when a fresh run is in flight. */
     readonly featureAdr?: FeatureAdrState;
+    /** Persistent owner-facing store warning; healthy/no-mark/error paths omit it. */
+    readonly storeHealth?: StatuslineStoreHealth;
+}
+/** Render-ready details for a non-healthy store verdict. */
+export interface StatuslineStoreHealth {
+    readonly verdict: Exclude<StoreHealthVerdict, 'ok' | 'no-mark'>;
+    /** Previous maximum for the affected store tier. */
+    readonly previousMax?: number;
+    /** Snapshot directory used by cold-start recovery guidance. */
+    readonly snapshotPath?: string;
+    /** Basenames of store files whose readonly count failed. */
+    readonly unreadableFiles?: readonly string[];
 }
 /** Directory of the per-slug live `/feature-adr` learning-state slots. */
 export declare function featureAdrStateDir(projectRoot: string): string;
@@ -82,6 +113,44 @@ export interface WriteFeatureAdrStateInput {
     readonly stored: number;
     readonly reinforced?: number;
     readonly mode?: string;
+    /** Identity of one pipeline invocation. Empty strings are not identities. */
+    readonly runId?: string;
+    /** Complexity tier (S/M/L/XL). Invalid/absent → the previous slot's tier is carried forward. */
+    readonly tier?: string;
+    /**
+     * TEST-ONLY seam (ADR-002 C2 RED half): run the slot transaction WITHOUT the
+     * `fa-phase-slot` named lock, so `statusline-phase-lock.test.ts` can reproduce the lost update
+     * the lock prevents. Never set by any shipped caller — `statusline-phase-lock.test.ts` asserts
+     * `grep -c _unsafeSkipLock` on the CLI source is 0, so this cannot be reached from `dz`.
+     */
+    readonly _unsafeSkipLock?: boolean;
+    /**
+     * TEST-ONLY seam, the twin of `_unsafeSkipLock`: busy-hold this many ms INSIDE the transition,
+     * between reading the previous slot and writing the new one. Without it the read-modify-write
+     * window is sub-millisecond and the RED half would be reproducing a race by LUCK — a flaky test
+     * is not a proof. With it the interleaving is deterministic in both halves: unlocked, two writers
+     * provably observe the same previous slot; locked, they provably do not. Never set by any shipped
+     * caller (same grep assertion as `_unsafeSkipLock`).
+     */
+    readonly _unsafeHoldMs?: number;
+    /**
+     * TEST-ONLY seam: fail after phase telemetry has been appended but before the slot is written.
+     * This makes the partial-write receipt deterministic without fabricating a phase row from a
+     * missing previous slot. Never set by a shipped caller.
+     */
+    readonly _unsafeFailSlotWrite?: boolean;
+}
+/**
+ * The outcome of a slot write. `state` is the slot as written; `refused` is a SHORT machine-ish
+ * reason when the operation did not complete. `refusedEffect` says whether no disk effect is known
+ * (`none`, callback never began) or a partial effect is possible (`unknown`, callback began).
+ * Exactly one of `state` and `refused` is present. The CLI prints `refused` on stderr.
+ */
+export interface WriteFeatureAdrStateResult {
+    readonly state?: FeatureAdrState;
+    readonly refused?: string;
+    /** Known disk effect of a refusal: `none` before the transaction, `unknown` once it began. */
+    readonly refusedEffect?: 'none' | 'unknown';
 }
 /**
  * Record the live `/feature-adr` learning state — called by the pipeline at Steps 0/8/9. Computes
@@ -92,6 +161,13 @@ export interface WriteFeatureAdrStateInput {
  * @param now Injectable clock (epoch ms) for the write timestamp — defaults to `Date.now()`.
  */
 export declare function writeFeatureAdrState(projectRoot: string, input: WriteFeatureAdrStateInput, now?: number): FeatureAdrState | undefined;
+/**
+ * The same write as {@link writeFeatureAdrState}, but it SAYS WHY it did not complete and what is
+ * known about its disk effect. A refusal before the transition returns `refusedEffect:'none'`; once
+ * the callback begins, a refusal returns `refusedEffect:'unknown'` because an append or slot write
+ * may already have landed. The pipeline still never breaks — the caller decides, this never throws.
+ */
+export declare function writeFeatureAdrStateDetailed(projectRoot: string, input: WriteFeatureAdrStateInput, now?: number): WriteFeatureAdrStateResult;
 /**
  * Gather dz's self-learning counts for one project. FAST + best-effort: every read
  * is guarded so a missing/corrupt `.dz`, absent native module, or locked store
@@ -101,4 +177,27 @@ export declare function writeFeatureAdrState(projectRoot: string, input: WriteFe
  * @param now Injectable clock (epoch ms) for the consolidation age — defaults to `Date.now()`.
  */
 export declare function statuslineData(projectRoot: string, now?: number): StatuslineData;
+/**
+ * Render the /feature-adr PHASE line (line format B, fa-phase-statusline ADR-001) — the second
+ * status-bar line:
+ *
+ *   `📐 <slug> [<tier>] <done>/<total> ▶ <step label> · <N>м/—`
+ *
+ * States, in precedence order:
+ * - `undefined` (no line): a loop slot, the terminal label `done`, or ≥90 min of slot silence;
+ * - `⚠ <N>м без отчёта` from 30 min of slot silence (counted from the last report `ts`);
+ * - a label starting `⛔` or `⏸` replaces the `▶ <label>` portion VERBATIM (failure/waiting states
+ *   are reported by the pipeline through the label itself, never synthesised here);
+ * - otherwise `▶ <label>` with elapsed minutes counted from the PHASE start (`phaseStartTs`).
+ *
+ * done/total is the label's step-number position in its tier's active-step list; an unknown tier,
+ * an unparseable label, or a number outside the list renders `?/?` — the panel never guesses.
+ * The estimate slot is fixed-width at the tail: v1 defers estimates entirely, so it is always `/—`
+ * (a future median would be computed on the WRITE path and stored in the slot as a ready number —
+ * this render path stays a pure function over the slot, no DB, no subprocess, no features/* sweep).
+ *
+ * @param state A fresh slot from {@link readFeatureAdrState} (the ONLY source of "in progress").
+ * @param now Injectable clock (epoch ms) — defaults to `Date.now()`.
+ */
+export declare function renderFeatureAdrPhaseLine(state: FeatureAdrState, now?: number): string | undefined;
 //# sourceMappingURL=statusline.d.ts.map

package/dist/statusline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"statusline.d.ts","sourceRoot":"","sources":["../src/statusline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,gGAAgG;IAChG,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC;IACvC,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wFAAwF;IACxF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,gEAAgE;IAChE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,gGAAgG;IAChG,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,mFAAmF;IACnF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,uFAAuF;AACvF,MAAM,WAAW,cAAc;IAC7B,uEAAuE;IACvE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,+FAA+F;IAC/F,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,uFAAuF;IACvF,QAAQ,CAAC,UAAU,CAAC,EAAE,eAAe,CAAC;CACvC;AAYD,0EAA0E;AAC1E,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE9D;AAYD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAI9E;AA8FD;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,GAAE,MAAmB,GAAG,eAAe,GAAG,SAAS,CA0E9G;AAED,0FAA0F;AAC1F,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,yBAAyB,EAChC,GAAG,GAAE,MAAmB,GACvB,eAAe,GAAG,SAAS,CA0C7B;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,GAAE,MAAmB,GAAG,cAAc,CAyC5F"}
+{"version":3,"file":"statusline.d.ts","sourceRoot":"","sources":["../src/statusline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAUH,OAAO,EAIL,KAAK,kBAAkB,EACxB,MAAM,kBAAkB,CAAC;AAE1B;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,gGAAgG;IAChG,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC;IACvC,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wFAAwF;IACxF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,gEAAgE;IAChE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,gGAAgG;IAChG,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,mFAAmF;IACnF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,gGAAgG;IAChG,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;0DACsD;IACtD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;qGACiG;IACjG,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,uFAAuF;AACvF,MAAM,WAAW,cAAc;IAC7B,uEAAuE;IACvE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,6GAA6G;IAC7G,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;QAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;QAC7B,4EAA4E;QAC5E,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;QAC5B,wGAAwG;QACxG,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;KAC7B,CAAC;IACF,+FAA+F;IAC/F,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,uFAAuF;IACvF,QAAQ,CAAC,UAAU,CAAC,EAAE,eAAe,CAAC;IACtC,kFAAkF;IAClF,QAAQ,CAAC,WAAW,CAAC,EAAE,qBAAqB,CAAC;CAC9C;AAED,4DAA4D;AAC5D,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,kBAAkB,EAAE,IAAI,GAAG,SAAS,CAAC,CAAC;IAChE,oDAAoD;IACpD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,+DAA+D;IAC/D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,4DAA4D;IAC5D,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C;AAcD,0EAA0E;AAC1E,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE9D;AAYD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAI9E;AAwFD;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,GAAE,MAAmB,GAAG,eAAe,GAAG,SAAS,CA+E9G;AAED,0FAA0F;AAC1F,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,gGAAgG;IAChG,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC;;;;OAIG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;CACzC;AAED;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,8FAA8F;IAC9F,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7C;AAsDD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,yBAAyB,EAChC,GAAG,GAAE,MAAmB,GACvB,eAAe,GAAG,SAAS,CAE7B;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,yBAAyB,EAChC,GAAG,GAAE,MAAmB,GACvB,0BAA0B,CAwH5B;AAQD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,GAAE,MAAmB,GAAG,cAAc,CAgH5F;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,GAAE,MAAmB,GAAG,MAAM,GAAG,SAAS,CAyB9G"}

package/dist/statusline.js

@@ -13,11 +13,15 @@
  *
  * @packageDocumentation
  */
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
 import { createRequire } from 'node:module';
 import { listBrain } from './brain.js';
+import { withNamedLockSync } from './named-lock.js';
 import { RECALL_USAGE_LOG_RELATIVE, aggregateRecallUsage, parseRecallUsageLog } from './recall-usage.js';
+import { countLearningStoreRowsReadonly, countSqliteRowsReadonly } from './store-counts.js';
+import { checkStoreHealth, readStoreMark, storeSnapshotPath, } from './store-guard.js';
+const QUARANTINE_TIER_DRIFT_TOLERANCE = 5;
 /** Path of the SQLite pattern store (the Tier-3 backend). */
 function sqlitePatternPath(projectRoot) {
     return join(projectRoot, '.dz', 'memory', 'patterns.sqlite');
@@ -50,33 +54,29 @@ export function featureAdrStatePath(projectRoot, slug) {
 }
 /**
  * Freshness window for the `/feature-adr` panel: a run older than this is considered finished, so
- * its state must NOT keep showing a stale panel in the status bar. 30 minutes (in ms).
+ * its state must NOT keep showing a stale panel in the status bar. 90 minutes (in ms).
+ *
+ * fa-phase-statusline (ADR-001 D4): extended 30→90 min as an EXPLICIT behaviour change so the phase
+ * line can fade in stages — the renderer shows `⚠ <N>м без отчёта` from 30 min of slot silence and
+ * nothing at all from 90. One window for the reader; the staging lives in
+ * {@link renderFeatureAdrPhaseLine}.
  */
-const FEATURE_ADR_FRESH_MS = 30 * 60 * 1_000;
+const FEATURE_ADR_FRESH_MS = 90 * 60 * 1_000;
+/** Slot silence (ms) after which the phase line renders `⚠ <N>м без отчёта` instead of progress. */
+const FEATURE_ADR_WARN_MS = 30 * 60 * 1_000;
+/** Valid complexity tiers for the phase line — anything else renders as `[?]` with `?/?`. */
+const FEATURE_ADR_TIERS = new Set(['S', 'M', 'L', 'XL']);
 /**
- * Count learned patterns via a direct **readonly** `COUNT(*)` with a short
- * `busy_timeout` — no FTS rebuild, no schema write, no waiting on a live writer.
- * Returns `undefined` (not `0`) when the fast path is unavailable so the caller
- * can fall back to a readonly jsonl line-count; any error → `undefined`.
+ * Active-step lists per tier (mirrors the Step-0 router bands in the /feature-adr SKILL):
+ * done/total on the phase line is the label's step-number POSITION in its tier's list. A label
+ * whose number is not in the list renders `?/?` — the panel never guesses progress.
  */
-function countSqlitePatternsReadonly(sqlitePath) {
-    try {
-        const require = createRequire(import.meta.url);
-        const Database = require('better-sqlite3');
-        const db = new Database(sqlitePath, { readonly: true });
-        try {
-            db.pragma('busy_timeout = 100'); // back off fast — never block the 300ms refresh on a write lock
-            const row = db.prepare('SELECT COUNT(*) as cnt FROM memory_records').get();
-            return typeof row?.cnt === 'number' ? row.cnt : undefined;
-        }
-        finally {
-            db.close();
-        }
-    }
-    catch {
-        return undefined;
-    }
-}
+const FEATURE_ADR_ACTIVE_STEPS = {
+    S: [0, 1, 6, 7, 8],
+    M: [0, 1, 3, 3.5, 5, 6, 7, 8],
+    L: [0, 1, 2, 3, 3.5, 4, 5, 6, 7, 8, 9],
+    XL: [0, 1, 2, 3, 3.5, 4, 5, 6, 7, 8, 9],
+};
 /**
  * Count the legacy/default `.dz/patterns.jsonl` store by reading the FILE directly — READONLY, no
  * backend open, no FTS rebuild, no schema write. Used only when the SQLite readonly COUNT is
@@ -103,7 +103,7 @@ function countJsonlPatternsReadonly(projectRoot) {
 function countLearnedPatterns(projectRoot) {
     const sqlitePath = sqlitePatternPath(projectRoot);
     if (existsSync(sqlitePath)) {
-        const fast = countSqlitePatternsReadonly(sqlitePath);
+        const fast = countSqliteRowsReadonly(sqlitePath, 'memory_records');
         if (fast !== undefined)
             return fast;
     }
@@ -193,6 +193,8 @@ export function readFeatureAdrState(projectRoot, now = Date.now()) {
                 return undefined;
             if (typeof parsed.step !== 'string' || parsed.step.length === 0)
                 return undefined;
+            if (parsed.step.trim() === 'done')
+                return undefined; // terminal slots never enter arbitration
             if (typeof parsed.ts !== 'string')
                 return undefined;
             const tsMs = Date.parse(parsed.ts);
@@ -215,7 +217,11 @@ export function readFeatureAdrState(projectRoot, now = Date.now()) {
                 stored: num(parsed.stored),
                 ...(num(parsed.reinforced) > 0 ? { reinforced: num(parsed.reinforced) } : {}),
                 ts: parsed.ts,
+                ...(typeof parsed.runId === 'string' && parsed.runId.trim() !== '' ? { runId: parsed.runId } : {}),
                 ...(typeof parsed.mode === 'string' && parsed.mode.length > 0 ? { mode: parsed.mode } : {}),
+                ...(typeof parsed.tier === 'string' && FEATURE_ADR_TIERS.has(parsed.tier) ? { tier: parsed.tier } : {}),
+                ...(typeof parsed.phaseStartTs === 'string' && !Number.isNaN(Date.parse(parsed.phaseStartTs))
+                    ? { phaseStartTs: parsed.phaseStartTs } : {}),
             };
             return { state, tsMs, rank: kind === 'feature-adr' ? 1 : 0 };
         }
@@ -236,6 +242,56 @@ export function readFeatureAdrState(projectRoot, now = Date.now()) {
     }
     return winner?.state;
 }
+/**
+ * Read ONE slot file raw (no freshness window, no arbitration) — the write path's "previous state".
+ * Best-effort: absent/corrupt → `undefined`.
+ */
+function readPreviousSlot(root, slug) {
+    try {
+        const parsed = JSON.parse(readFileSync(featureAdrStatePath(root, slug), 'utf-8'));
+        if (typeof parsed.step !== 'string' || typeof parsed.ts !== 'string')
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * fa-phase-statusline (ADR-001 D3): when a step label CHANGES, the phase that just ended leaves one
+ * telemetry row in the EXISTING `.dz/feature-adr/run-cost-ledger.jsonl`:
+ * `{"_schema":"feature-adr-phase/1","kind":"phase",slug,tier,mode,step,wallSec,ts}`.
+ * DELIBERATE field choices, both load-bearing:
+ * - `ts`, never `date` — cadence.ts skips ledger rows without a string `date`, so shipment dating
+ *   is untouched by construction (pinned in cadence.test.ts);
+ * - `wallSec` (wall seconds of the ended phase), never `minutes` — 1-3 minute phases keep resolution.
+ * The ledger is NEVER created here: phase rows enrich the existing witness file, they are not a new
+ * store. Append-only (`appendFileSync`, one line) — not a read-modify-write, so no named lock owed.
+ * Best-effort: any failure is swallowed (the panel write must never break the pipeline).
+ */
+function appendPhaseRow(root, prev, resolved, now) {
+    try {
+        const ledger = join(root, '.dz', 'feature-adr', 'run-cost-ledger.jsonl');
+        if (!existsSync(ledger))
+            return; // append to the EXISTING ledger only — never create one
+        const startedMs = Date.parse(prev.phaseStartTs ?? prev.ts ?? '');
+        if (Number.isNaN(startedMs))
+            return; // an unmeasurable phase leaves no row — never a guess
+        const wallSec = Math.max(0, Math.round((now - startedMs) / 1000));
+        const row = {
+            _schema: 'feature-adr-phase/1',
+            kind: 'phase',
+            slug: resolved.slug,
+            tier: resolved.tier ?? null,
+            mode: prev.mode ?? resolved.mode ?? null,
+            step: prev.step,
+            wallSec,
+            ts: new Date(now).toISOString(),
+        };
+        appendFileSync(ledger, `${JSON.stringify(row)}\n`);
+    }
+    catch { /* best-effort telemetry — never blocks the slot write */ }
+}
 /**
  * Record the live `/feature-adr` learning state — called by the pipeline at Steps 0/8/9. Computes
  * `pool` as the total learned-pattern count (via the same readonly {@link countLearnedPatterns} the
@@ -245,7 +301,17 @@ export function readFeatureAdrState(projectRoot, now = Date.now()) {
  * @param now Injectable clock (epoch ms) for the write timestamp — defaults to `Date.now()`.
  */
 export function writeFeatureAdrState(projectRoot, input, now = Date.now()) {
+    return writeFeatureAdrStateDetailed(projectRoot, input, now).state;
+}
+/**
+ * The same write as {@link writeFeatureAdrState}, but it SAYS WHY it did not complete and what is
+ * known about its disk effect. A refusal before the transition returns `refusedEffect:'none'`; once
+ * the callback begins, a refusal returns `refusedEffect:'unknown'` because an append or slot write
+ * may already have landed. The pipeline still never breaks — the caller decides, this never throws.
+ */
+export function writeFeatureAdrStateDetailed(projectRoot, input, now = Date.now()) {
     const root = resolve(projectRoot);
+    let transactionStarted = false;
     let pool = 0;
     try {
         pool = countLearnedPatterns(root);
@@ -253,22 +319,12 @@ export function writeFeatureAdrState(projectRoot, input, now = Date.now()) {
     catch {
         pool = 0;
     }
-    const state = {
-        kind: input.kind === 'loop' ? 'loop' : 'feature-adr',
-        slug: input.slug,
-        step: input.step,
-        pool,
-        recalled: Number.isFinite(input.recalled) ? input.recalled : 0,
-        stored: Number.isFinite(input.stored) ? input.stored : 0,
-        ...(input.reinforced !== undefined && Number.isFinite(input.reinforced) ? { reinforced: input.reinforced } : {}),
-        ts: new Date(now).toISOString(),
-        ...(input.mode !== undefined && input.mode.length > 0 ? { mode: input.mode } : {}),
-    };
     try {
         const dir = featureAdrStateDir(root);
         mkdirSync(dir, { recursive: true });
         // Housekeeping belongs only on this write path, never the ~300ms render path. Every file is
         // independently guarded so an unreadable/racing entry cannot prevent the live state write.
+        // Kept OUTSIDE the lock below: it is per-file guarded and takes no part in the transition race.
         try {
             const cutoff = Date.now() - 24 * 60 * 60 * 1_000;
             for (const name of readdirSync(dir)) {
@@ -283,13 +339,99 @@ export function writeFeatureAdrState(projectRoot, input, now = Date.now()) {
             }
         }
         catch { /* best-effort directory cleanup */ }
-        const path = featureAdrStatePath(root, input.slug);
-        writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`);
+        // fa-phase-statusline QE fix (P2, cross-family review of 656d6903): read/compare/append/write
+        // is a read-modify-write over a shared slot — two concurrent design-sibling ckpt agents both
+        // read the same previous slot, both see a label change, and both append a phase row, breaking
+        // the one-row-per-transition promise. So the whole transaction runs under the repo's named
+        // per-store lock (cross-runtime-concurrency rule) — a short, fully synchronous critical
+        // section, no subprocess, no model turn. A lock timeout throws → the outer catch refuses the
+        // write (returns undefined): no new claim rather than a raced one.
+        const transition = () => {
+            transactionStarted = true;
+            // ADR-001 D3/D5: the previous slot is the phase clock. Same step label → the phase start
+            // carries forward; a CHANGED label ends the previous phase (one telemetry row) and starts a
+            // new one now. Tier is stored state, carried forward when a record omits it.
+            const prev = readPreviousSlot(root, input.slug);
+            const tier = typeof input.tier === 'string' && FEATURE_ADR_TIERS.has(input.tier)
+                ? input.tier
+                : (typeof prev?.tier === 'string' && FEATURE_ADR_TIERS.has(prev.tier) ? prev.tier : undefined);
+            const nowIso = new Date(now).toISOString();
+            const prevRunId = typeof prev?.runId === 'string' && prev.runId.trim() !== '' ? prev.runId.trim() : undefined;
+            const runId = typeof input.runId === 'string' && input.runId.trim() !== '' ? input.runId.trim() : undefined;
+            const sameRun = prevRunId !== undefined && runId !== undefined && prevRunId === runId;
+            const legacyRunScope = prevRunId === undefined && runId === undefined;
+            const sameRunScope = sameRun || legacyRunScope;
+            // MONOTONIC STEP GUARD (P1, cross-family review of 656d6903): the pipeline's pre-existing
+            // fallback recorder fires AFTER the router checkpoint, so "Step 0 recall" used to overwrite
+            // "Step 1 Design" and the panel deterministically regressed to Step 0 for the whole design
+            // fan (with the design time mis-attributed to Step 0 in telemetry). A plain step label whose
+            // number goes BACKWARDS within the SAME identified invocation is a stale duplicate of an
+            // earlier step: its counters/tier/mode/ts are absorbed, but the step and phase clock stand,
+            // and no phase row is written. Two absent identities retain the legacy fresh-slot behavior.
+            // Distinct identities, a one-sided identity, an explicit gate/waiting label (⛔/⏸), or an
+            // unparseable label never authorizes the guard to cross an unproven run boundary.
+            let step = input.step;
+            const isGateLabel = input.step.trimStart().startsWith('⛔') || input.step.trimStart().startsWith('⏸');
+            if (prev !== undefined && input.kind !== 'loop' && prev.kind !== 'loop' && !isGateLabel) {
+                const prevTsMs = Date.parse(prev.ts ?? '');
+                const prevFresh = !Number.isNaN(prevTsMs) && now - prevTsMs <= FEATURE_ADR_FRESH_MS;
+                const prevNum = parseStepNumber(prev.step ?? '');
+                const newNum = parseStepNumber(input.step);
+                const guardThisRun = sameRun || (legacyRunScope && prevFresh);
+                if (guardThisRun && prevNum !== undefined && newNum !== undefined && newNum < prevNum) {
+                    step = prev.step; // stale duplicate — the run is further along than this record
+                }
+            }
+            // TEST-ONLY hold (see WriteFeatureAdrStateInput._unsafeHoldMs): widens the read→write window
+            // so the lost update is deterministic instead of lucky. Zero cost when unset.
+            if (typeof input._unsafeHoldMs === 'number' && input._unsafeHoldMs > 0) {
+                const until = Date.now() + input._unsafeHoldMs;
+                while (Date.now() < until) { /* deliberate busy hold — test seam only */ }
+            }
+            const samePhase = prev !== undefined && sameRunScope && prev.step === step;
+            const phaseStartTs = samePhase ? (prev.phaseStartTs ?? prev.ts ?? nowIso) : nowIso;
+            // Phase telemetry is a /feature-adr concept — loop slots never leave phase rows in the ledger.
+            if (prev !== undefined && sameRunScope && !samePhase && input.kind !== 'loop' && prev.kind !== 'loop') {
+                appendPhaseRow(root, prev, { slug: input.slug, ...(tier !== undefined ? { tier } : {}), ...(input.mode !== undefined && input.mode.length > 0 ? { mode: input.mode } : {}) }, now);
+            }
+            const state = {
+                kind: input.kind === 'loop' ? 'loop' : 'feature-adr',
+                slug: input.slug,
+                step,
+                pool,
+                recalled: Number.isFinite(input.recalled) ? input.recalled : 0,
+                stored: Number.isFinite(input.stored) ? input.stored : 0,
+                ...(input.reinforced !== undefined && Number.isFinite(input.reinforced) ? { reinforced: input.reinforced } : {}),
+                ts: nowIso,
+                ...(runId !== undefined ? { runId } : {}),
+                ...(input.mode !== undefined && input.mode.length > 0 ? { mode: input.mode } : {}),
+                ...(tier !== undefined ? { tier } : {}),
+                phaseStartTs,
+            };
+            if (input._unsafeFailSlotWrite === true) {
+                throw new Error('test-only slot write failure after phase append');
+            }
+            writeFileSync(featureAdrStatePath(root, input.slug), `${JSON.stringify(state, null, 2)}\n`);
+            return state;
+        };
+        // The seam is TEST-ONLY (see WriteFeatureAdrStateInput._unsafeSkipLock): it exists so the RED
+        // half of the lock test can reproduce the lost update. Shipped callers never pass it.
+        const written = input._unsafeSkipLock === true
+            ? transition()
+            : withNamedLockSync(root, 'fa-phase-slot', transition);
+        return { state: written };
     }
-    catch {
-        return undefined;
+    catch (err) {
+        // A refusal is REPORTED, never mistaken for success. A lock timeout before the callback proves
+        // effect `none`; once the callback began, append/write progress is unknowable after an error.
+        const reason = err instanceof Error && err.message.trim() !== '' ? err.message : String(err);
+        return { refused: reason, refusedEffect: transactionStarted ? 'unknown' : 'none' };
     }
-    return state;
+}
+/** First `Step <n>` number in a label, or `undefined` — shared by the guard and the renderer. */
+function parseStepNumber(label) {
+    const m = /Step\s+(\d+(?:\.\d+)?)/.exec(label);
+    return m !== null ? Number(m[1]) : undefined;
 }
 /**
  * Gather dz's self-learning counts for one project. FAST + best-effort: every read
@@ -302,12 +444,85 @@ export function writeFeatureAdrState(projectRoot, input, now = Date.now()) {
 export function statuslineData(projectRoot, now = Date.now()) {
     const root = resolve(projectRoot);
     let patterns = 0;
+    let storeRows;
     try {
-        patterns = countLearnedPatterns(root);
+        storeRows = countLearningStoreRowsReadonly(root);
+        patterns = typeof storeRows.lexicalRows === 'number'
+            ? storeRows.lexicalRows
+            : countJsonlPatternsReadonly(root);
     }
     catch {
         patterns = 0;
     }
+    let storeHealth;
+    try {
+        if (storeRows === undefined)
+            throw new Error('store row counts unavailable');
+        const rows = storeRows;
+        const mark = readStoreMark(root);
+        const health = checkStoreHealth({
+            projectRoot: root,
+            lexicalRows: rows.lexicalRows,
+            lexicalSource: rows.lexicalSource,
+            vectorRows: rows.vectorRows,
+            mark,
+        });
+        if (health.verdict === 'collapsed') {
+            const vectorAffected = health.reason.startsWith('vector ');
+            const previousMax = vectorAffected ? mark?.vectorMax : mark?.lexicalMax;
+            storeHealth = {
+                verdict: health.verdict,
+                ...(previousMax === undefined ? {} : { previousMax }),
+            };
+        }
+        else if (health.verdict === 'cold-start-over-existing') {
+            const previousMax = mark === undefined
+                ? undefined
+                : rows.lexicalRows === 0 && mark.lexicalMax > 0 ? mark.lexicalMax : mark.vectorMax;
+            storeHealth = {
+                verdict: health.verdict,
+                ...(previousMax === undefined ? {} : { previousMax }),
+                snapshotPath: storeSnapshotPath(root),
+            };
+        }
+        else if (health.verdict === 'unreadable') {
+            storeHealth = {
+                verdict: health.verdict,
+                unreadableFiles: [
+                    ...(rows.lexicalRows === 'unreadable' ? [basename(rows.lexicalSourcePath)] : []),
+                    ...(rows.vectorRows === 'unreadable' && rows.vectorSourcePath !== undefined
+                        ? [basename(rows.vectorSourcePath)] : []),
+                ],
+            };
+        }
+        else if (health.verdict === 'source-changed') {
+            storeHealth = { verdict: health.verdict };
+        }
+    }
+    catch {
+        storeHealth = undefined;
+    }
+    let patternBreakdown;
+    try {
+        if (storeRows !== undefined
+            && typeof storeRows.lexicalRows === 'number'
+            && typeof storeRows.lexicalQuarantinedRows === 'number') {
+            const quarantined = storeRows.lexicalQuarantinedRows;
+            const tierDelta = typeof storeRows.vectorQuarantinedRows === 'number'
+                ? Math.abs(quarantined - storeRows.vectorQuarantinedRows)
+                : undefined;
+            patternBreakdown = {
+                source: 'lexical',
+                active: storeRows.lexicalRows - quarantined,
+                quarantined,
+                attention: quarantined > 0 && quarantined * 3 >= storeRows.lexicalRows,
+                ...(tierDelta !== undefined && tierDelta > QUARANTINE_TIER_DRIFT_TOLERANCE ? { tierDelta } : {}),
+            };
+        }
+    }
+    catch {
+        patternBreakdown = undefined;
+    }
     let brainSources = 0;
     try {
         brainSources = listBrain().length;
@@ -333,10 +548,61 @@ export function statuslineData(projectRoot, now = Date.now()) {
     }
     return {
         patterns,
+        ...(patternBreakdown !== undefined ? { patternBreakdown } : {}),
         ...(usedPatterns !== undefined ? { usedPatterns } : {}),
         brainSources,
         ...(ageH !== undefined ? { consolidatedAgeH: ageH } : {}),
         ...(featureAdr !== undefined ? { featureAdr } : {}),
+        ...(storeHealth !== undefined ? { storeHealth } : {}),
     };
 }
+/**
+ * Render the /feature-adr PHASE line (line format B, fa-phase-statusline ADR-001) — the second
+ * status-bar line:
+ *
+ *   `📐 <slug> [<tier>] <done>/<total> ▶ <step label> · <N>м/—`
+ *
+ * States, in precedence order:
+ * - `undefined` (no line): a loop slot, the terminal label `done`, or ≥90 min of slot silence;
+ * - `⚠ <N>м без отчёта` from 30 min of slot silence (counted from the last report `ts`);
+ * - a label starting `⛔` or `⏸` replaces the `▶ <label>` portion VERBATIM (failure/waiting states
+ *   are reported by the pipeline through the label itself, never synthesised here);
+ * - otherwise `▶ <label>` with elapsed minutes counted from the PHASE start (`phaseStartTs`).
+ *
+ * done/total is the label's step-number position in its tier's active-step list; an unknown tier,
+ * an unparseable label, or a number outside the list renders `?/?` — the panel never guesses.
+ * The estimate slot is fixed-width at the tail: v1 defers estimates entirely, so it is always `/—`
+ * (a future median would be computed on the WRITE path and stored in the slot as a ready number —
+ * this render path stays a pure function over the slot, no DB, no subprocess, no features/* sweep).
+ *
+ * @param state A fresh slot from {@link readFeatureAdrState} (the ONLY source of "in progress").
+ * @param now Injectable clock (epoch ms) — defaults to `Date.now()`.
+ */
+export function renderFeatureAdrPhaseLine(state, now = Date.now()) {
+    if (state.kind === 'loop')
+        return undefined;
+    const label = state.step.trim();
+    if (label === 'done')
+        return undefined; // a finished run leaves the bar immediately
+    const tsMs = Date.parse(state.ts);
+    if (Number.isNaN(tsMs))
+        return undefined;
+    const silenceMs = now - tsMs;
+    const silenceMin = Math.floor(silenceMs / 60_000);
+    if (silenceMs >= FEATURE_ADR_FRESH_MS)
+        return undefined; // fully faded (90 min)
+    const tier = state.tier !== undefined && FEATURE_ADR_TIERS.has(state.tier) ? state.tier : undefined;
+    const steps = tier !== undefined ? FEATURE_ADR_ACTIVE_STEPS[tier] : undefined;
+    const stepNum = parseStepNumber(label);
+    const idx = steps !== undefined && stepNum !== undefined ? steps.indexOf(stepNum) : -1;
+    const ratio = idx >= 0 && steps !== undefined ? `${idx}/${steps.length}` : '?/?';
+    const head = `📐 ${state.slug} [${tier ?? '?'}] ${ratio}`;
+    if (silenceMs >= FEATURE_ADR_WARN_MS)
+        return `${head} ⚠ ${silenceMin}м без отчёта`;
+    const phaseStartMs = Date.parse(state.phaseStartTs ?? state.ts);
+    const elapsedMin = Number.isNaN(phaseStartMs) ? 0 : Math.max(0, Math.floor((now - phaseStartMs) / 60_000));
+    // ⛔ (a gate failure) and ⏸ (a waiting state) labels carry their own marker — verbatim, no ▶.
+    const stepPart = label.startsWith('⛔') || label.startsWith('⏸') ? label : `▶ ${label}`;
+    return `${head} ${stepPart} · ${elapsedMin}м/—`;
+}
 //# sourceMappingURL=statusline.js.map