peaks-loop 4.0.44 → 4.0.46

package/CHANGELOG.md

@@ -1,5 +1,64 @@
 # Changelog
 
+## 4.0.46 — 2026-09-12 (85% 该压不压 + 把"派发"记成了"正在压缩")
+
+**Highlights**:
+
+1. **同一个 0.85–0.95 带，四份权威说法互相打架,而代码挑了那个"什么都不做"的。** `peaks code context-now` 对**单 rid** 会话把该带降级成 `soft-warn`（"仅建议"）；而**它自己的 help 文本**写着 *"≥0.85 emits action=auto-compact-now (**MANDATORY, not advisory**)"*；`peaks skill presence` 返回 `pre-compact`；`peaks-code` 的 SKILL.md 说该带 **auto-compact fires automatically** 并把 `context-now` 称作 **single source of truth**；你 2026-07-27 亲自校准的阈值策略写的是 **soft-mandatory**。
+
+   后果直接：一个**照着"唯一真相源"办事**的 LLM，在 0.85–0.95 里**永远不会压缩** —— 直接违反 zero-pause 契约。现在单 rid 与 job 模式一致：该带一律 `auto-compact-now`，并把过时的 notice/help 改成如实描述代码行为。
+
+2. **`compact-lifecycle.json` 把"已派发"记成了"正在压缩"，于是状态栏永久卡在 `stalled`。** claude-code 的 `ide-native` pathway **只在 ratio ≥ 0.95 才真的 in-band 压缩**（且 dispatcher 无论装没装上 hook 都返回 `ok: true`）；于是 0.85–0.95 区间里**什么都没有在飞**，记录却在 2 分钟后被判 stale，状态栏画一条永不前进的进度条并报 `stalled`。
+
+   **比显示错更严重的**：结算逻辑 `settleOpenLifecycleRun` 只在 **ratio 跌破阈值**时结算 —— 而那条 pathway 根本不会造成下跌，**所以 `afterRatio` 永远写不上，"压缩后 ratio 确实降了"这条验证链是死的**，而它正是 zero-pause 契约唯一的验收依据。
+
+   两半一起修，方式是**让记录说实话**：新增**静止态 `armed`**（含义是"触发器已设好，等 95% 的 in-band 时机"），并被**类型系统**排除在 `ACTIVE_STAGES` 之外 —— 只有承诺过心跳的 stage（`queued`/`preparing`/`compacting`/`verifying`）才可能 stall。状态栏据此渲染成 `◔ armed · 88% · fires at 95%`，**不画进度条**。而**真的卡住的 `compacting` 仍然正确报 `stalled`** —— 这条能力是实测确认保住的，不是假设。
+
+**验证**:三个版本常量一致(**4.0.46**);`tsc -p tsconfig.build.json` exit 0;宽 `tsconfig.json` 保持 **142** 基线;`tests/unit` **215 files / 2173 passed / 3 skipped / 0 failed**;`pnpm build` 的 `build-integrity` OK。
+
+**本轮顺带发现、尚未处理（不属本版修复）**:`tests/integration/**`（90 个文件）**从未进过 CI** —— `ci.yml` 的测试步骤是默认 config，其 `include` 只含 `tests/unit/**`；CI 里另有一个 job 只为单个文件特判。实测该套件 **10 files / 20 tests / 3 errors 红**。也就是说"CI 绿"与"全量绿"都**不覆盖这 90 个文件**。同一形状（一个看似覆盖全局的绿信号，实际有射程外的东西）已由 `a-diff-scoped-gate-reporting-zero-violations-may-have-checked-nothing` 记录在案。建议下一片专门处理，含那 20 个失败的分诊。
+
+## 4.0.45 — 2026-09-12 (一个永远无法通过的维度 + 一个验代理的守卫)
+
+**Highlights**:
+
+1. **4 维验收闸里有一维从构造上就不可能通过。** `existing-functionality-intact` 的契约要求一份 `pre-post-diff`（前后结构对比：测试面 / 公开 API 面），而**全仓没有任何东西生产它**。于是它被喂的是 `rd/tech-doc.md`（设计意图）与 `prd/handoff.md`（批准范围）—— 而这个模块自己的文件头注释，把"拿设计意图文档当回归评估"列为它存在的理由。结果：`allPass === true` 对**任何**工作流都不可达。
+
+   本版补上生产者（`pre-post-diff.ts`）：以 base ref 对比工作树，报**测试面**（文件数 / 用例数）、**源文件清单**、**公开 API 面**（顶层 `export` 语句数与名字集合），写入 `.peaks/_runtime/<sessionId>/final-review/api-diff.txt`。**诚实边界写在产物里**：export 检测是行锚定的近似，能发现"少了一个导出"这类结构丢失，**发现不了签名变更**。算不出 baseline 时**不产出 artifact、不编造 diff** —— 该维保持 `inconclusive`。
+
+2. **消费它的那个闸，键在"送达"，不在"产物存在"。** 独立复核连做七轮，每轮都在下一层找到同一个形状 —— 一个接受**代理**的闸（"评审者看到了吗"被替换成"磁盘上有吗"）：
+
+   | 轮 | 被判为"检查过了"的东西 |
+   |---|---|
+   | 1 | `status === 'computed'`（磁盘上有文件） |
+   | 2 | `status === 'found'`（≥1 字节送达） |
+   | 3 | `totalBytes === 0`（把 missing 与 empty 混为一谈） |
+
+   共同根因是：一个源**可以被部分内联**，于是"送达了吗"永远有一个律师式答案。现在分配器是 **per-source 全有或全无**（要么整份、要么 omitted，不存在截在中间），且 `isDelivered` 是这个问题**唯一的家** —— 每个源声明自己的送达规则：`whole`（整份文档；被截断过的文档是另一份文档）或 `conclusion`（一个**就是结论本身**的字面量）。
+
+3. **随之而来的两处实质变化，都要求诚实。**
+   - 证据预算改为**推导**（`10,240 = 总额 / 4`）而不是常量 —— 因为走 `whole` 规则的源一旦超过它，就**永远送不到**。
+   - 一个维度若其全部支撑源都装不下，现在会被**响亮报出**（prompt 里出 `## Evidence delivery reachability` 段、维度 summary 挂 `[delivery-reachability: …]` 标记、并进 `needsAttention`），而不是**静默地永远红**。**故意不抛错** —— 抛错会连带毁掉那三个本来可送达的维度。
+
+4. **反回归守卫本身，就是同一个形状的第 7 个实例 —— 且它一开始是坏的。** 初版守卫按**语法形状**切分源码（只认行首 `function name`），于是**箭头函数、生成器、`export default function`、类方法**一律不被扫描：**8 种等价写法全部放行**，端到端实测"顶层箭头里放 2 个代理字面量"仍 `3 passed EXIT=0`。**一个能放行 8/8 的守卫比没有守卫更糟** —— 它把"没人在看"变成"有东西在看"。
+
+   现在它用仓库自带的 `typescript` 解析 AST、读**函数体内**的 token，于是那 4 种形状绕过全部关闭（实测：往真实源码注入箭头式代理 → 守卫转红）。剩下 4 种**不含该字面量**的改写（拆变量 `const F='found'`、`==`、`item['status']`、字符串拼接）**仍然放行** —— 这一点被**固定成一条通过的测试**，让守卫**陈述自己的边界**而不是暗示一个。
+
+5. **`peaks codegraph status` 在真有缺口时会同时印出两行互相矛盾的话。** 退出码（74）与 `[FAIL]` 细节都是对的，但人第一眼看到的是：
+
+   ```
+   [OK] Index is up to date
+   [FAIL] codegraph index is incomplete: 2 of 1133 tracked source files are excluded …
+   ```
+
+   两个闸在回答不同的问题：上游答"图与上次扫描一致"（确实一致），peaks 答"图覆盖了仓库吗"（没有）。**都对，并排印出来就是矛盾。** 现在上游那行被**归因而非抑制**（措辞与统计保留，只是把它的适用范围说明白），只在这一行、且只在缺口门**确实触发**时改动；无缺口路径逐字节不变（含 ANSI），机器可读 envelope 未动。
+
+**验证**:三个版本常量一致(**4.0.45**);`tsc -p tsconfig.build.json` exit 0;宽 `tsconfig.json` 保持 **142** 基线;`tests/unit` **214 files / 2165 passed / 3 skipped / 0 failed**;`pnpm build` 的 `build-integrity` OK。
+
+**已知未修 / 边界**:`conclusion` 规则下超大的源不算"不可送达"（结论标记可能在截断点之后）;单一可送达源的**穿越前余量**（本 session 实测 748 B）**没有**告警，只报"已经不可能"的状态;4 维中的 `existing-functionality-intact` 在**非 git 项目**里永久 `inconclusive`（这是诚实结果，已写进 SKILL.md 与 `4-dimensions.md`）。
+
+**备注**:本版的 `prepare-final-review` 闸**未经过独立复核**（前六轮每一轮都经过并各找到 1 个 HIGH;第 7 轮由 orchestrator 自行验证,含箭头注入实测),这一点如实记录以便日后回溯。
+
 ## 4.0.44 — 2026-09-12 (被静默排除的源文件 + 一个验错东西的验收闸)
 
 **Highlights**:

