peaks-loop 4.0.47 → 4.0.49

package/dist/services/code/compact-event-settle.js

@@ -0,0 +1,240 @@
+/**
+ * rid `2026-09-13-compact-event-settle` — what runs when the HARNESS says a
+ * compaction completed.
+ *
+ * THE PROBLEM THIS EXISTS TO DELETE. Before this slice peaks-loop learned that
+ * a compaction had happened by INFERENCE: `src/services/code/auto-compact-orchestrator.ts`
+ * probes the context ratio on every run, and a ratio that has fallen back below
+ * the auto-fire threshold is taken as proof that a previously-dispatched
+ * compact landed. That is a guess with three failure modes, all silent — the
+ * probe may not measure at all (`conservative-fallback`), the next probe may
+ * not come for minutes (during which the ratio has already climbed back up),
+ * and a compaction that left the ratio high is invisible.
+ *
+ * `PostCompact` is the harness STATING it. This module turns that statement
+ * into the same lifecycle settlement the probe path produces, plus an
+ * `observed` row carrying the one fact the probe path can never produce: what
+ * the harness said the compaction WAS — `manual` or `auto`.
+ *
+ * FOUR THINGS THIS MODULE REFUSES TO DO, EACH FOR A REASON:
+ *
+ *   1. It does not invent a `trigger`. `PostCompact`'s payload schema is
+ *      truncated in the retrievable docs, so a payload without the field is an
+ *      expected input. Absent stays absent. Defaulting it to `'auto'` would
+ *      answer "has this machine ever auto-compacted?" with a fabricated yes,
+ *      which is worse than the current "no answer".
+ *   2. It does not settle when no run is open. A `PostCompact` on a session
+ *      peaks-loop never dispatched for has nothing to attribute, and
+ *      `CompactHistoryEvent.beforeRatio` is a required number that could only
+ *      be filled with a ratio measured AFTER the compaction — a fabricated
+ *      "before". See the RD tech-doc §D8: covering that case needs a
+ *      `PreCompact` snapshot and is a separate slice, not a widened contract.
+ *   3. It does not let a stale measurement become an `afterRatio`. The probe's
+ *      statusline source may still hold the pre-compact value at the instant
+ *      this runs; `settleOpenLifecycleRunOnCompactEvent` drops anything that is
+ *      not below the dispatch ratio.
+ *   4. It does not settle a run off an event that names a DIFFERENT harness
+ *      session, and it does not label one `'main'` without checking. A payload
+ *      whose `session_id` is another session's would otherwise close this
+ *      project's open run and file the row as the main session's. The check is
+ *      best-effort in one direction only: an absent `session_id`, or a project
+ *      whose own harness session id cannot be resolved, is accepted rather than
+ *      refused — a guard that cannot see the name it is checking against must
+ *      not turn a missing field into a hook that never settles anything.
+ *
+ * NOTHING HERE THROWS. The caller is a hook on the harness's compaction path,
+ * where a failure must cost a telemetry row and nothing else.
+ */
+import { resolveAutoCompactProfile } from '../mode/mode-status-service.js';
+import { readContextPercent } from '../context/auto-compact-reader.js';
+import { resolveOuterSessionId } from '../session/binding-status-service.js';
+import { appendCompactHistoryEvent } from './auto-compact-orchestrator.js';
+import { settleOpenLifecycleRunOnCompactEvent } from './auto-compact-lifecycle.js';
+/**
+ * Which layer settled the run. `post-compact-hook` = the harness's event;
+ * `post-compact-probe` (written by the orchestrator) = a later probe's
+ * measurement. The two are deliberately distinct strings so a reader of
+ * `compact-history.jsonl` can tell a NOTIFICATION from an INFERENCE — which is
+ * the entire instrument this slice exists to build.
+ */
+export const COMPACT_EVENT_PATHWAY = 'post-compact-hook';
+/**
+ * Read `trigger` out of an already-parsed `PostCompact` payload.
+ *
+ * Anything that is not exactly `'manual'` or `'auto'` yields `undefined` — a
+ * missing field, a `null`, a number, another string, a payload that is not an
+ * object at all. This function never throws and never guesses (see this file's
+ * header, refusal 1).
+ */
+export function readTriggerFromHookPayload(payload) {
+    if (typeof payload !== 'object' || payload === null || Array.isArray(payload))
+        return undefined;
+    const raw = payload.trigger;
+    return raw === 'manual' || raw === 'auto' ? raw : undefined;
+}
+/**
+ * Read the harness session id out of an already-parsed `PostCompact` payload.
+ *
+ * Same contract as `readTriggerFromHookPayload`: a missing field, an empty
+ * string, a number, a non-object payload — every one of those is `undefined`,
+ * and "absent" is an expected input rather than an error (see this file's
+ * header, refusal 4, for what the caller does with it and what it does with
+ * `undefined`).
+ */
+export function readSessionIdFromHookPayload(payload) {
+    if (typeof payload !== 'object' || payload === null || Array.isArray(payload))
+        return undefined;
+    const raw = payload.session_id;
+    return typeof raw === 'string' && raw.length > 0 ? raw : undefined;
+}
+/**
+ * The post-compact ruler: the same probe the orchestrator uses, so this row
+ * divides by the same denominator the dispatch did.
+ *
+ * `ratio` is `null` when nothing could be measured — a `conservative-fallback`
+ * probe reports `0`, but that `0` means "unknown", and recording it here would
+ * publish a real, infinitely-deep drop. The rest of the reading (adapter, the
+ * window the ratio divides by) is still carried, because knowing WHICH adapter
+ * could not measure is diagnostic.
+ */
+export function measurePostCompact(input) {
+    const probe = readContextPercent({
+        projectRoot: input.projectRoot,
+        sessionId: input.sessionId,
+        outerSessionId: resolveOuterSessionId(input.projectRoot, input.sessionId, input.env),
+        env: input.env
+    });
+    const unmeasurable = probe.source === 'conservative-fallback';
+    return {
+        ratio: unmeasurable ? null : probe.ratio,
+        ide: probe.ide,
+        windowTokens: unmeasurable || typeof probe.capacityTokens !== 'number' ? null : probe.capacityTokens,
+        windowSource: unmeasurable ? null : (probe.capacitySource ?? null)
+    };
+}
+/**
+ * Settle whatever compact run is open in `sessionId`, because the harness just
+ * reported one.
+ *
+ * `measure` is the ruler, injected rather than called directly for one concrete
+ * reason: the production ruler prefers `~/.claude/statusline-state.json`, a real
+ * file whose contents differ on every machine that runs the test suite. A test
+ * asserting this row's `afterRatio` against the developer's own statusline would
+ * pass or fail by accident. It is called at most once — the IDE tag and the
+ * window come from the same reading, so they cannot disagree with each other.
+ *
+ * Returns `{ settled: false }` when there is no open run — the honest answer,
+ * not an error — and when the payload names another harness session. The two
+ * say different things in `reason`, because they are different facts.
+ */
+export function settleCompactFromHarnessEvent(input) {
+    const env = input.env ?? process.env;
+    const measure = input.measure ??
+        (() => measurePostCompact({ projectRoot: input.projectRoot, sessionId: input.sessionId, env }));
+    // Attribution first, and before the probe: an event that is not about this
+    // session must not spend a measurement, and must not touch this run at all.
+    // The comparison is harness-id to harness-id — the payload's `session_id` and
+    // this project's own outer session id as `resolveOuterSessionId` resolves it
+    // (env signal, then the binding's recorded id). It is never compared against
+    // the peaks-loop session id, which is a different namespace and would differ
+    // on every legitimate event.
+    if (input.hookSessionId !== undefined) {
+        const ownOuterSessionId = resolveOuterSessionId(input.projectRoot, input.sessionId, env);
+        if (ownOuterSessionId !== undefined && ownOuterSessionId !== input.hookSessionId) {
+            return { settled: false, reason: 'different-session' };
+        }
+    }
+    let measurement = null;
+    try {
+        measurement = measure();
+    }
+    catch {
+        // A ruler that broke is not a reason to refuse the harness's statement.
+        measurement = null;
+    }
+    const settled = settleOpenLifecycleRunOnCompactEvent({
+        projectRoot: input.projectRoot,
+        sessionId: input.sessionId,
+        measuredRatio: measurement?.ratio ?? null,
+        failLifecycleWrite: input.failLifecycleWrite
+    });
+    if (settled === null) {
+        return { settled: false, reason: 'nothing-to-settle' };
+    }
+    if (!settled.lifecycleWritten) {
+        // Repair R9 (AC2): a settle whose lifecycle write FAILED has not settled the
+        // run. The record is still resting at `armed` / `compacting`, so the next
+        // arrival — another `PostCompact`, or a probe — finds the SAME run open and
+        // settles it again. Appending the row anyway writes one per arrival for a
+        // compaction the lifecycle store never recorded, each one carrying an
+        // `afterRatio` that reads as a settled measurement; and when the store does
+        // recover, the retry appends a SECOND row for the same compaction, which
+        // `computeWindowCalibration` is free to attach to a later dispatch pair.
+        // Nothing is lost by deferring: `probe.ratio` is re-measured at the retry,
+        // and the retry is the settlement this row is about.
+        return {
+            settled: true,
+            runId: settled.runId,
+            beforeRatio: settled.triggerRatio,
+            afterRatio: settled.afterRatio,
+            historyWritten: false,
+            lifecycleWritten: false,
+            ...(input.trigger !== undefined ? { trigger: input.trigger } : {})
+        };
+    }
+    const event = {
+        schemaVersion: 1,
+        kind: 'observed',
+        ts: new Date().toISOString(),
+        // The guard above refused every payload that named another session, so
+        // reaching here means the event named this one or named none. The row is
+        // therefore attributable to the main session, which is the only session
+        // this command settles.
+        target: 'main',
+        mode: resolveAutoCompactProfile(input.projectRoot),
+        ide: measurement?.ide ?? 'claude-code',
+        pathway: COMPACT_EVENT_PATHWAY,
+        beforeRatio: settled.triggerRatio,
+        ...(settled.afterRatio !== null ? { afterRatio: settled.afterRatio } : {}),
+        ...(input.trigger !== undefined ? { trigger: input.trigger } : {}),
+        redLine: false,
+        ok: true,
+        checkpointPath: '',
+        dispatchMessage: `PostCompact fired: the harness reported a ${input.trigger ?? 'unreported-trigger'} compaction, ` +
+            `settling the run dispatched at ${(settled.triggerRatio * 100).toFixed(1)}%` +
+            (settled.afterRatio !== null
+                ? ` (measured now at ${(settled.afterRatio * 100).toFixed(1)}%)`
+                : ' (no post-compact measurement available)'),
+        ...(settled.afterRatio !== null
+            ? { windowTokens: measurement?.windowTokens ?? null, windowSource: measurement?.windowSource ?? null }
+            : {})
+    };
+    try {
+        appendCompactHistoryEvent({ projectRoot: input.projectRoot, sessionId: input.sessionId, event });
+    }
+    catch {
+        // The lifecycle run is already settled; losing the history row is the
+        // smaller loss, and a throwing hook is the larger one. Reported rather
+        // than silenced: "the run settled but the row is missing" and "the row is
+        // on disk" are different facts, and a caller that cannot tell them apart
+        // cannot diagnose a hook that has stopped recording anything.
+        return {
+            settled: true,
+            runId: settled.runId,
+            beforeRatio: settled.triggerRatio,
+            afterRatio: settled.afterRatio,
+            historyWritten: false,
+            lifecycleWritten: settled.lifecycleWritten,
+            ...(input.trigger !== undefined ? { trigger: input.trigger } : {})
+        };
+    }
+    return {
+        settled: true,
+        runId: settled.runId,
+        beforeRatio: settled.triggerRatio,
+        afterRatio: settled.afterRatio,
+        historyWritten: true,
+        lifecycleWritten: settled.lifecycleWritten,
+        ...(input.trigger !== undefined ? { trigger: input.trigger } : {})
+    };
+}

