peaks-loop 4.0.46 → 4.0.48

package/dist/services/code/auto-compact-orchestrator.js

@@ -9,10 +9,15 @@
  * conversation history — so peaks-loop drives the entire compaction:
  *
  *   1. Read current context % (via IDE adapter's `readContextPercent`).
- *   2. If ratio ≥ 0.95 (RED LINE): synchronous gate — peaks-loop
- *      refuses sub-agent dispatch and forces IDE compact immediately.
- *      The LLM cannot opt out (compact red line — keeps the runner
- *      alive).
+ *   2. If ratio ≥ 0.95 (RED LINE): peaks-loop ASKS the harness to
+ *      compact and reports that it is waiting. It does NOT block
+ *      sub-agent dispatch (slice
+ *      2026-09-13-auto-compact-trigger-ownership, T3): peaks-loop owns
+ *      the *decision*, the harness owns the *capability*, and peaks-loop
+ *      has no way to compact a running session itself — so a "gate"
+ *      here gated nothing and deadlocked the runner at the worst
+ *      moment. If the ratio keeps rising and the harness has not
+ *      compacted, the honest move is to say so and hand control back.
  *   3. If 0.85 ≤ ratio < 0.95 (pre-compact zone): peaks-loop prepares
  *      the convergence toolkit (checkpoint + auto-decisions log +
  *      IDE-dispatch handle) and surfaces it to the LLM. The LLM
@@ -24,18 +29,20 @@
  * Why two tiers (vs. one): the LLM uses the 0.85–0.95 zone for
  * intelligent convergence — wait for in-flight sub-agents, finish
  * the current todo row, persist a checkpoint, then compact. At 0.95
- * the window is gone; peaks-loop takes over synchronously. Net effect:
- * the LLM-runner keeps working with context < 95% without human
- * intervention.
+ * peaks-loop stops negotiating and requests the compact outright. Net
+ * effect: the LLM-runner keeps working at any ratio without human
+ * intervention, and without a gate it cannot satisfy.
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { getSessionIdCanonical } from '../session/session-manager.js';
 import { resolveOuterSessionId } from '../session/binding-status-service.js';
-import { AUTO_COMPACT_PRE_COMPACT_RATIO } from '../context/auto-compact-types.js';
+import { resolveCanonicalProjectRoot } from '../config/config-service.js';
+import { describeHarnessWindowSync, harnessWindowSyncWarning } from '../context/harness-window-config.js';
+import { AUTO_COMPACT_PRE_COMPACT_RATIO, DEPRECATED_ENVELOPE_FIELDS } from '../context/auto-compact-types.js';
 import { describeMode, thresholdFor } from './auto-compact-modes.js';
 import { resolveAutoCompactProfile } from '../mode/mode-status-service.js';
-import { CompactLifecyclePublisher, newCompactRunId, resolveDispatchedStage, settleOpenLifecycleRun, summarizeLifecycleError } from './auto-compact-lifecycle.js';
+import { CompactLifecyclePublisher, fillEventSettledMeasurement, newCompactRunId, resolveDispatchedStage, settleOpenLifecycleRun, summarizeLifecycleError } from './auto-compact-lifecycle.js';
 const PRE_COMPACT_REASON = 'pre-compact-auto';
 /**
  * Map a context ratio to a `CompactTrigger` action. Pure; the side
@@ -44,7 +51,7 @@ const PRE_COMPACT_REASON = 'pre-compact-auto';
  *
  *   - ratio < preCompact → 'none' or 'soft-warn'
  *   - ratio ≥ preCompact → 'pre-compact' (async-friendly path)
- *   - ratio ≥ redLine    → 'red-line' (synchronous gate)
+ *   - ratio ≥ redLine    → 'red-line' (ask the harness; dispatch continues)
  *
  * Slice 2026-07-28 (rid-027): `mode` selects the threshold table.
  * Default `'standard'` (0.85/0.95). `'partial'` (0.70/0.85) is used
@@ -64,10 +71,17 @@ export function evaluateCompactTrigger(ratio, mode = 'standard') {
             };
     }
     if (ratio >= redLine) {
+        // Slice 2026-09-13-auto-compact-trigger-ownership (T3): the red line no
+        // longer claims it blocks anything. It cannot: peaks-loop has no
+        // executor for a running session (no `/compact` the model may invoke, no
+        // hook-initiated compact, no `--compact` flag), so "refuse dispatch until
+        // ratio < 0.85" was a gate with no key — a constructive deadlock at the
+        // exact moment the runner most needed to keep working. What peaks-loop
+        // CAN do is ask the harness (whose own trigger is armed) and say so.
         return {
             kind: 'red-line',
             ratio,
-            message: `Context at ${(ratio * 100).toFixed(1)}% ≥ ${(redLine * 100).toFixed(0)}% red line (mode=${mode}). Synchronous compact REQUIRED (LLM cannot opt out).`
+            message: `Context at ${(ratio * 100).toFixed(1)}% ≥ ${(redLine * 100).toFixed(0)}% red line (mode=${mode}). peaks-loop has asked the harness to compact and is WAITING for it — sub-agent dispatch is NOT blocked; carry on and re-probe with \`peaks code context-now\`.`
         };
     }
     if (ratio < preCompact) {
@@ -104,8 +118,13 @@ export function evaluateCompactTrigger(ratio, mode = 'standard') {
  *   - 0.85 ≤ ratio < 0.95    → pre-compact; if in-flight batch
  *                                present, defer (D6.e); else dispatch
  *                                IDE compact asynchronously.
- *   - ratio ≥ 0.95           → red-line; ALWAYS dispatch synchronously
- *                                regardless of in-flight batch.
+ *   - ratio ≥ 0.95           → red-line; ask the harness to compact
+ *                                regardless of in-flight batch. Nothing is
+ *                                gated — dispatch is NOT blocked (slice
+ *                                2026-09-13-auto-compact-trigger-ownership:
+ *                                peaks-loop cannot compact a running session,
+ *                                so a "block" gated nothing and deadlocked the
+ *                                runner).
  */
 export function evaluateAutoCompactDecision(input) {
     const trigger = evaluateCompactTrigger(input.ratio, input.mode ?? 'standard');
@@ -123,7 +142,10 @@ export function evaluateAutoCompactDecision(input) {
         return { shouldCompact: false, reason: 'below-threshold', trigger, action: 'soft-warn' };
     }
     if (trigger.kind === 'red-line') {
-        // Red line: ignore in-flight batch — synchronous dispatch wins.
+        // Red line: ignore in-flight batch — the harness is asked NOW rather than
+        // waiting for the batch to drain. Not "synchronous dispatch": peaks-loop
+        // has no synchronous compact to run, it can only request one and report
+        // that it is waiting.
         return { shouldCompact: true, reason: 'red-line', trigger, action: 'red-line' };
     }
     // pre-compact zone (0.85 ≤ ratio < 0.95): honor D6.e in-flight deferral.
@@ -162,7 +184,7 @@ export function buildConvergencePlan(input) {
         checkpointPath: input.checkpointPath,
         nextActions: [...input.nextActions],
         resumeHint: input.redLine === true
-            ? 'RED-LINE compact: post-compact-detect must confirm ratio < 0.85 before resuming work.'
+            ? 'RED-LINE compact requested from the harness; work CONTINUES (nothing is blocked). Re-probe with `peaks code context-now`; if the ratio is still ≥ 0.95 and the harness has not compacted, report it and hand control back to the user.'
             : 'post-compact-detect shouldAutoResume → resume pre-compact plan from checkpoint'
     };
 }
@@ -204,6 +226,13 @@ function appendAutoDecisionLog(input) {
  * The file is gitignored under `.peaks/_runtime/<sessionId>/txt/` and
  * is one-shot: the LLM should `mv` it to `.consumed` after firing
  * `/compact`. A re-run will overwrite.
+ *
+ * ZERO READERS as of slice 2026-09-13-auto-compact-trigger-ownership: the
+ * write survives, but nothing consumes the file, and its `nextAction` asks
+ * for a `/compact` the model cannot invoke (the Skill tool exposes only
+ * `/init` and `/security-review`; hooks can observe or veto, never initiate).
+ * Retained deliberately for the sibling A2 slice, which owns harness-side
+ * state re-injection. Not a capability peaks-loop has today.
  */
 function writeMainSessionCompactIntent(input) {
     const dir = join(input.projectRoot, '.peaks', '_runtime', input.sessionId, 'txt');
@@ -242,7 +271,7 @@ function writePreCompactCheckpoint(input) {
         // rehydrates from the auto-decisions log + open question list.
         mode: 'full-auto',
         currentPlan: input.redLine === true
-            ? 'RED-LINE compact just executed; confirm ratio < 0.85 before resuming work'
+            ? 'RED-LINE compact REQUESTED from the harness (not executed by peaks-loop); work continues'
             : 'auto-compact in progress; resume from auto-decisions.md',
         openQuestions: [],
         recentDecisions: [],
@@ -276,13 +305,14 @@ function resolveAutoCompactMode(projectRoot) {
  *   5. If trigger.kind === 'pre-compact' AND in-flight batch → wait.
  *   6. If trigger.kind === 'pre-compact' → async dispatch (write
  *      checkpoint + IDE compact; orchestrator returns immediately).
- *   7. If trigger.kind === 'red-line' → synchronous gate: refuse
- *      sub-agent dispatch, dispatch IDE compact, mark `redLineGated`.
+ *   7. If trigger.kind === 'red-line' → dispatch the IDE compact, report
+ *      that the harness has been asked and that dispatch continues.
  *
  * The caller (CLI or skill body) handles the actual return — D7's
- * post-compact-detect will pick up the checkpoint on the next turn.
- * For red-line, the caller MUST block further tool calls until the
- * post-compact probe confirms ratio < 0.85.
+ * post-compact-detect will pick up the checkpoint on the next turn. For
+ * red-line, the caller keeps working; it re-probes and, if the ratio is
+ * still rising with no compact from the harness, reports that instead of
+ * stalling.
  */
 export async function runAutoCompact(input) {
     const sessionId = input.sessionId ?? getSessionIdCanonical(input.projectRoot);
@@ -300,7 +330,7 @@ export async function runAutoCompact(input) {
     // v2.13.0 zero-pause contract.
     const mode = input.mode ?? resolveAutoCompactMode(input.projectRoot);
     // Lazy import to avoid the AC-1 module depending on the orchestrator.
-    const { readContextPercent } = await import('../context/auto-compact-reader.js');
+    const { readContextPercent, syncHarnessWindowForProject } = await import('../context/auto-compact-reader.js');
     const outerSessionId = resolveOuterSessionId(input.projectRoot, sessionId, input.env ?? process.env);
     const probe = readContextPercent({
         projectRoot: input.projectRoot,
@@ -308,6 +338,21 @@ export async function runAutoCompact(input) {
         outerSessionId,
         env: input.env
     });
+    // Slice 2026-09-13-auto-compact-trigger-ownership (T1 + T2): write the very
+    // denominator this probe divided by into the harness's own machine-local
+    // settings, so "peaks-loop's 85%" and "the harness's trigger" are the same
+    // point on one scale. Idempotent — an unchanged value performs no write, so
+    // a hook firing this on every Bash call cannot churn the file.
+    const harnessWindow = syncHarnessWindowForProject({
+        // Promoted to the git root first (`--project .` is what the PreToolUse
+        // hook passes): the harness's settings live at the project root, and the
+        // envelope must report an absolute path for the write it claims to have
+        // made. Fail-open — `resolveCanonicalProjectRoot` returns its input when
+        // nothing resolves.
+        projectRoot: resolveCanonicalProjectRoot(input.projectRoot),
+        env: input.env,
+        tokens: probe.capacityTokens ?? null
+    });
     const decision = evaluateAutoCompactDecision({
         ratio: probe.ratio,
         // Slice 4.0.8 (D4d): production `inFlightBatch` MUST come from
@@ -337,27 +382,79 @@ export async function runAutoCompact(input) {
         // still open at `compacting`. Nothing is written when there is no
         // open run, when the ratio is still high, or when the probe could
         // not measure at all.
-        settleOpenLifecycleRun({
+        const settled = settleOpenLifecycleRun({
             projectRoot: input.projectRoot,
             sessionId,
             measuredRatio: probe.ratio,
             source: probe.source,
             autoFireThreshold: thresholdFor(mode, 'autoFire'),
             onLifecycleStage: input.onLifecycleStage
-        });
+        }) ??
+            // Repair R1 (`2026-09-13-compact-event-settle`): the HARNESS event may
+            // already have closed this run WITHOUT an honest post-compact number —
+            // in which case the call above finds nothing open, and without this the
+            // calibration pair stays blank for exactly the compactions the event path
+            // exists to witness. Fills the number the event owed.
+            fillEventSettledMeasurement({
+                projectRoot: input.projectRoot,
+                sessionId,
+                measuredRatio: probe.ratio,
+                source: probe.source
+            });
+        // Slice 2026-09-13-auto-compact-trigger-ownership (T4): a settle means a
+        // dispatched compact demonstrably landed. Append an `observed` row
+        // carrying the measured ratio, so `peaks compact history` can show
+        // "asked at R (intent) / landed by R' (observed)" once a real session has
+        // run. Without this row the intent has nothing to be compared against.
+        if (settled !== null) {
+            appendObservedCompactEvent({
+                projectRoot: input.projectRoot,
+                sessionId,
+                event: {
+                    schemaVersion: 1,
+                    kind: 'observed',
+                    ts: new Date().toISOString(),
+                    target: input.target ?? 'main',
+                    mode,
+                    ide: probe.ide,
+                    pathway: 'post-compact-probe',
+                    beforeRatio: settled.triggerRatio,
+                    afterRatio: probe.ratio,
+                    redLine: false,
+                    ok: true,
+                    checkpointPath: '',
+                    dispatchMessage: `post-compact probe measured ratio ${(probe.ratio * 100).toFixed(1)}% (source=${probe.source}) after the compact dispatched at ${(settled.triggerRatio * 100).toFixed(1)}%`,
+                    windowTokens: probe.capacityTokens ?? null,
+                    windowSource: probe.capacitySource ?? null
+                }
+            });
+        }
         return {
             ok: true,
             code: decision.reason === 'in-flight-batch' ? 'AUTO_COMPACT_WAIT' : 'AUTO_COMPACT_SKIP',
-            message: decision.trigger.kind === 'soft-warn'
+            message: `${decision.trigger.kind === 'soft-warn'
                 ? decision.trigger.message
                 : decision.reason === 'in-flight-batch'
                     ? `In-flight batch detected; deferring pre-compact (ratio=${(probe.ratio * 100).toFixed(1)}%); next probe will re-evaluate.`
-                    : `Context at ${(probe.ratio * 100).toFixed(1)}%; below the ${(thresholdFor(mode, 'autoFire') * 100).toFixed(0)}% auto-fire threshold (mode=${mode}).`,
+                    : `Context at ${(probe.ratio * 100).toFixed(1)}%; below the ${(thresholdFor(mode, 'autoFire') * 100).toFixed(0)}% auto-fire threshold (mode=${mode}).`}${
+            // No compact was needed, but the sync may still have rewritten the
+            // harness's settings (the first probe of a project always does). The
+            // notice is appended ONLY for an actual write — the other actions'
+            // sentences would be noise on every quiet probe — PLUS the one refusal
+            // that is not quiet: a refused write that leaves peaks-loop's number and
+            // the harness's pinned window disagreeing. That is the moment the ratio
+            // stops describing the harness's trigger, so staying silent is exactly
+            // the failure 要告知 exists to prevent.
+            harnessWindow !== null && harnessWindow !== undefined &&
+                (harnessWindow.action === 'written' || harnessWindowSyncWarning(harnessWindow) !== null)
+                ? ` ${describeHarnessWindowSync(harnessWindow)}`
+                : ''}`,
             data: {
                 sessionId,
                 ratio: probe.ratio,
                 source: probe.source,
-                decision: decision.reason === 'in-flight-batch' ? 'in-flight-batch' : 'below-threshold'
+                decision: decision.reason === 'in-flight-batch' ? 'in-flight-batch' : 'below-threshold',
+                harnessWindow
             }
         };
     }
@@ -392,14 +489,20 @@ export async function runAutoCompact(input) {
         });
         nextActions = isRedLine
             ? [
-                'RED-LINE compact dispatched — further sub-agent dispatch BLOCKED until ratio < 0.85',
+                'RED-LINE: harness compact requested — sub-agent dispatch is NOT blocked; keep working',
                 'Post-compact resume picks up the convergence plan from auto-decisions.md',
-                'Next `peaks code auto-compact` probe will confirm ratio dropped below 0.85'
+                'Next `peaks code context-now` probe will confirm the ratio dropped; if it keeps climbing and the harness has not compacted, report that to the user and hand control back',
+                // Slice 2026-09-13-auto-compact-trigger-ownership: this command
+                // also rewrites the harness's own settings, so it says so too. The
+                // user accepted that write on the condition 要告知 — a write only
+                // one of the two syncing commands reports is not a notice.
+                describeHarnessWindowSync(harnessWindow)
             ]
             : [
                 'Pre-compact dispatched — IDE compact in progress (async)',
                 'Post-compact resume picks up the convergence plan from auto-decisions.md',
-                'Next `peaks code auto-compact` probe will confirm ratio dropped below 0.85'
+                'Next `peaks code auto-compact` probe will confirm ratio dropped below 0.85',
+                describeHarnessWindowSync(harnessWindow)
             ];
         plan = buildConvergencePlan({
             sessionId,
@@ -426,7 +529,14 @@ export async function runAutoCompact(input) {
                 source: probe.source,
                 target: input.target ?? 'main',
                 mode,
-                redLineGated: isRedLine
+                redLineRequested: isRedLine,
+                // Compatibility alias + its record. `redLineGated` shipped from
+                // 2.13.0 to 4.0.46, so a consumer outside this repo reads it and must
+                // not start receiving `undefined`; the record is what makes the
+                // deprecation visible to that consumer. See the type.
+                redLineGated: isRedLine,
+                deprecatedFields: DEPRECATED_ENVELOPE_FIELDS,
+                harnessWindow
             }
         };
     }
@@ -474,7 +584,10 @@ export async function runAutoCompact(input) {
                 convergencePlan: plan,
                 target,
                 mode,
-                redLineGated: isRedLine
+                redLineRequested: isRedLine,
+                redLineGated: isRedLine,
+                deprecatedFields: DEPRECATED_ENVELOPE_FIELDS,
+                harnessWindow
             }
         };
     }
@@ -506,6 +619,7 @@ export async function runAutoCompact(input) {
             sessionId,
             event: {
                 schemaVersion: 1,
+                kind: 'dispatch',
                 ts: now.toISOString(),
                 target,
                 mode,
@@ -516,6 +630,10 @@ export async function runAutoCompact(input) {
                 ok: dispatch.ok,
                 checkpointPath,
                 dispatchMessage: dispatch.message,
+                // T4 calibration: the exact denominator this dispatch divided by, so
+                // `beforeRatio * windowTokens` is the token point we asked for.
+                windowTokens: probe.capacityTokens ?? null,
+                windowSource: probe.capacitySource ?? null,
             },
         });
     }
@@ -527,7 +645,7 @@ export async function runAutoCompact(input) {
             : 'AUTO_COMPACT_DISPATCH_FAILED',
         message: dispatch.ok
             ? isRedLine
-                ? `RED-LINE compact dispatched (${dispatch.ide} / ${dispatch.pathway} / target=${target} / mode=${mode} — ${describeMode(mode)}); checkpoint at ${checkpointPath}. Further sub-agent dispatch is BLOCKED until ratio < 0.85.`
+                ? `RED-LINE: harness compact REQUESTED (${dispatch.ide} / ${dispatch.pathway} / target=${target} / mode=${mode} — ${describeMode(mode)}); checkpoint at ${checkpointPath}. Sub-agent dispatch is NOT blocked — keep working and re-probe with \`peaks code context-now\`.`
                 : `Auto-compact dispatched (${dispatch.ide} / ${dispatch.pathway} / target=${target} / mode=${mode} — ${describeMode(mode)}); checkpoint at ${checkpointPath}.`
             : `Auto-compact checkpoint written but IDE dispatch failed: ${dispatch.message}`,
         data: {
@@ -539,7 +657,10 @@ export async function runAutoCompact(input) {
             dispatch,
             target,
             mode,
-            redLineGated: isRedLine
+            redLineRequested: isRedLine,
+            redLineGated: isRedLine,
+            deprecatedFields: DEPRECATED_ENVELOPE_FIELDS,
+            harnessWindow
         }
     };
 }
@@ -550,6 +671,17 @@ export function appendCompactHistoryEvent(input) {
     const path = join(dir, 'compact-history.jsonl');
     appendFileSync(path, JSON.stringify(input.event) + '\n', 'utf8');
 }
+/**
+ * Best-effort variant for the post-compact measurement row. Telemetry must
+ * never change the probe's return envelope, so an append failure here is
+ * swallowed — same discipline as the dispatch-path append.
+ */
+function appendObservedCompactEvent(input) {
+    try {
+        appendCompactHistoryEvent(input);
+    }
+    catch { /* best-effort; the probe result is already settled */ }
+}
 // Keep dirname import live for symmetry with sibling services that
 // use it for path joins; tree-shaking removes it in builds.
 void dirname;

package/dist/services/code/compact-event-settle.d.ts

@@ -0,0 +1,122 @@
+/** The harness's own report of what caused a compaction. */
+export type CompactTrigger = 'manual' | 'auto';
+/**
+ * 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 declare const COMPACT_EVENT_PATHWAY = "post-compact-hook";
+/**
+ * One post-compact reading: the ratio, the window it was divided by, and the
+ * adapter that produced it — all from a SINGLE probe call, so the three cannot
+ * disagree with each other.
+ */
+export type PostCompactMeasurement = {
+    /** `null` = nothing could be measured. Never `0`, which means "unknown". */
+    readonly ratio: number | null;
+    readonly ide: string;
+    readonly windowTokens: number | null;
+    readonly windowSource: string | null;
+};
+export type CompactSettleResult = {
+    readonly settled: true;
+    readonly runId: string;
+    readonly beforeRatio: number;
+    /** The measured post-compact ratio, or `null` when none was trustworthy. */
+    readonly afterRatio: number | null;
+    /** Present only when the harness reported one. */
+    readonly trigger?: CompactTrigger;
+    /**
+     * False when the run settled but the `observed` row could not be
+     * appended. The settlement is the load-bearing half and is never undone
+     * for this, but the two outcomes are not the same fact.
+     */
+    readonly historyWritten: boolean;
+    /**
+     * False when the lifecycle record could not be written. The run is then
+     * still open, so a later probe will settle it from its own measurement —
+     * but the `observed` row is appended anyway, because the harness's
+     * statement is evidence independent of that write. The two failures are
+     * reported separately rather than collapsed: a caller that sees only one
+     * of them cannot say which half of the settlement landed.
+     */
+    readonly lifecycleWritten: boolean;
+} | {
+    readonly settled: false;
+    /**
+     * `nothing-to-settle` — there was no open run. `different-session` — the
+     * payload named a harness session that is not this project's, so the open
+     * run was left alone. The second is a refusal of ATTRIBUTION, not an
+     * absence of it, and a reader told "nothing was open" would be told
+     * something false.
+     */
+    readonly reason: 'nothing-to-settle' | 'different-session';
+};
+/**
+ * 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 declare function readTriggerFromHookPayload(payload: unknown): CompactTrigger | 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 declare function readSessionIdFromHookPayload(payload: unknown): string | 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 declare function measurePostCompact(input: {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+    readonly env: NodeJS.ProcessEnv;
+}): PostCompactMeasurement;
+/**
+ * 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 declare function settleCompactFromHarnessEvent(input: {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+    readonly trigger?: CompactTrigger | undefined;
+    /**
+     * The harness session id the payload named, when it named one (see
+     * `readSessionIdFromHookPayload`). Refused when it is present AND this
+     * project's own harness session id resolves AND the two differ. Absent, or
+     * unresolvable on this side, is accepted: a guard that cannot see what it is
+     * checking against must not become a hook that never settles anything.
+     */
+    readonly hookSessionId?: string | undefined;
+    readonly env?: NodeJS.ProcessEnv | undefined;
+    readonly measure?: (() => PostCompactMeasurement | null) | undefined;
+    /** Failure injection for the lifecycle write — the seam `CompactLifecyclePublisher` already takes. */
+    readonly failLifecycleWrite?: boolean | undefined;
+}): CompactSettleResult;