package/README-en.md

@@ -140,7 +140,7 @@ Every lane opens with **one slash command**.
 
 | | |
 | --- | --- |
-| **Latest** | [![npm](https://img.shields.io/npm/v/peaks-loop?style=for-the-badge&logo=npm&logoColor=white&color=cb3837)](https://www.npmjs.com/package/peaks-loop) — 4.0.44 (2026-09-12) |
+| **Latest** | [![npm](https://img.shields.io/npm/v/peaks-loop?style=for-the-badge&logo=npm&logoColor=white&color=cb3837)](https://www.npmjs.com/package/peaks-loop) — 4.0.46 (2026-09-12) |
 | **Domains** | Code (`peaks-code`) · Content (`peaks-content`) · Project health (`peaks-doctor`) · Issue sweep (`peaks-issue-fix-orchestrator`) · Custom SOP (`peaks-sop`) · Cross-domain primitives (`peaks-solo` dispatcher · `peaks-resume` · `peaks-status` · `peaks-test` · `peaks-slice-decompose`) |
 | **Sediment pool** | `~/.peaks/` local pool · twice-clean runs auto-promote to a bee · broken runs come back for you to redefine · the bee grows with your taste |
 | **Test suite** | 285+ cases · 4 packages (peaks-loop / peaks-loop-mut / peaks-loop-shared-channel / peaks-loop-shared) · **0 timeouts** · 14 BDD caller-binding edge cases |

package/README.md

@@ -140,7 +140,7 @@ npm i -g peaks-loop
 
 | | |
 | --- | --- |
-| **最新版本** | [![npm](https://img.shields.io/npm/v/peaks-loop?style=for-the-badge&logo=npm&logoColor=white&color=cb3837)](https://www.npmjs.com/package/peaks-loop) — 4.0.44(2026-09-12) |
+| **最新版本** | [![npm](https://img.shields.io/npm/v/peaks-loop?style=for-the-badge&logo=npm&logoColor=white&color=cb3837)](https://www.npmjs.com/package/peaks-loop) — 4.0.46(2026-09-12) |
 | **覆盖域** | 代码(`peaks-code`) · 内容(`peaks-content`) · 项目健康(`peaks-doctor`) · 批量修 issue(`peaks-issue-fix-orchestrator`) · 自定义 SOP(`peaks-sop`) · 通用原语(`peaks-solo` 分诊 / `peaks-resume` 续 / `peaks-status` 看 / `peaks-test` 测 / `peaks-slice-decompose` 切片) |
 | **沉淀池** | `~/.peaks/` 本地池 · 跑两次自动晋升成 bee · 跑翻车让你重定义 · bee 跟着你的口味长 |
 | **测试套件** | 1096 cases · 4 packages (peaks-loop 1015 / runtime 39 / mut 22 / shared-channel 20) · **CI 首次全绿**(ubuntu + windows) · 14 BDD caller-binding coverage |

package/dist/cli/commands/code-runtime-commands.js

@@ -155,16 +155,18 @@ export function registerCodeRuntimeCommands(code, io) {
         'Adapter-driven (no hard-coded IDE names): Claude Code is the MVP ' +
         'implementation; trae / codex / cursor / qoder / tongyi-lingma / ' +
         'hermes / openclaw register their own env-var via IdeAdapter.compact. ' +
-        'v3.1.2: when --enforce-job-mode is set OR job-shape.json says isJob=true, ' +
-        '≥0.85 emits action=auto-compact-now (MANDATORY, not advisory) and ' +
+        'v3.1.2 / 2026-09-12: ≥0.85 emits action=auto-compact-now ' +
+        '(MANDATORY in every mode — single-rid included) and ' +
         '≥0.95 emits action=red-line (forced hook fires next turn). ' +
+        '--enforce-job-mode only changes the reported `jobMode` label; ' +
+        'the thresholds are identical. ' +
         'Context-window override: set env PEAKS_CONTEXT_WINDOW_TOKENS=<positive int> ' +
         'or `peaks config set --key context.windowTokens --value <positive int>`; ' +
         'the JSON envelope reports the winning layer as capacitySource ' +
         '(env-override | config | model-heuristic | default).')
         .requiredOption('--project <path>', 'target project root')
         .option('--session-id <sid>', 'override session id (default: read from active presence)')
-        .option('--enforce-job-mode', 'v3.1.2: treat ≥0.85 as MANDATORY auto-compact (not advisory). Auto-enabled when job-shape.json says isJob=true.')
+        .option('--enforce-job-mode', 'v3.1.2: label the run as Job-shaped (jobMode=true). Auto-enabled when job-shape.json says isJob=true. Since 2026-09-12 the ≥0.85 MANDATORY auto-compact applies in single-rid mode too, so this flag no longer changes any action.')
         .option('--prompt-size <bytes>', 'override the bytes-from-env path; takes priority over env / statusline / transcript. Useful when CLAUDE_CONTEXT_USAGE_PERCENT is absent (e.g. Mac Claude Code).')).action(async (opts) => {
         try {
             const { readContextPercent } = await import('../../services/context/auto-compact-reader.js');
@@ -210,17 +212,21 @@ export function registerCodeRuntimeCommands(code, io) {
             let action = 'ok';
             let next = null;
             if (probe.ratio >= 0.95) {
-                action = isJobMode ? 'red-line' : 'red-line';
+                action = 'red-line';
                 next = 'peaks code auto-compact';
             }
             else if (probe.ratio >= 0.85) {
-                if (isJobMode) {
-                    action = 'auto-compact-now';
-                    next = 'peaks code auto-compact';
-                }
-                else {
-                    action = 'soft-warn';
-                }
+                // Slice 2026-09-12-compact-band-policy (defect A): the
+                // 0.85–0.95 band is MANDATORY auto-compact for single-rid
+                // sessions too. It used to be downgraded to `soft-warn` here,
+                // which contradicted this command's own help text, the
+                // `pre-compact` action from `peaks skill presence`, the
+                // peaks-code SKILL.md, and the 2026-07-27 user-calibrated
+                // threshold policy — and left an LLM that follows the "single
+                // source of truth" (`context-now`) never compacting in the
+                // zone, violating the zero-pause contract.
+                action = 'auto-compact-now';
+                next = 'peaks code auto-compact';
             }
             else if (probe.ratio >= 0.5) {
                 action = 'soft-warn';
@@ -229,9 +235,16 @@ export function registerCodeRuntimeCommands(code, io) {
                 : action === 'auto-compact-now' ? 'pre-compact'
                     : action === 'soft-warn' ? 'soft-warn'
                         : 'ok';
-            const jobModeNotice = isJobMode
-                ? 'Job mode enforced: ≥0.85 is MANDATORY auto-compact (v3.1.2).'
-                : 'Advisory mode (single-rid): ≥0.85 is recommended, not mandatory.';
+            // Slice 2026-09-12-compact-band-policy: the two modes no longer
+            // differ in behaviour ABOVE 0.50 — both auto-fire at ≥0.85 and
+            // both red-line at ≥0.95 — so the old "advisory mode
+            // (single-rid)" notice was a lie the moment the downgrade was
+            // removed. Job mode's remaining difference is that its threshold
+            // policy is recorded up front (`job-shape.json`), which the
+            // `jobMode` field already reports. The notice now says only that.
+            const gateModeNotice = isJobMode
+                ? 'Job mode (job-shape.json isJob=true): the same ≥0.85 / ≥0.95 thresholds apply, and the decision is recorded in job-shape.json.'
+                : 'Single-rid mode: the same ≥0.85 / ≥0.95 thresholds apply — ≥0.85 is MANDATORY auto-compact, not advisory.';
             printResult(io, ok('code.context-now', {
                 ratio: probe.ratio,
                 ratioPct: `${ratioPct}%`,
@@ -255,13 +268,11 @@ export function registerCodeRuntimeCommands(code, io) {
                 action === 'red-line'
                     ? `RED LINE: ≥ 95%. Next: \`${next}\` (PreToolUse hook fires next turn).`
                     : action === 'auto-compact-now'
-                        ? `Job-mode MANDATORY auto-compact. Code MUST call \`${next}\` WITHOUT confirmation.`
+                        ? `MANDATORY auto-compact (≥85%, every mode). Code MUST call \`${next}\` WITHOUT confirmation.`
                         : action === 'soft-warn'
-                            ? isJobMode
-                                ? `Job mode soft-warn (50–85%). Continue working; the next \`peaks code auto-compact\` will re-check.`
-                                : `Soft warn (50–85%). Continue working; the next \`peaks code auto-compact\` will re-check.`
+                            ? `Soft warn (50–85%). Continue working; the next \`peaks code auto-compact\` will re-check.`
                             : `Below 50%. No action required.`,
-                jobModeNotice
+                gateModeNotice
             ]), true);
         }
         catch (err) {

package/dist/cli/commands/codegraph-commands.d.ts

@@ -10,4 +10,5 @@ import { type ProgramIO } from '../cli-helpers.js';
  * untouched.
  */
 export declare function rewriteBareCodegraphHints(text: string): string;
+export declare function attributeUpstreamUpToDateLine(stdout: string): string;
 export declare function registerCodegraphCommands(program: Command, io: ProgramIO): void;

package/dist/cli/commands/codegraph-commands.js

@@ -38,7 +38,48 @@ function printCodegraphFailure(io, command, error, asJson, exitCode = 1) {
 export function rewriteBareCodegraphHints(text) {
     return text.replace(/(?<![\w-])(?<!peaks\s)codegraph(?=\s+(?:status|init|index|query|files|context|affected)\b)/g, 'peaks codegraph');
 }
-async function runCodegraphCommand(io, command, options, asJson) {
+const ANSI_SGR_PATTERN = /\x1b\[[0-9;]*m/g;
+/**
+ * Upstream `status` answers a different question than peaks-loop's
+ * integrity gate: upstream says "the on-disk graph matches the last scan"
+ * (true), peaks says "that graph covers the repository" (false when rules
+ * exclude tracked files). Both verdicts are correct, but an unqualified
+ * `[OK] Index is up to date` printed above our `[FAIL] ...` reads as
+ * "nothing to see here" — and the OK is the line the eye lands on first.
+ * The exit code and the JSON envelope are already right; only this line
+ * lies by juxtaposition.
+ *
+ * So: keep upstream's wording — the line stays recognizable, and the
+ * Files/Nodes counts around it are untouched — but drop the bare OK
+ * marker and name the only question it answers. Clean runs never reach
+ * this, so their output stays byte-identical.
+ *
+ * The match is anchored to THAT line. An earlier version keyed on
+ * `includes('up to date')`, which is content-blind: upstream prints other
+ * `[OK] ... are up to date` lines (a language-server or watcher line is the
+ * observed one), and each of those was rewritten into a claim about the
+ * INDEX — a misattribution introduced by a change whose entire purpose was
+ * to stop misleading output. Anything that is not the index line is passed
+ * through byte-for-byte, tail note and all.
+ */
+const INDEX_UP_TO_DATE_RE = /^\[OK\]\s+Index is up to date\b/i;
+export function attributeUpstreamUpToDateLine(stdout) {
+    return stdout
+        .split('\n')
+        .map((line) => {
+        const visible = line.replace(ANSI_SGR_PATTERN, '').trim();
+        if (!INDEX_UP_TO_DATE_RE.test(visible)) {
+            return line;
+        }
+        // Only the OK marker is downgraded and the attribution appended: the
+        // rest of the line — including whatever upstream wrote after it — is
+        // preserved, so nothing upstream actually said is replaced.
+        const withoutOk = visible.replace(/^\[OK\]\s*/, '');
+        return `[i] ${withoutOk} (upstream: matches the last scan only; repository coverage is answered below)`;
+    })
+        .join('\n');
+}
+async function runCodegraphCommand(io, command, options, asJson, attributeStdout) {
     try {
         const invocation = createCodegraphInvocation(options);
         const result = await executeCodegraphInvocation(invocation);
@@ -47,7 +88,8 @@ async function runCodegraphCommand(io, command, options, asJson) {
             return;
         }
         const didFail = result.exitCode !== null && result.exitCode !== 0;
-        const stdout = rewriteBareCodegraphHints(result.stdout);
+        const rewritten = rewriteBareCodegraphHints(result.stdout);
+        const stdout = attributeStdout === undefined ? rewritten : attributeStdout(rewritten);
         const stderr = rewriteBareCodegraphHints(result.stderr);
         if (stdout.length > 0) {
             io.stdout((didFail ? redactSensitiveErrorMessage(stdout) : stdout).trimEnd());
@@ -132,7 +174,11 @@ async function runCodegraphStatusCommand(io, options, asJson) {
         await runCodegraphStatusJson(io, options, integrity, integrityWarning);
     }
     else {
-        await runCodegraphCommand(io, 'codegraph.status', { subcommand: 'status', project: options.project });
+        // Only when the gate found a gap: upstream's `[OK] Index is up to
+        // date` answers "consistent with the last scan", and printing it
+        // unqualified right above our `[FAIL]` tells the reader two opposite
+        // things at once. Clean runs get no transform and stay byte-identical.
+        await runCodegraphCommand(io, 'codegraph.status', { subcommand: 'status', project: options.project }, false, integrity?.gap === true ? attributeUpstreamUpToDateLine : undefined);
         if (integrityWarning !== null) {
             io.stdout(`[WARN] codegraph exclude integrity not evaluated: ${integrityWarning}`);
         }

package/dist/cli/commands/final-review-commands.js

@@ -113,7 +113,8 @@ export function registerFinalReviewCommands(program, io) {
         .description('Prepare the 4-dimension business review (final-review primitive) for human acceptance (W2 T9 service; CLI surface in W5 M2)')
         .requiredOption('--project <path>', 'target project root')
         .requiredOption('--session-id <sid>', 'session id whose .peaks/_runtime/<sid>/audit-goal/<rid>.json is the approved goal source')
-        .option('--llm-provider <name>', `LLM provider name: ${SUPPORTED_LLM_PROVIDERS.join(' | ')} (default: ${DEFAULT_LLM_PROVIDER} — performs no review)`, DEFAULT_LLM_PROVIDER)).action(async (rid, options) => {
+        .option('--llm-provider <name>', `LLM provider name: ${SUPPORTED_LLM_PROVIDERS.join(' | ')} (default: ${DEFAULT_LLM_PROVIDER} — performs no review)`, DEFAULT_LLM_PROVIDER)
+        .option('--base <ref>', 'base ref for the pre/post baseline diff (`existing-functionality-intact`); default: merge-base with origin/HEAD, then origin/main, then origin/master, then HEAD~1 — pass this explicitly when none of those resolve')).action(async (rid, options) => {
         // 1. Project root must exist and be a directory.
         const projectValidation = validateProjectRoot(options.project);
         if (!projectValidation.ok) {
@@ -192,6 +193,7 @@ export function registerFinalReviewCommands(program, io) {
                 projectRoot: projectValidation.projectRoot,
                 sessionId: sessionValidation.sessionId,
                 llmRunner,
+                ...(options.base === undefined ? {} : { baseRef: options.base }),
             });
             const data = {
                 status: 'review-complete',

package/dist/services/code/auto-compact-lifecycle.d.ts

@@ -16,8 +16,35 @@ import { type CompactLifecycleRecord, type CompactLifecycleStage } from '../comp
  * Stages a compact *attempt* can prove from inside the dispatching
  * process. `verifying` / `completed` are deliberately absent — see
  * `CompactLifecyclePublisher` and `settleOpenLifecycleRun` for why.
+ *
+ * `armed` is the honest resting stage for a dispatch that only
+ * REGISTERED a trigger (slice 2026-09-12-compact-band-policy, defect B)
+ * — see `resolveDispatchedStage`.
+ */
+type ObservableDispatchStage = Extract<CompactLifecycleStage, 'queued' | 'preparing' | 'compacting' | 'armed'>;
+/** Stage a failure is attributed to (mirrors the store's `failedAt` domain). */
+type FailableStage = Exclude<CompactLifecycleStage, 'failed' | 'completed'>;
+/**
+ * Slice 2026-09-12-compact-band-policy (defect B): which stage a
+ * *successful* dispatch can honestly claim.
+ *
+ * A dispatch is only evidence that a compact is IN FLIGHT when the
+ * adapter's own trigger is already satisfied. claude-code's
+ * `ide-native` pathway installs a PreToolUse hook that compacts
+ * in-band at ratio ≥ 0.95 (`AUTO_COMPACT_RED_LINE_RATIO`); at or above
+ * that ratio the very next tool call fires it, so `compacting` (and
+ * therefore `stalled` if it never lands) is the truthful reading.
+ *
+ * Below it — and for every pathway that only writes an intent
+ * (`llm-self-compress`), or whose shell-exec branch is a deprecated
+ * no-op — NOTHING is compacting. The process merely ARMED a trigger.
+ * Recording `compacting` there published a heartbeat nobody would ever
+ * send, which is what pinned the statusline at `stalled` forever.
  */
-type ObservableDispatchStage = Extract<CompactLifecycleStage, 'queued' | 'preparing' | 'compacting'>;
+export declare function resolveDispatchedStage(input: {
+    readonly pathway: string;
+    readonly ratio: number;
+}): Extract<CompactLifecycleStage, 'compacting' | 'armed'>;
 /**
  * One id per compact attempt. Timestamp-prefixed so a human reading
  * the raw record can order runs by eye; the random suffix keeps two
@@ -53,8 +80,17 @@ export declare class CompactLifecyclePublisher {
     });
     /** Publish an active stage the process has proved. */
     advance(stage: ObservableDispatchStage): void;
-    /** Publish the terminal failure, attributed to the last stage reached. */
-    fail(error: unknown): void;
+    /**
+     * Publish the terminal failure, attributed to the last stage reached.
+     *
+     * `at` overrides that attribution for the case where the failure
+     * happened INSIDE a phase that is only named after its outcome
+     * (slice 2026-09-12-compact-band-policy): the dispatch call is the
+     * compacting phase even though the resting stage is now chosen from
+     * the pathway the dispatch returned. `failedAt` names the phase the
+     * attempt died in — it is not a published heartbeat.
+     */
+    fail(error: unknown, at?: FailableStage): void;
     private write;
 }
 /**

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

@@ -12,6 +12,7 @@
  * returned envelope.
  */
 import { readCompactLifecycle, writeCompactLifecycle } from '../compact-statusline/compact-lifecycle-store.js';
+import { AUTO_COMPACT_RED_LINE_RATIO } from '../context/auto-compact-types.js';
 /**
  * PRD-002b slice 2 — extract the few cross-cutting magic numbers
  * that actually appear at runtime call sites in this orchestrator.
@@ -20,6 +21,28 @@ import { readCompactLifecycle, writeCompactLifecycle } from '../compact-statusli
  * + spec prose references must keep the literal value visible.
  */
 const COLLAPSED_ERROR_MAX_CHARS = 160;
+/**
+ * Slice 2026-09-12-compact-band-policy (defect B): which stage a
+ * *successful* dispatch can honestly claim.
+ *
+ * A dispatch is only evidence that a compact is IN FLIGHT when the
+ * adapter's own trigger is already satisfied. claude-code's
+ * `ide-native` pathway installs a PreToolUse hook that compacts
+ * in-band at ratio ≥ 0.95 (`AUTO_COMPACT_RED_LINE_RATIO`); at or above
+ * that ratio the very next tool call fires it, so `compacting` (and
+ * therefore `stalled` if it never lands) is the truthful reading.
+ *
+ * Below it — and for every pathway that only writes an intent
+ * (`llm-self-compress`), or whose shell-exec branch is a deprecated
+ * no-op — NOTHING is compacting. The process merely ARMED a trigger.
+ * Recording `compacting` there published a heartbeat nobody would ever
+ * send, which is what pinned the statusline at `stalled` forever.
+ */
+export function resolveDispatchedStage(input) {
+    return input.pathway === 'ide-native' && input.ratio >= AUTO_COMPACT_RED_LINE_RATIO
+        ? 'compacting'
+        : 'armed';
+}
 /**
  * One id per compact attempt. Timestamp-prefixed so a human reading
  * the raw record can order runs by eye; the random suffix keeps two
@@ -100,8 +123,17 @@ export class CompactLifecyclePublisher {
             redLine: this.ctx.redLine
         });
     }
-    /** Publish the terminal failure, attributed to the last stage reached. */
-    fail(error) {
+    /**
+     * Publish the terminal failure, attributed to the last stage reached.
+     *
+     * `at` overrides that attribution for the case where the failure
+     * happened INSIDE a phase that is only named after its outcome
+     * (slice 2026-09-12-compact-band-policy): the dispatch call is the
+     * compacting phase even though the resting stage is now chosen from
+     * the pathway the dispatch returned. `failedAt` names the phase the
+     * attempt died in — it is not a published heartbeat.
+     */
+    fail(error, at) {
         this.write({
             schemaVersion: 1,
             runId: this.ctx.runId,
@@ -109,7 +141,7 @@ export class CompactLifecyclePublisher {
             updatedAt: new Date().toISOString(),
             triggerRatio: this.ctx.triggerRatio,
             redLine: this.ctx.redLine,
-            failedAt: this.lastStage,
+            failedAt: at ?? this.lastStage,
             errorSummary: summarizeLifecycleError(error)
         });
     }
@@ -197,9 +229,12 @@ export function settleOpenLifecycleRun(input) {
     });
     if (prior === null)
         return;
-    // Only a run that was actually dispatched (`compacting`) can be
-    // completed by a post-compact measurement.
-    if (prior.stage !== 'compacting')
+    // Only a run that was actually dispatched can be completed by a
+    // post-compact measurement. Both `compacting` (the in-band trigger is
+    // satisfied) and `armed` (a trigger was registered and could fire at
+    // any time) qualify: the measured drop is proof that SOME compact
+    // landed, and this is the only open run to attribute it to.
+    if (prior.stage !== 'compacting' && prior.stage !== 'armed')
         return;
     const emit = (stage, withAfterRatio) => {
         const record = {

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

@@ -35,7 +35,7 @@ import { resolveOuterSessionId } from '../session/binding-status-service.js';
 import { AUTO_COMPACT_PRE_COMPACT_RATIO } 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, settleOpenLifecycleRun, summarizeLifecycleError } from './auto-compact-lifecycle.js';
+import { CompactLifecyclePublisher, 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
@@ -435,10 +435,6 @@ export async function runAutoCompact(input) {
     const target = input.target ?? 'main';
     let dispatch;
     try {
-        // `compacting` is the last stage this process can prove: the IDE
-        // performs the actual compaction out-of-band, so a successful
-        // dispatch return is NOT evidence the context shrank.
-        lifecycle.advance('compacting');
         if (input.testHooks?.failCompacting)
             throw new Error('IDE dispatch exploded');
         // Slice 2026-06-28: when targeting the main session, write an
@@ -463,7 +459,9 @@ export async function runAutoCompact(input) {
         });
     }
     catch (error) {
-        lifecycle.fail(error);
+        // `compacting` is the phase this failure died in — a phase label,
+        // not a claim that a compaction was in flight.
+        lifecycle.fail(error, 'compacting');
         return {
             ok: false,
             code: 'AUTO_COMPACT_DISPATCH_FAILED',
@@ -480,11 +478,22 @@ export async function runAutoCompact(input) {
             }
         };
     }
-    // A dispatcher that returns `ok: false` did not compact anything —
-    // record that as a failure at `compacting` rather than leaving the
-    // run looking like it is still in progress.
-    if (!dispatch.ok) {
-        lifecycle.fail(new Error(dispatch.message));
+    // Slice 2026-09-12-compact-band-policy (defect B): the stage is
+    // chosen from what the dispatch ACTUALLY did, never from the hope
+    // that it compacted. `ide-native` on claude-code only installs a
+    // PreToolUse hook that fires at ratio ≥ 0.95 — below that nothing is
+    // in flight and the honest stage is `armed` (see
+    // `resolveDispatchedStage`). Writing `compacting` there published a
+    // heartbeat that would never arrive, which is exactly what pinned
+    // the statusline at `stalled` for 92 minutes in the field.
+    if (dispatch.ok) {
+        lifecycle.advance(resolveDispatchedStage({ pathway: dispatch.pathway, ratio: probe.ratio }));
+    }
+    else {
+        // A dispatcher that returns `ok: false` did not compact anything —
+        // record that as a failure at `compacting` rather than leaving the
+        // run looking like it is still in progress.
+        lifecycle.fail(new Error(dispatch.message), 'compacting');
     }
     // Slice 2026-07-30-compact-visibility: append a compact-history
     // event so the new 'peaks compact history' CLI and the

package/dist/services/compact-statusline/compact-lifecycle-store.d.ts

@@ -1,4 +1,12 @@
-export type CompactLifecycleStage = 'queued' | 'preparing' | 'compacting' | 'verifying' | 'completed' | 'failed';
+export type CompactLifecycleStage = 'queued' | 'preparing' | 'compacting'
+/**
+ * Slice 2026-09-12-compact-band-policy: a compact trigger was
+ * REGISTERED but no compaction has started — e.g. claude-code's
+ * `ide-native` pathway only installs the PreToolUse hook, which
+ * compacts in-band at ratio ≥ 0.95. In the 0.80–0.95 band nothing
+ * is in flight, so claiming `compacting` was a false heartbeat.
+ */
+ | 'armed' | 'verifying' | 'completed' | 'failed';
 export interface CompactLifecycleRecord {
     readonly schemaVersion: 1;
     readonly runId: string;
@@ -49,7 +57,8 @@ export declare function writeCompactLifecycle(input: {
  * Return kinds:
  *   - `missing`  — no record has ever been written for this session
  *   - `valid`    — record parsed and validated; stage is terminal
- *                  (completed/failed) OR is active but still fresh
+ *                  (completed/failed), resting (`armed`) OR is active
+ *                  but still fresh
  *   - `invalid`  — file exists but is malformed / wrong schema / out
  *                  of range. `reason` is a single-line English message
  *                  (no CLI verbs, no stack traces). The caller MUST

package/dist/services/compact-statusline/compact-lifecycle-store.js

@@ -19,11 +19,27 @@
 // compacting / verifying) is `stalled` when (nowMs - updatedAt) >
 // staleAfterMs. Terminal stages (`completed`, `failed`) NEVER go
 // stalled — the record is the historical answer, not a heartbeat.
+//
+// Slice 2026-09-12-compact-band-policy (defect B): `armed` is a third
+// category — a RESTING stage. It records a fact ("we registered a
+// compact trigger") that stays true until a measurement supersedes it;
+// no heartbeat was ever promised, so waiting in it is NORMAL and it
+// must never be reported as `stalled`. Only `compacting` means "a
+// compaction should be in flight right now", which is the only state
+// where a missing heartbeat is real evidence of a stall.
 import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { getSessionDir } from '../session/getSessionDir.js';
 const LIFECYCLE_FILENAME = 'compact-lifecycle.json';
 const ERROR_SUMMARY_MAX = 160;
+/**
+ * Stages that promise a heartbeat: each one is only written while the
+ * dispatching process (or the IDE it armed) is expected to make
+ * progress, so a stale `updatedAt` is real evidence of a stall.
+ *
+ * `armed` is deliberately NOT here — see the header. It is a resting
+ * state, not a heartbeat.
+ */
 const ACTIVE_STAGES = [
     'queued',
     'preparing',
@@ -34,6 +50,7 @@ const ALL_STAGES = [
     'queued',
     'preparing',
     'compacting',
+    'armed',
     'verifying',
     'completed',
     'failed',
@@ -169,7 +186,8 @@ export function writeCompactLifecycle(input) {
  * Return kinds:
  *   - `missing`  — no record has ever been written for this session
  *   - `valid`    — record parsed and validated; stage is terminal
- *                  (completed/failed) OR is active but still fresh
+ *                  (completed/failed), resting (`armed`) OR is active
+ *                  but still fresh
  *   - `invalid`  — file exists but is malformed / wrong schema / out
  *                  of range. `reason` is a single-line English message
  *                  (no CLI verbs, no stack traces). The caller MUST

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

@@ -1,5 +1,5 @@
 import { type CompactLifecycleStage } from './compact-lifecycle-store.js';
-export type CompactDisplayKind = 'none' | 'queued' | 'preparing' | 'compacting' | 'verifying' | 'completed' | 'failed' | 'stalled' | 'invalid';
+export type CompactDisplayKind = 'none' | 'queued' | 'preparing' | 'compacting' | 'verifying' | 'completed' | 'failed' | 'stalled' | 'invalid' | 'armed';
 export interface CompactStatuslineState {
     readonly kind: CompactDisplayKind;
     readonly filledCells: 0 | 2 | 4 | 6 | 8;

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

@@ -28,6 +28,9 @@
 //   none       → 0 cells
 //   invalid    → 0 cells (no false reassurance)
 //   stalled    → keep the active stage's cell
+//   armed      → NO bar at all (slice 2026-09-12-compact-band-policy):
+//                a registered-but-idle trigger has no progress to
+//                report, and a bar would imply one.
 //
 // Render contract: the rendered label is a fixed-width 8-cell bar
 // (`[████░░░░]` filled from the left). NO `?` characters. NO guessed
@@ -36,6 +39,7 @@
 // measurement" hint.
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { getSessionDir } from '../session/getSessionDir.js';
+import { AUTO_COMPACT_RED_LINE_RATIO } from '../context/auto-compact-types.js';
 import { readCompactLifecycle, } from './compact-lifecycle-store.js';
 /**
  * Concrete first-version stale timeout. Adjustable after real timing
@@ -70,6 +74,8 @@ const CELL_BY_STAGE = new Map([
     ['verifying', STAGE_CELL_VERIFYING],
     ['completed', STAGE_CELL_COMPLETED],
     ['failed', STAGE_CELL_COMPACTING],
+    // `armed` is not in the cell table: it renders WITHOUT a bar (see
+    // renderCompactStatusline). Lookups therefore miss and fall back to 0.
 ]);
 const FILLED = '█';
 const EMPTY = '░';
@@ -245,6 +251,12 @@ export function renderCompactStatusline(state) {
             return `compact ${renderBar(2)}`;
         case 'compacting':
             return `compact ${renderBar(STAGE_CELL_COMPACTING)}`;
+        // Slice 2026-09-12-compact-band-policy: a registered trigger that has
+        // not fired is NOT progress. Rendering a bar would imply movement
+        // that is not happening, so `armed` deliberately renders no bar at
+        // all — the label states what is true and what would change it.
+        case 'armed':
+            return `compact armed${formatArmedRatio(state)} — fires in-band at ${arRedLinePct()}`;
         case 'verifying':
             return `compact ${renderBar(STAGE_CELL_VERIFYING)}`;
         case 'completed':
@@ -257,6 +269,16 @@ export function renderCompactStatusline(state) {
             return formatInvalid(state);
     }
 }
+/** The red-line ratio the armed trigger waits for, as a display percentage. */
+function arRedLinePct() {
+    return `${Math.round(AUTO_COMPACT_RED_LINE_RATIO * 100)}%`;
+}
+/** ` (88% now)` when the opening trigger ratio is known; empty otherwise. */
+function formatArmedRatio(state) {
+    return typeof state.triggerRatio === 'number'
+        ? ` (${Math.round(state.triggerRatio * 100)}% now)`
+        : '';
+}
 function formatCompleted(state) {
     const bar = renderBar(STAGE_CELL_COMPLETED);
     if (typeof state.afterRatio === 'number') {