package/dist/services/compact-history/compact-history-service.d.ts

@@ -26,6 +26,20 @@ export interface CompactHistoryEvent {
     readonly kind?: 'dispatch' | 'observed';
     /** `observed` rows only: the measured post-compact ratio. */
     readonly afterRatio?: number;
+    /**
+     * rid `2026-09-13-compact-event-settle`: what the HARNESS said caused the
+     * compaction — `manual` (a user ran `/compact`) or `auto` (the harness's own
+     * window fired). Written only by the `PostCompact` hook path, which is the
+     * only path a harness reports it on.
+     *
+     * OPTIONAL, AND ABSENT MEANS "NOT REPORTED" — never "manual", never "auto".
+     * `PostCompact`'s payload schema is truncated in the retrievable docs, so a
+     * payload without the field is an expected input, not an error; the whole
+     * reason this column exists is that "has this machine ever auto-compacted?"
+     * has no answer today, and a defaulted value would answer it falsely.
+     * Rows that predate the slice omit it, exactly like `windowTokens` / `kind`.
+     */
+    readonly trigger?: 'manual' | 'auto';
 }
 /**
  * One dispatch paired with the measurement that followed it — the

package/dist/services/compact-statusline/compact-statusline-service.js

@@ -9,8 +9,8 @@
 //
 // Decision priority (explicit, no implicit fall-through):
 //   1. lifecycle missing  → fall back to legacy (pending → queued,
-//      recent history → completed WITHOUT an invented after-ratio,
-//      else none)
+//      a recent `observed` history row → completed WITHOUT an invented
+//      after-ratio, else none)
 //   2. lifecycle invalid  → 'invalid' (NEVER fall back to legacy
 //      — a corrupted lifecycle is not a green progress bar)
 //   3. lifecycle valid    → map stage to filledCells via the
@@ -37,9 +37,10 @@
 // ratios. After-ratio is only rendered when the lifecycle record
 // carries a real one; otherwise the bar shows a stable "no
 // measurement" hint.
-import { existsSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { getSessionDir } from '../session/getSessionDir.js';
 import { AUTO_COMPACT_RED_LINE_RATIO } from '../context/auto-compact-types.js';
+import { readCompactHistory } from '../compact-history/compact-history-service.js';
 import { readCompactLifecycle, } from './compact-lifecycle-store.js';
 /**
  * Concrete first-version stale timeout. Adjustable after real timing
@@ -58,7 +59,12 @@ const DEFAULT_STALE_AFTER_MS = 120_000;
  * to not flap on subsequent reads. Adjustable after real timing feedback.
  */
 export const COMPLETED_EXPIRY_MS = 10_000;
