peaks-loop 4.0.45 → 4.0.46

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # 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**:

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.45 (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.45(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/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') {

package/dist/services/skills/skill-statusline-renderer.js

@@ -1,4 +1,5 @@
 import { basename } from 'node:path';
+import { AUTO_COMPACT_RED_LINE_RATIO } from '../context/auto-compact-types.js';
 import { computeRootSuffix as computeRootSuffixImpl, } from './skill-statusline-sid-suffix.js';
 // Re-export so existing test imports
 // (`import { formatShortSid, computeRootSuffix } from '.../skill-statusline-renderer'`)
@@ -181,6 +182,10 @@ function formatRatio(value) {
  *
  *   <stage-glyph> <bar> <label>[ · <before>%][ → <after>%]
  *
+ * `armed` is the one exception: it renders WITHOUT the bar
+ * (`<glyph> armed · <before>% · fires at <redLine>%`) because a bar is
+ * a progress claim and a registered-but-unfired trigger has no progress.
+ *
  * Failed states additionally suffix the stage at which the compact failed.
  * Stalled states keep the active-stage cell count and render a plain
  * "stalled" label. Invalid states surface the read-reason verbatim as a
@@ -202,6 +207,16 @@ function renderCompact(state, palette) {
             return `${palette.compact.compacting} ${renderCompactBar(4, palette)} compacting${typeof state.triggerRatio === 'number'
                 ? `${palette.inlineSeparator}${formatRatio(state.triggerRatio)}`
                 : ''}`;
+        case 'armed': {
+            // Slice 2026-09-12-compact-band-policy: NO bar. A bar is a
+            // progress claim, and a registered-but-unfired trigger has no
+            // progress to report — it is waiting for the ratio to reach the
+            // red line on its own. Say exactly that instead.
+            const now = typeof state.triggerRatio === 'number'
+                ? `${palette.inlineSeparator}${formatRatio(state.triggerRatio)}`
+                : '';
+            return `${palette.compact.armed} armed${now}${palette.inlineSeparator}fires at ${formatRatio(AUTO_COMPACT_RED_LINE_RATIO)}`;
+        }
         case 'verifying':
             return `${palette.compact.verifying} ${renderCompactBar(6, palette)} verifying`;
         case 'completed':
@@ -518,7 +533,14 @@ export function renderStatusLine(model, options, env) {
     const compactSegment = renderCompact(model.compact, palette);
     let line;
     const hasCompact = compactSegment.length > 0;
-    if (hasCompact) {
+    // Slice 2026-09-12-compact-band-policy: `armed` is a RESTING state, not
+    // an in-flight compact. It can hold for the whole band between the
+    // auto-fire ratio and the red line, so it is appended to the normal
+    // line instead of REPLACING the skill token — hiding which skill is
+    // active for many turns would be a regression the user never asked
+    // for. Every other (genuinely in-flight) stage keeps replacing it.
+    const armedOnly = model.compact.kind === 'armed';
+    if (hasCompact && !armedOnly) {
         // Compact state replaces the active / stale / idle skill content.
         // `invalid-presence` still surfaces its own diagnostic when compact
         // is also `invalid` (the compact diagnostic wins, since it's the
@@ -526,21 +548,24 @@ export function renderStatusLine(model, options, env) {
         line = `${brand} ${compactSegment}${rootSuffix}`;
     }
     else {
+        let base;
         switch (model.state) {
             case 'active':
-                line = `${brand} ${renderActive(model.presence, palette, nowMs, capability, noColor, model.activeLeaf, model.twentyFourHourState)}${rootSuffix}`;
+                base = renderActive(model.presence, palette, nowMs, capability, noColor, model.activeLeaf, model.twentyFourHourState);
                 break;
             case 'stale':
-                line = `${brand} ${renderStale(model.presence, model.ageMs, palette, capability, noColor)}${rootSuffix}`;
+                base = renderStale(model.presence, model.ageMs, palette, capability, noColor);
                 break;
             case 'invalid-presence':
-                line = `${brand} ${renderInvalid(palette)}${rootSuffix}`;
+                base = renderInvalid(palette);
                 break;
             case 'idle':
             default:
-                line = `${brand} ${renderIdle(palette)}${rootSuffix}`;
+                base = renderIdle(palette);
                 break;
         }
+        const armedSuffix = armedOnly ? `${palette.inlineSeparator}${compactSegment}` : '';
+        line = `${brand} ${base}${armedSuffix}${rootSuffix}`;
     }
     // Marquee is OFF for idle (and only idle). Compact states always
     // carry the band because the compact bar IS the headline. NO_COLOR

package/dist/services/skills/statusline-palette.d.ts

@@ -35,6 +35,12 @@ interface CompactPalette {
     readonly queued: string;
     readonly preparing: string;
     readonly compacting: string;
+    /**
+     * Slice 2026-09-12-compact-band-policy: a trigger is registered but no
+     * compaction is running. Rendered WITHOUT a bar — see
+     * `renderCompact` in skill-statusline-renderer.ts.
+     */
+    readonly armed: string;
     readonly verifying: string;
     readonly completed: string;
     readonly failed: string;

package/dist/services/skills/statusline-palette.js

@@ -117,7 +117,7 @@ function buildPalette(capability, noColor) {
             idleLabel: 'empty',
             invalidMessage: 'presence unreadable',
             compact: {
-                queued: '[', preparing: '+', compacting: '+', verifying: '+',
+                queued: '[', preparing: '+', compacting: '+', armed: '~', verifying: '+',
                 completed: '*', failed,
             },
             barFilled: '#',
@@ -142,6 +142,9 @@ function buildPalette(capability, noColor) {
             queued: brandGlyph('◐'),
             preparing: brandGlyph('◑'),
             compacting: brandGlyph('◒'),
+            // Distinct from `compacting` on purpose: "waiting for the trigger"
+            // must not wear the same face as "a compact is in flight".
+            armed: brandGlyph('◔'),
             verifying: brandGlyph('◓'),
             completed: brandGlyph('✓'),
             failed,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-loop",
-  "version": "4.0.45",
+  "version": "4.0.46",
   "description": "Loop Engineering CLI — workflow primitive / loop guards / evaluators / slice orchestration",
   "author": "SquabbyZ",
   "keywords": [
@@ -102,10 +102,10 @@
     "picomatch": "4.0.4",
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "peaks-loop-mut": "0.1.43",
-    "peaks-loop-shared-channel": "0.0.47",
-    "peaks-loop-internal-runtime": "0.0.30",
-    "peaks-loop-shared": "0.0.79"
+    "peaks-loop-internal-runtime": "0.0.31",
+    "peaks-loop-shared": "0.0.80",
+    "peaks-loop-shared-channel": "0.0.48",
+    "peaks-loop-mut": "0.1.44"
   },
   "devDependencies": {
     "@changesets/cli": "2.31.1",

package/skills/peaks-code/SKILL.md

@@ -185,7 +185,7 @@ Before the first planning action, run `peaks fresh-context preflight --prompt "<
 1. **PreToolUse hook — `peaks code gate-step-08`.** Installed by `peaks workspace init` on the `Bash` matcher; checks `job-shape.json` presence + fail-closed backup regex. If `job-shape.json` AND `progress.json` exist, surfaces `Next: slice #N of M (<currentSlice>)` so the LLM cannot wake up cold.
 2. **Size-fear ban — `peaks code emit-handoff`.** Refuses to emit a final handoff while `remaining > 0` under Job mode. Pass `--force-under-job` only with explicit user approval.
 3. **On-disk slice progress — `peaks job progress`.** `peaks job checkpoint --state done` writes `progress.json`. `peaks job progress --job-id <jid> [--allow-missing]` is the canonical reader.
-4. **Forced auto-compact — `--enforce-job-mode`.** `peaks code context-now --enforce-job-mode` returns `action: 'auto-compact-now'` at ≥ 0.85. **Job mode at ≥ 0.85 is MANDATORY auto-compact** — Code MUST call `peaks code auto-compact` without confirmation.
+4. **Forced auto-compact — `peaks code context-now`.** It returns `action: 'auto-compact-now'` at ≥ 0.85. **≥ 0.85 is MANDATORY auto-compact in every mode (single-rid included)** — Code MUST call `peaks code auto-compact` without confirmation. `--enforce-job-mode` (v3.1.2) only labels the run `jobMode=true`; the ≥ 0.85 downgrade that used to apply to single-rid sessions was removed 2026-09-12.
 
 **Step 0.7 resume rule (read-FIRST):** on resume, `peaks code gate-step-08` reads `progress.json` first and surfaces `Next: slice #N of M (<currentSlice>)` so the orchestrator picks up at the right slice without re-reading the artifact tree.
 
@@ -209,7 +209,7 @@ Before the first planning action, run `peaks fresh-context preflight --prompt "<
 
 **Enforcement layers (defense in depth):**
 1. `src/services/code/auto-compact-orchestrator.ts` — `evaluateAutoCompactDecision` default-returns `shouldCompact: true` for both `pre-compact` and `red-line`. Only deferral is `inFlightBatch.hasInFlightBatch` (D6.e); no LLM/human approval branch.
-2. `--enforce-job-mode` (v3.1.2) — Job mode elevates ≥0.85 to MANDATORY regardless of in-flight batch.
+2. `peaks code context-now` — ≥ 0.85 is MANDATORY (`auto-compact-now`) in every mode; `--enforce-job-mode` no longer gates that (2026-09-12). Only an in-flight sub-agent batch defers it.
 3. `peaks code gate-step-08` (PreToolUse hook) — surfaces `auto-compact-now` on every Bash call when ratio is in the zone, so the LLM cannot wake up cold and forget.
 4. Karpathy §4 exception: `peaks code auto-compact` is fired *by the orchestrator*, not by the user. If you find yourself about to write "ask the user to compact" / "prompt the user to run `/compact`", STOP — that is the regression.