-/** Legacy mtime window for the "just compacted" indicator. */
+/**
+ * How recently the last history row must itself have been written for the
+ * legacy path to report it as "just compacted". Measured against the row's own
+ * `ts` — the fact — rather than the file's mtime, which is only a proxy for it
+ * and is also moved by rows that record no compaction (repair R9).
+ */
 const LEGACY_JUST_COMPACTED_WINDOW_MS = 30_000;
 // PRD-002b slice 2 — extract cell-table magic numbers (4/6/8) into named
 // consts so the no-magic-numbers lint rule stops flagging the typed
@@ -142,6 +148,7 @@ export function decideCompactStatusline(input) {
     // lifecycle.kind === 'missing' → fall back to legacy files.
     return decideLegacyFallback({
         projectRoot: input.projectRoot,
+        sessionId: input.sessionId,
         sessionDir,
         now: input.now,
     });
@@ -212,26 +219,53 @@ function decideLegacyFallback(input) {
             // fall through to history check
         }
     }
-    // Priority 2 within legacy: a recent history event within 30s.
-    if (existsSync(historyPath)) {
-        try {
-            const mtimeMs = statSync(historyPath).mtimeMs;
-            if (now - mtimeMs <= LEGACY_JUST_COMPACTED_WINDOW_MS) {
-                // CRITICAL: no invented after-ratio. The history event may
-                // carry a beforeRatio, but never a measured after-ratio;
-                // this is the legacy path and we honour the "no measurement"
-                // default.
-                return {
-                    kind: 'completed',
-                    filledCells: 8,
-                    detail: historyPath,
-                };
-            }
-        }
-        catch {
-            // fall through to idle
+    // Priority 2 within legacy: a history row TESTIFIES that a compaction was
+    // witnessed, recently enough to still be the one being reported.
+    //
+    // Repair R9 (AC4). This used to read the file's mtime — freshness taken as
+    // evidence that "a compact just landed". Freshness is evidence of neither:
+    // the same file takes a `dispatch` row every time peaks-loop ASKS for a
+    // compact, and an ask is an intent, not an outcome. One real session
+    // (2026-09-13, ~15.5 h) holds 1075 dispatch rows and ZERO compactions
+    // (`auto-compact-orchestrator.ts`), so a fresh file was the NORMAL state of a
+    // session in which nothing had compacted at all — and each of those asks
+    // painted this 8-cell "completed" bar.
+    //
+    // So the row's own testimony is read instead, through the same reader the CLI
+    // uses. Only `kind: 'observed'` means a compaction was witnessed (a row with
+    // no `kind` is a dispatch — every pre-`kind` row is one), and the row's `ts`
+    // is the moment compared, not the filesystem's.
+    //
+    // Repair R11. The testimony is looked for in EVERY row inside the window, not
+    // only in the last one. Reading the last row alone made the indicator depend
+    // on the ASK: a `dispatch` row lands on every probe, so an `observed` row
+    // stopped counting the moment peaks-loop asked again — `[observed, dispatch]`
+    // one second apart answered `none` for a compaction that had just been
+    // witnessed — i.e. it deleted the very indicator the mtime read had shown,
+    // the one the replacement was meant to keep honest. A `dispatch` row alone
+    // still testifies
+    // to nothing (the direction R9 closed): what is required is an `observed` row
+    // inside the window, wherever in the file it sits.
+    try {
+        // The reader answers `file-missing` / `empty` itself; the `catch` is for the
+        // read itself, which it does not guard.
+        const read = readCompactHistory({ projectRoot: input.projectRoot, sessionId: input.sessionId });
+        const witnessed = read.kind === 'ok' &&
+            read.events.some((row) => row.kind === 'observed' && now - Date.parse(row.ts) <= LEGACY_JUST_COMPACTED_WINDOW_MS);
+        if (witnessed) {
+            // CRITICAL: no invented after-ratio. The row may carry a measured
+            // afterRatio, but this is the legacy path and we honour the
+            // "no measurement" default.
+            return {
+                kind: 'completed',
+                filledCells: 8,
+                detail: historyPath,
+            };
         }
     }
+    catch {
+        // fall through to idle
+    }
     return { kind: 'none', filledCells: 0 };
 }
 /**

package/dist/services/config/config-restore.d.ts

@@ -1,9 +1,20 @@
+export interface RestoreListResult {
+    /**
+     * True when `~/.peaks/config.json.1.x.bak` exists — i.e. whether there is
+     * anything to restore from at all. Meaning is identical to
+     * `RollbackPlan.available`.
+     */
+    available: boolean;
+    fields: string[];
+}
 export interface RestoreResult {
+    /** See `RestoreListResult.available`. */
+    available: boolean;
     field: string;
     applied: boolean;
     sidecarPath?: string;
 }
-export declare function listAvailableFields(): string[];
+export declare function listAvailableFields(): RestoreListResult;
 export declare function restoreField(opts: {
     field: string;
     apply: boolean;

package/dist/services/config/config-restore.js

@@ -9,21 +9,52 @@ import { backupConfigPath } from './config-migration.js';
  * can review before adopting. Fields in the deferred-design set
  * (workspaces, providers, proxy) throw RESTORE_GUARDED so the user has
  * to acknowledge explicitly.
+ *
+ * MISSING BACKUP IS NOT A FAILURE (rid 2026-09-13-two-decisions ①, user-
+ * decided). `~/.peaks/config.json.1.x.bak` only exists on a machine that ran
+ * `peaks config migrate --apply`; a machine that never did is in its NORMAL
+ * initial state, not in an error state. Both subcommands therefore report it
+ * as a SUCCESS carrying `available: false` rather than throwing — the sibling
+ * `rollback` already did, and `restore` exited 1 for the same state, so a
+ * script could not ask either one "was there ever a backup?" without knowing
+ * which subcommand it was talking to.
+ *
+ * ⚠️ THE COST, ACCEPTED BY THE USER: an existing script that read exit 1 as
+ * "never backed up" loses that signal. The replacement is `available` — it is
+ * on EVERY envelope this module produces, on the success path (`false` ⇒
+ * nothing to restore, exit 0) and on the failure path (`true` ⇒ a backup IS
+ * there and the field/guard was the problem, exit 1), so one JSON key answers
+ * the question that used to take the exit code, and it distinguishes "no
+ * backup" from "backup exists but the field is not in it".
  */
 const GUARDED_FIELDS = new Set(['workspaces', 'providers', 'proxy']);
+/**
+ * The parsed `.bak`, or `null` when there is none. `null` is the normal
+ * "nothing was ever migrated" state (see the module comment), not an error.
+ *
+ * A `.bak` that exists but does not parse still throws: `available` means
+ * "the backup file is present", and a present-but-malformed one is a real
+ * failure the caller must surface.
+ */
 function readBakContent() {
     const bak = backupConfigPath();
     if (!existsSync(bak)) {
-        throw new Error('NO_BACKUP: ~/.peaks/config.json.1.x.bak not found');
+        return null;
     }
     return JSON.parse(readFileSync(bak, 'utf8'));
 }
 export function listAvailableFields() {
     const bak = readBakContent();
-    return Object.keys(bak).filter((k) => k !== 'version');
+    if (bak === null) {
+        return { available: false, fields: [] };
+    }
+    return { available: true, fields: Object.keys(bak).filter((k) => k !== 'version') };
 }
 export function restoreField(opts) {
     const bak = readBakContent();
+    if (bak === null) {
+        return { available: false, field: opts.field, applied: false };
+    }
     if (!(opts.field in bak)) {
         throw new Error(`FIELD_NOT_FOUND: ${opts.field} is not in config.json.1.x.bak`);
     }
@@ -33,7 +64,7 @@ export function restoreField(opts) {
     const home = homedir();
     const sidecar = join(home, '.peaks', `config.json.restore-${opts.field}.json`);
     if (!opts.apply) {
-        return { field: opts.field, applied: false };
+        return { available: true, field: opts.field, applied: false };
     }
     mkdirSync(join(home, '.peaks'), { recursive: true });
     const payload = {
@@ -43,5 +74,5 @@ export function restoreField(opts) {
         restoredAt: new Date().toISOString(),
     };
     writeFileSync(sidecar, JSON.stringify(payload, null, 2) + '\n', 'utf8');
-    return { field: opts.field, applied: true, sidecarPath: sidecar };
+    return { available: true, field: opts.field, applied: true, sidecarPath: sidecar };
 }

package/dist/services/config/config-rollback.js

@@ -15,7 +15,12 @@ export function planRollback() {
 export function executeRollback(opts) {
     const plan = planRollback();
     if (!plan.available) {
-        throw new Error('NO_BACKUP: ~/.peaks/config.json.1.x.bak not found');
+        // rid 2026-09-13-two-decisions ①: a machine that never migrated has no
+        // `.bak`, and that is its normal state — `--apply` on such a machine is
+        // "nothing to roll back", not a failure. Returned instead of thrown so the
+        // exit status and the `available` key agree on every path; see
+        // `config-restore.ts` for the full rationale and the accepted cost.
+        return { ...plan, applied: false };
     }
     if (!opts.apply) {
         return { ...plan, applied: false };

package/dist/services/context/auto-compact-types.d.ts

@@ -128,13 +128,31 @@ export type AutoCompactResult = {
     readonly nextActions: readonly string[];
 } | {
     readonly ok: true;
-    readonly code: 'AUTO_COMPACT_SKIP' | 'AUTO_COMPACT_WAIT';
+    readonly code: 'AUTO_COMPACT_SKIP' | 'AUTO_COMPACT_WAIT' | 'AUTO_COMPACT_ALREADY_ARMED' | 'AUTO_COMPACT_UNRESOLVED_SESSION';
     readonly message: string;
     readonly data: {
         readonly sessionId: string;
         readonly ratio: number;
         readonly source: string;
-        readonly decision: 'below-threshold' | 'in-flight-batch';
+        /**
+         * `unresolved-session` (repair R6): the session id named no session
+         * directory, so the compact backoff's question — "is an attempt already
+         * outstanding?" — could not be asked. It is NOT `already-armed` (no run
+         * was found; the record could not be read at all) and NOT an admit: the
+         * dispatch is left undone because an unanswerable question is not a
+         * "no", and admitting on one is how a gate ends up reading a string
+         * instead of the artifact the string names.
+         */
+        readonly decision: 'below-threshold' | 'in-flight-batch' | 'already-armed' | 'unresolved-session';
+        /**
+         * rid `2026-09-14-compact-dispatch-backoff`, `already-armed` only: the
+         * ratio the open run was dispatched at, and its id. `ratio` above is the
+         * LIVE reading — the pair is what keeps "it is still high" legible after
+         * the backoff drops the per-probe rows: the ask is at `armedAtRatio`, and
+         * the context is now at `ratio`, above it and not yet compacted.
+         */
+        readonly armedAtRatio?: number;
+        readonly armedRunId?: string;
         /**
          * Slice 2026-09-13-auto-compact-trigger-ownership: what syncing the
          * harness auto-compact window did on this probe. `null` = the active