peaks-loop 4.0.45 → 4.0.47

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Changelog
 
+## 4.0.47 — 2026-09-13 (90 个文件第一次进 CI 就绿了 + 弹窗的根在守卫射程 + 说"能做"而做不到的地方)
+
+**Highlights**:
+
+1. **`tests/integration/**`（90 个文件 / 463 个测试）第一次进了 CI，也第一次在 ubuntu 上绿了。** 它此前**从未在任何地方跑过** —— `ci.yml` 的测试步骤用默认 config，其 `include` 只含 `tests/unit/**`；所以"CI 绿"与"全量绿"都不覆盖它。接入后实测 **20 条失败**，逐条分诊后：**2 条是真产品 bug**（`memory extract` 把"文件不存在"报成沙箱逃逸；`release canary` 缺 `package.json` 时抛 `UNHANDLED_ERROR`）、**1 条分诊误判被拒绝**（`sop registry` 看着像读不到磁盘清单，实际是仓库从没跑过 `sop register` —— 内容缺口，不是代码缺口）、其余为陈旧期望与契约选择。
+
+   **那个 CI job 一开始是"有意变红"的，现在是普通闸门** —— 它的名字与注释都改成了如实描述：**红即真回归**，不再是"已知初始状态"。已验证：**ubuntu 与 windows 双双全绿**。
+
+2. **空白 `cmd.exe` 弹窗：根在守卫的射程，不在扫描的深度。** 上一版给 14 个文件加了 `windowsHide` 并加了守卫，弹窗却没停 —— 因为守卫的 `GUARDED_FILES` 是**那 14 个文件的硬编码棘轮**，其它文件**按构造就在射程外**，于是守卫报零而症状继续。扩成**发现式**（遍历 `src|tests|scripts|packages`，**先收集完整列表再逐个解析**，不依赖单文件结果）后，查出 **214 个未隐藏调用点 / 105 个文件**，**全部修复，债务棘轮为空**。
+
+   扩围还暴露了守卫**自身 AST 遍历的 4 处缺陷** —— 那些缺陷正是这些站点长期隐形的原因：`execFile(cmd,args,OPTIONS,cb)` 的 options 读错位置（放过 `src/shared/process.ts`，**每次子代理派发都在跑**）、改名 import 跟不上、**`promisify(execFile)` 完全跟不上**（隐藏了 `orchestrator-can-do.ts` 上**每轮** `code context-now` 路径的两个活站点）、动态 import 命名空间漏。
+
+3. **auto-compact：从"谁来决定何时压"到"压完之后还在不在"。** 两件事都做了：
+
+   - **尺度对齐。** peaks-loop 与 harness **各自独立解析"上下文窗口"**（前者走 env → config → 模型名启发式 → 硬编码 200K），**没有任何机制保证两者相同**。后果：启发式认不出模型时，peaks-loop 的"95%"落在 **190K token**、而 harness 要到 **~967K** 才压 —— **红线早触发约 5 倍，然后死锁**（没有任何东西能在 190K 处强制压缩）。现在两边**是同一个数**；红线**不再封死派发**，只请求并报告等待；阈值写入 `.claude/settings.local.json` 的 `env` 块，**带人类可读的告知与一键回滚**（harness 默认对被覆盖是静默的）。
+   - **压缩后回注。** 压缩由 harness 执行、摘要是**泛化的** —— 它不知道什么是 slice / request / gate / AC，所以丢掉的恰恰是本项目自己的状态，而**没有任何东西把它装回去**。新增 `SessionStart` + `matcher:"compact"` 钩子（官方支持的回注通道），**预算 3072 字节**：按**存活排名**保留块（身份 → **指针** → 运行期规则 → 下一步 → 当前工作），**指针优先于规则**（让人去读产物，而不是把产物搬进来）；降级是 **greedy by rank（跳过并继续）**，不是一个超大块把后面的全挤掉。**单位是字节而非"窗口的百分之几"** —— 百分比预算会**随窗口变大而变大**，正好重新制造它要防的失效。
+
+4. **一批"代码在说它做不到的事"** —— 本版最反复的一条主线：
+
+   - **一个谁都接不住的 spawn 失败。** 集成套件测试全过、进程却 exit 1。根因不是平台：`ProcessSupervisor.spawn` 调 `nodeSpawn` 时**没挂 `'error'` 监听器**，而 **Node 把 ENOENT 派发在 nextTick 上，那个队列在 `await` 恢复之前就排空了** —— 所以 `await spawn(); child.on('error', …)` **无论谁写都输掉竞速**，`DispatchResult.child`（注释写明"给调用方挂 handler 用"）是个**无法兑现的承诺**，CLI 里自称 "canonical pattern" 的 handler **是死代码**。改为把结果做成**类型化的值**（`settled` 承诺 + `spawnError`），失败不再被记成 `running`。
+   - **缺必填选项报成 `UNHANDLED_ERROR`**（`command: "cli"`、`nextActions` 为空）—— 改为类型化的 `MISSING_REQUIRED_OPTION`，点名命令与选项。
+   - **`config restore` 读的是 `~/.peaks/*.bak` 而不是项目目录** —— 所以它在一台**恰好迁移过配置的开发机**上绿、在干净 runner 上红；而 `rollback` 因为优雅降级反而一直绿。
+   - **CI 里 `request init` 要解析 caller id**，无 IDE env 时落到 D2/EX_USAGE（exit 64），而 `workspace init` 从不解析它 —— 这就是"上一行成功、这一行失败"的不对称。
+
+**验证**：三个版本常量一致（**4.0.47**）；`tsc -p tsconfig.json` 保持 **142** 基线；`tests/unit` **228 files / 2397 passed / 3 skipped / 0 failed**；`tests/integration` **88 files / 2 skipped / 0 failed**，且 **CI 的 ubuntu 与 windows 两个平台都绿**。
+
+**明确未验证的（不当作已完成）**：压缩后回注**没有人在一次*真实*压缩之后观察过** —— 单测无法让 harness 压缩、也无法观测它怎么捕获钩子 stdout，所以 `matcher:"compact"` 是当作已知条件接受的，**它的失效方式是静默的**；**下一次真实压缩才是第一次真检验**。以及"由 peaks-loop 决定**触发点**"仍未达成：写入的窗口等于真实窗口，只让两边共享尺度，**没有让 harness 提前压** —— 标定需要真实会话数据，`compact-history.jsonl` 已记录"意图 vs 实际"待读。
+
+**本轮顺带发现、尚未处理（不属本版修复）**：三条 `SessionStart` 条目假设 Windows 上 shell 形式的 SessionStart 命令不会开控制台窗口 —— `shell: powershell` 那个钉子只加在了 per-tool-call 钩子上，**这是 windowsHide 家族还没扫到的一处**；`materializeClaudeSettingsLocal` 拥有本地 settings 文件的整个 `hooks` 键，落在那里的一条 SessionStart 条目会被模板刷新**静默删掉**（今天没有东西走那条路）；`config restore --list` 在缺 `.bak` 时 exit 1 而 `rollback` exit 0 并返回 `{available:false}` —— 一处真实的不对称，需要产品决定；`test:integration` 脚本仍漏 `--config`，**选中的是零个文件**。
+
+## 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.47 (2026-09-13) |
 | **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.47(2026-09-13) |
 | **覆盖域** | 代码(`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.d.ts

@@ -11,4 +11,26 @@
  */
 import type { Command } from 'commander';
 import { type ProgramIO } from '../cli-helpers.js';
+import { type ResultEnvelope } from 'peaks-loop-shared/result';
+import { type AutoCompactResult } from '../../services/code/auto-compact-orchestrator.js';
+/**
+ * Adapt `runAutoCompact`'s domain result to a `ResultEnvelope`.
+ *
+ * Extracted and exported so the CHANNEL each fact chooses can be asserted
+ * directly, without a real red-line probe.
+ *
+ * The harness-window CONFLICT ("peaks-loop divided this ratio by N but the
+ * settings file pins M") is a fact about the STATE, not an instruction, so it
+ * rides `warnings` — the very channel `peaks code context-now` already puts it
+ * on, via the same `harnessWindowSyncWarning`. Before this, the shim hard-coded
+ * `warnings: []`, so the identical fact reached a consumer as a sentence inside
+ * `nextActions` on this command and as a `warnings` entry on the other one. One
+ * fact, two shapes, depending on which of the two syncing commands a consumer
+ * happened to read: two parsers for one mechanism.
+ *
+ * The prose description (`describeHarnessWindowSync`) stays in `nextActions` on
+ * BOTH commands — that half is advice ("what to do about it") and both already
+ * agree on it.
+ */
+export declare function buildAutoCompactEnvelope(result: AutoCompactResult): ResultEnvelope<unknown>;
 export declare function registerCodeRuntimeCommands(code: Command, io: ProgramIO): void;

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

@@ -14,6 +14,9 @@ import { fail, ok } from 'peaks-loop-shared/result';
 import { detectPostCompactResume, formatPostCompactResumeLogLine } from '../../services/code/post-compact-detector.js';
 import { runAutoCompact } from '../../services/code/auto-compact-orchestrator.js';
 import { auditContext } from '../../services/context/context-audit.js';
+import { syncHarnessWindowForProject } from '../../services/context/auto-compact-reader.js';
+import { describeHarnessWindowSync, harnessWindowSyncWarning } from '../../services/context/harness-window-config.js';
+import { resolveCanonicalProjectRoot } from '../../services/config/config-service.js';
 import { buildContextAuditHint } from '../../services/context/context-audit-hint.js';
 import { evaluateStep08, STEP_08_BACKUP_REGEX } from '../../services/code/step-08-gate.js';
 import { evaluateEmitHandoff, JOB_NOT_INITIALIZED, JOB_REMAINING_BLOCKED } from '../../services/code/emit-handoff.js';
@@ -21,6 +24,38 @@ import { readJobShapeDecision, JobShapeDecisionError } from '../../services/code
 import { getSkillPresence } from '../../services/skills/skill-presence-service.js';
 import { probeInFlightBatch } from '../../services/workflow/workflow-inflight-probe.js';
 import { resolveOuterSessionId } from '../../services/session/binding-status-service.js';
+/**
+ * Adapt `runAutoCompact`'s domain result to a `ResultEnvelope`.
+ *
+ * Extracted and exported so the CHANNEL each fact chooses can be asserted
+ * directly, without a real red-line probe.
+ *
+ * The harness-window CONFLICT ("peaks-loop divided this ratio by N but the
+ * settings file pins M") is a fact about the STATE, not an instruction, so it
+ * rides `warnings` — the very channel `peaks code context-now` already puts it
+ * on, via the same `harnessWindowSyncWarning`. Before this, the shim hard-coded
+ * `warnings: []`, so the identical fact reached a consumer as a sentence inside
+ * `nextActions` on this command and as a `warnings` entry on the other one. One
+ * fact, two shapes, depending on which of the two syncing commands a consumer
+ * happened to read: two parsers for one mechanism.
+ *
+ * The prose description (`describeHarnessWindowSync`) stays in `nextActions` on
+ * BOTH commands — that half is advice ("what to do about it") and both already
+ * agree on it.
+ */
+export function buildAutoCompactEnvelope(result) {
+    const data = 'data' in result ? result.data : null;
+    const nextActions = 'nextActions' in result ? result.nextActions : [];
+    const warning = harnessWindowSyncWarning(data?.harnessWindow ?? null);
+    const warnings = warning === null ? [] : [warning];
+    if (result.ok) {
+        return ok('code.auto-compact', data ?? {}, warnings, [result.message, ...nextActions]);
+    }
+    // `fail()` hard-codes `warnings: []`, so the warning is spread back over it —
+    // a refused write can disagree with the ratio just as easily on the failure
+    // path, and the state does not become less true because the dispatch failed.
+    return { ...fail('code.auto-compact', result.code, result.message, data, [...nextActions]), warnings };
+}
 export function registerCodeRuntimeCommands(code, io) {
     addJsonOption(code
         .command('post-compact-detect')
@@ -58,9 +93,11 @@ export function registerCodeRuntimeCommands(code, io) {
         .command('auto-compact')
         .description('v2.13.0 AC-4: zero-human-intervention auto-compact. Probes current ' +
         'context-fill % via the active IDE adapter; ≥ 0.85 writes a pre-compact ' +
-        'checkpoint + convergence plan + auto-decisions log; ≥ 0.95 forces ' +
-        'synchronous IDE-side compact. The LLM / runner keeps working with ' +
-        'context < 95% without human intervention. Pair with `peaks code ' +
+        'checkpoint + convergence plan + auto-decisions log; ≥ 0.95 ASKS the ' +
+        'harness to compact and reports that it is waiting for it — no ratio ' +
+        'blocks sub-agent dispatch, because peaks-loop has no way to compact a ' +
+        'running session and a gate nobody can satisfy gates nothing. The LLM / ' +
+        'runner keeps working at any ratio without human intervention. Pair with `peaks code ' +
         'context-now` (AC-1), the read-only probe that reports the ratio this ' +
         'command acts on. This command is also fired by the installed ' +
         'PreToolUse hook, which passes `--project .` — without that argument ' +
@@ -71,7 +108,15 @@ export function registerCodeRuntimeCommands(code, io) {
         .option('--session-id <sid>', 'override session id (default: read from active presence)')
         .option('--in-flight-batch', 'defer if a sub-agent batch is in flight (D6.e)')
         .option('--force', 'force compact at any ratio (test seam)')
-        .option('--bypass-red-line', 'skip the 95% red-line gate (test seam; never true in production)')
+        // Accepted and inert. There is no longer a 95% gate to skip: peaks-loop
+        // cannot compact a running session, so the red line never blocked
+        // dispatch and `bypassRedLine` is read by nothing (slice
+        // 2026-09-13-auto-compact-trigger-ownership, T3/A1). The flag is KEPT
+        // rather than deleted because it is a published CLI surface — deleting it
+        // would make an existing caller fail on an unknown option, which is a
+        // harder break than a no-op — and because the honest fix here is to stop
+        // advertising it, not to change its meaning.
+        .option('--bypass-red-line', 'no-op: the 95% red line no longer gates dispatch, so there is nothing to bypass (accepted for backward compatibility)')
         // No commander default here, deliberately. A declared default makes
         // `opts.mode` permanently defined, which defeats the orchestrator's
         // `input.mode ?? resolveAutoCompactMode(projectRoot)` fallback and
@@ -132,12 +177,7 @@ export function registerCodeRuntimeCommands(code, io) {
             // generic accepts it. The orchestrator envelope carries
             // `data` on success-path and `nextActions` on the error
             // path; surface both directly to the user.
-            const data = 'data' in result ? result.data : null;
-            const nextActions = 'nextActions' in result ? result.nextActions : [];
-            const envelope = result.ok
-                ? ok(`code.auto-compact`, data ?? {}, [], [result.message, ...nextActions])
-                : fail(`code.auto-compact`, code, result.message, data, [...nextActions]);
-            printResult(io, envelope, opts.json);
+            printResult(io, buildAutoCompactEnvelope(result), opts.json);
             if (!exitOk)
                 process.exitCode = 1;
         }
@@ -155,16 +195,19 @@ 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 ' +
-        '≥0.95 emits action=red-line (forced hook fires next turn). ' +
+        '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 (the installed PreToolUse hook re-runs ' +
+        'this command on the next Bash/Task tool call; nothing is blocked). ' +
+        '--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');
@@ -206,21 +249,47 @@ export function registerCodeRuntimeCommands(code, io) {
                 env: process.env,
                 promptSizeBytes
             });
+            // Slice 2026-09-13-auto-compact-trigger-ownership (T1 + T2): materialize
+            // the window this probe just divided by into the harness's own settings,
+            // so "85%" here and the harness's own trigger are one point on one
+            // scale. Idempotent (no write when the value is already in force) and a
+            // no-op when the probe carried no token window — peaks-loop never
+            // invents a number it did not measure.
+            const harnessWindow = syncHarnessWindowForProject({
+                // Promote `--project .` (what the PreToolUse hook passes) to the git
+                // root first: the settings path this writes to must not depend on
+                // the caller's cwd, and an absolute path is what the envelope then
+                // reports back to the operator.
+                projectRoot: resolveCanonicalProjectRoot(opts.project),
+                env: process.env,
+                tokens: probe.capacityTokens ?? null
+            });
+            // The machine half of 要告知. A refused write is not automatically a
+            // non-event: the file may pin a window that disagrees with the one this
+            // probe just divided by, and then the ratio above describes a trigger
+            // the harness is not going to fire. `nextActions` carries the full
+            // sentence; this one line rides `warnings` so a JSON consumer cannot
+            // miss it either.
+            const harnessWindowWarning = harnessWindowSyncWarning(harnessWindow);
             const ratioPct = (probe.ratio * 100).toFixed(1);
             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 +298,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}%`,
@@ -250,19 +326,37 @@ export function registerCodeRuntimeCommands(code, io) {
                 // default) — null for byte/percent sources, which have no window.
                 capacitySource: probe.capacitySource ?? null,
                 bytesPrompt: promptSizeBytes ?? null,
-                capturedAt: probe.capturedAt
-            }, [], [
+                capturedAt: probe.capturedAt,
+                // Slice 2026-09-13-auto-compact-trigger-ownership: what the harness
+                // window sync did on this probe. Reported rather than silent — the
+                // harness tells a user who overrides the window only via
+                // `/autocompact`, so peaks-loop must be the one that says it.
+                harnessWindow
+            }, harnessWindowWarning === null ? [] : [harnessWindowWarning], [
                 action === 'red-line'
-                    ? `RED LINE: ≥ 95%. Next: \`${next}\` (PreToolUse hook fires next turn).`
+                    ? `RED LINE: ≥ 95%. Next: \`${next}\` — peaks-loop asks the harness to compact and KEEPS WORKING (dispatch is not blocked); re-probe to confirm it landed.`
                     : 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
-            ]), true);
+                gateModeNotice,
+                // Single wording, shared with `peaks code auto-compact` — see
+                // `describeHarnessWindowSync`.
+                describeHarnessWindowSync(harnessWindow)
+            ]), 
+            // Slice 2026-09-13-auto-compact-trigger-ownership: was hard-coded
+            // `true`, which made the declared `--json` flag a no-op and left the
+            // human with raw JSON and no `next:` lines — so a person running this
+            // command could not see that peaks-loop had just written their
+            // harness settings. The notices above (including the key, the value
+            // and the rollback command) are `nextActions`, which `printResult`
+            // prints as `next: …` lines ONLY in the non-JSON path. Honoring the
+            // flag is what puts them in front of a human. See the consumer audit
+            // in the slice's RD artifact: every in-repo caller (the PreToolUse
+            // hooks, `orchestrator-can-do`, the skill runbooks) passes `--json`
+            // explicitly, so their byte-for-byte output is unchanged.
+            opts.json === true);
         }
         catch (err) {
             printResult(io, fail('code.context-now', 'CONTEXT_NOW_FAILED', getErrorMessage(err), null, [

package/dist/cli/commands/compact-command.js

@@ -4,7 +4,9 @@ import { fail, ok, getErrorMessage } from 'peaks-loop-shared/result';
 import { addJsonOption, printResult } from '../cli-helpers.js';
 import { writeCheckpoint } from '../../services/session/session-checkpoint-service.js';
 import { getSessionIdCanonical } from '../../services/session/session-manager.js';
-import { readCompactHistory, summarizeCompactHistory, } from '../../services/compact-history/compact-history-service.js';
+import { computeWindowCalibration, readCompactHistory, summarizeCompactHistory, } from '../../services/compact-history/compact-history-service.js';
+import { readHarnessWindowState, resolveHarnessWindowLocation } from '../../services/context/auto-compact-reader.js';
+import { disableHarnessWindowSync, reenableHarnessWindowSync, resetHarnessWindow } from '../../services/context/harness-window-config.js';
 import { buildRecommendEnvelopePure, dryRunCompact, suggestCompact } from '../../services/compact/suggest-service.js';
 import { PHASES, SURVIVAL_TABLE, isPhase, lookupPhaseTransition } from '../../services/compact/decision-tables.js';
 function splitList(value) {
@@ -288,9 +290,16 @@ export function registerCompactCommands(program, io) {
                 return;
             }
             const summary = summarizeCompactHistory(result.events);
+            // Slice 2026-09-13-auto-compact-trigger-ownership (T4): the
+            // intent-vs-observed record. `pairs[i].requestedTokens` is the token
+            // point peaks-loop asked for; `observedTokens` is what the next real
+            // session actually measured. Unmeasured pairs are reported as such —
+            // this instrument states what happened, it does not predict.
+            const windowCalibration = computeWindowCalibration(result.events);
             printResult(io, ok('compact.history', {
                 sessionId: session.sid,
                 ...summary,
+                windowCalibration,
                 events: result.events,
                 parseErrors: result.parseErrors,
                 historyPath: result.path,
@@ -301,4 +310,123 @@ export function registerCompactCommands(program, io) {
             process.exitCode = 1;
         }
     }));
+    // 7. peaks compact harness-window [--reset | --disable | --reenable]
+    //    (slice 2026-09-13-auto-compact-trigger-ownership, T1 + T2)
+    //
+    // The window peaks-loop divides by and the window the harness compacts
+    // against must be ONE number, or "95%" lands at two different token counts.
+    // This command is the visible half of that write: the default reports what
+    // is in force, `--reset` removes it, `--disable` stops managing it.
+    //
+    // There is deliberately NO `--sync` flag. Materializing the window requires
+    // the ratio's own denominator, which only a probe has (it is the only place
+    // the active model is known). A `--sync` that re-derived the window here
+    // would be the second, independent resolution this slice exists to delete —
+    // `peaks code context-now` and `peaks code auto-compact` already sync.
+    addJsonOption(compact
+        .command('harness-window')
+        .description('Report / roll back the auto-compact window peaks-loop writes into the ' +
+        'harness\'s own machine-local settings (the adapter-declared ' +
+        'autoCompactWindowEnvVar, e.g. CLAUDE_CODE_AUTO_COMPACT_WINDOW in ' +
+        '.claude/settings.local.json). peaks-loop computes its context ratio ' +
+        'against exactly this number, so the value it reports as "85%" and the ' +
+        'point the harness compacts at are the same. Context probes ' +
+        '(`peaks code context-now`, `peaks code auto-compact`) materialize it ' +
+        'automatically. Two different intentions, two verbs: --reset removes ' +
+        'the key AND opts the project out so later probes do not put it back ' +
+        '(when the file holds no peaks-loop row at all there is nothing to ' +
+        'roll back, so --reset writes nothing); --disable records the opt-out ' +
+        'only, leaving whatever value is already there untouched, so "stop ' +
+        'managing this key" works on a project peaks-loop has never written ' +
+        'to; --reenable undoes either opt-out.')
+        .option('--project <path>', 'project root (defaults to git root or cwd)')
+        .option('--reset', 'rollback: remove the window key and stop managing it')
+        .option('--disable', 'record the opt-out only (do not manage this key), without removing a value that is already there; expressible before the first write')
+        .option('--reenable', 'undo a --reset or --disable opt-out (peaks-loop manages it again)')
+        .action((options) => {
+        try {
+            const project = options.project !== undefined
+                ? resolveCanonicalProjectRoot(options.project)
+                : (findProjectRoot(process.cwd()) ?? process.cwd());
+            const location = resolveHarnessWindowLocation({ projectRoot: project, env: process.env });
+            if (location === null) {
+                printResult(io, ok('compact.harness-window', {
+                    projectRoot: project,
+                    managed: false,
+                    message: 'The active IDE adapter declares no auto-compact window key, so peaks-loop cannot tie ' +
+                        'the harness window to its own ratio. Nothing was written and there is nothing to roll back.',
+                }), options.json);
+                return;
+            }
+            if (options.reset === true) {
+                const result = resetHarnessWindow({ location, env: process.env });
+                printResult(io, ok('compact.harness-window', {
+                    projectRoot: project,
+                    action: result.action,
+                    key: location.envVar,
+                    settingsPath: result.settingsPath,
+                    previousTokens: result.previousTokens,
+                }, [], [
+                    result.action === 'removed'
+                        ? `Removed ${location.envVar} from ${result.settingsPath} and opted this project out, so later probes stop writing it. Undo with \`peaks compact harness-window --reenable\`.`
+                        : `Nothing to remove — ${location.envVar} was already absent from ${result.settingsPath}, so nothing was written and no opt-out row was recorded: if a probe writes a window here later, run --reset again to remove it. To say "never manage this key here" WITHOUT waiting for that first write, run \`peaks compact harness-window --disable\`.`,
+                ]), options.json);
+                return;
+            }
+            if (options.disable === true) {
+                const result = disableHarnessWindowSync({ location });
+                printResult(io, ok('compact.harness-window', {
+                    projectRoot: project,
+                    action: result.action,
+                    key: location.envVar,
+                    settingsPath: result.settingsPath,
+                }, [], [
+                    result.action === 'disabled'
+                        ? `Recorded the opt-out in ${result.settingsPath}: peaks-loop will not write ${location.envVar} here, and left any value already in the file exactly as it was. Undo with \`peaks compact harness-window --reenable\`.`
+                        : result.action === 'already-opted-out'
+                            ? `Already opted out — ${result.settingsPath} carries ${location.envVar}'s opt-out, so nothing was written. Undo with \`peaks compact harness-window --reenable\`.`
+                            : result.action === 'refused-unsafe-project-root'
+                                ? `Nothing written: the resolved project root is the user's own home directory, so ${result.settingsPath} is their PERSONAL harness settings, not a project's. peaks-loop already refuses to write ${location.envVar} there, so an opt-out would change nothing except which refusal you see. Point --project at a project (a subdirectory of home is fine) and the opt-out lands there.`
+                                : `Nothing written — ${result.settingsPath} is not a JSON object peaks-loop can safely edit, so the opt-out could not be recorded there.`,
+                ]), options.json);
+                return;
+            }
+            if (options.reenable === true) {
+                const result = reenableHarnessWindowSync({ location });
+                printResult(io, ok('compact.harness-window', { projectRoot: project, action: result.action, key: location.envVar, settingsPath: result.settingsPath }, [], [
+                    result.action === 'reenabled'
+                        ? 'Opt-out cleared; the next context probe will materialize the window again.'
+                        : 'No opt-out was recorded for this project.',
+                ]), options.json);
+                return;
+            }
+            const state = readHarnessWindowState({ projectRoot: project, env: process.env });
+            printResult(io, ok('compact.harness-window', {
+                projectRoot: project,
+                managed: true,
+                key: location.envVar,
+                settingsPath: location.settingsPath,
+                tokens: state?.tokens ?? null,
+                raw: state?.raw ?? null,
+                source: state?.source ?? null,
+                optedOut: state?.optedOut ?? false,
+                // Provenance: whether this value is peaks-loop's own write or
+                // one the user set by hand. It decides whether the late 1M
+                // rescue may override it, so it is not just diagnostics.
+                peakWritten: state?.peakWritten ?? false,
+            }, [], [
+                state?.tokens === null || state?.tokens === undefined
+                    ? 'No window is set yet. The next `peaks code context-now` probe materializes the window it computes its ratio against.'
+                    : `peaks-loop computes its context ratio against ${state.tokens} tokens; the harness fires near the end of that window. ${state.peakWritten
+                        ? 'peaks-loop wrote this value; it may raise it if a session outgrows it.'
+                        : 'This value is not peaks-loop\'s own write, so peaks-loop will not raise it — it is treated as your setting.'}`,
+                'Rollback: `peaks compact harness-window --reset`.',
+                'Intent-vs-observed calibration: `peaks compact history --json` → windowCalibration.',
+            ]), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('compact.harness-window', 'COMPACT_HARNESS_WINDOW_FAILED', getErrorMessage(error), {}, ['Verify the project path is writable and a session is bound']), options.json);
+            process.exitCode = 1;
+        }
+    }));
 }

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

@@ -37,7 +37,7 @@ function detectContainerRuntime(explicit) {
     const tryOrder = explicit ? [explicit] : ['docker', 'podman'];
     for (const r of tryOrder) {
         try {
-            const version = execSync(`${r} --version`, { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8' }).trim();
+            const version = execSync(`${r} --version`, { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8', windowsHide: true }).trim();
             return { ok: true, runtime: r, binary: `${r} (${version.split('\n')[0] ?? ''})` };
         }
         catch {
@@ -117,7 +117,7 @@ export function registerContainerCommand(program, io) {
             // when the lease file is missing.
             const cidFile = `${normalizePath(joinPathSession(projectRoot, sessionId))}/.${runtime.runtime}-cid-${leaseId}`;
             try {
-                execSync(`${runtime.runtime} run --rm -d --cidfile "${cidFile}" --label "peaks.leaseId=${leaseId}" --label "peaks.rid=${options.rid}" -v "${mount}:/work" -w /work ${image} sleep infinity`, { cwd: projectRoot, stdio: 'pipe', encoding: 'utf8' });
+                execSync(`${runtime.runtime} run --rm -d --cidfile "${cidFile}" --label "peaks.leaseId=${leaseId}" --label "peaks.rid=${options.rid}" -v "${mount}:/work" -w /work ${image} sleep infinity`, { cwd: projectRoot, stdio: 'pipe', encoding: 'utf8', windowsHide: true });
             }
             catch (err) {
                 printResult(io, fail('container.spawn', 'DOCKER_RUN_FAILED', getErrorMessage(err), { rid: options.rid, image, runtime: runtime.runtime, sessionId }, [
@@ -199,7 +199,7 @@ export function registerContainerCommand(program, io) {
             try {
                 const releaseRuntime = detectContainerRuntime(undefined);
                 const runtimeCmd = releaseRuntime.ok ? releaseRuntime.runtime : 'docker';
-                execSync(`${runtimeCmd} rm --force "${lease.containerId}"`, { cwd: projectRoot, stdio: 'pipe', encoding: 'utf8' });
+                execSync(`${runtimeCmd} rm --force "${lease.containerId}"`, { cwd: projectRoot, stdio: 'pipe', encoding: 'utf8', windowsHide: true });
             }
             catch {
                 dockerRmFailed = true;

package/dist/cli/commands/core/skill-command.js

@@ -307,17 +307,18 @@ export function registerSkillCommand(program, io) {
     });
     addJsonOption(skill
         .command('presence:clear')
-        .description('Clear the active Peaks skill presence indicator. Slice 4.0.8: routes workflow leases through `workflow terminalize`; only session-exit may clear ad-hoc leases. Raw unlink is FORBIDDEN.')
+        .description('Unlink the DEPRECATED pre-4.0.11 single-slot presence marker files (`.peaks/_runtime/active-skill.json`, `.peaks/.active-skill.json`). It does NOT terminalize a live presence lease — a workflow-bound lease terminalizes through `peaks workflow terminalize --workflow <id> --reason <reason>`, an ad-hoc lease only at session exit, and raw unlink is FORBIDDEN for both. The envelope reports what is still active.')
         .option('--project <path>', 'project root path (auto-detected from cwd when omitted)')).action(async (options) => {
         const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
-        // Slice 4.0.8 (DR): `presence:clear` is a workflow terminalizer,
-        // not a raw unlink. For workflow-bound leases the call is routed
-        // through `workflow terminalize` (canonical in
-        // workflow-presence-lifecycle.ts). Ad-hoc (non-workflow) leases
-        // remain terminalizable only via session exit. We delegate to the
-        // compat shim `clearSkillPresence`, which the compat wrapper
-        // re-routes to `terminalizePresenceLease` when a workflow
-        // binding is present.
+        // What this command actually is: a stale-marker cleanup for projects
+        // carrying a pre-4.0.11 single-slot file, and nothing more. The previous
+        // description claimed it "routes workflow leases through `workflow
+        // terminalize`" and that a "compat wrapper re-routes [it] to
+        // `terminalizePresenceLease` when a workflow binding is present" — there is
+        // no such wrapper, and no such routing happens here or in
+        // `clearSkillPresence`. A caller who read that line and ran this command
+        // expecting a live workflow lease to terminalize got a successful exit code
+        // and a still-running lease.
         const removed = clearSkillPresence(options.project);
         // Auto-update project context so future sessions have up-to-date history.
         // Slice 2026-07-15-project-scan-bootstrap: generateProjectContext now also
@@ -329,7 +330,41 @@ export function registerSkillCommand(program, io) {
         catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
             // non-fatal: context update failure should not block presence clear
         }
-        printResult(io, ok('skill.presence:clear', { active: false, removed, projectContextUpdated: true }), options.json);
+        // Report the state the project is actually in, not the state this command
+        // intended to reach. `clearSkillPresence` unlinks only the DEPRECATED
+        // single-slot marker files; the canonical sid-scoped lease is deliberately
+        // left alive for an AD-HOC lease (raw unlink is FORBIDDEN — only session
+        // exit may terminalize one; workflow leases route through `workflow
+        // terminalize`). So after a `presence:set` the very next `peaks skill
+        // presence` call still reads `active: true`. A hardcoded `active: false`
+        // therefore reported a state the command never reached, and the caller had
+        // no way to tell that from a real clear.
+        //
+        // Re-reading through `getSkillPresence` — the same projection the
+        // `skill presence` command serves — is the only derivation that cannot
+        // drift from what the next command prints: it is the same read path, on
+        // the same project root, evaluated after every write this command makes.
+        const active = getSkillPresence(projectRoot) !== null;
+        // `cleared` is the live question the caller is actually asking ("is it gone
+        // now?"), which `removed` could never answer: a legacy marker being unlinked
+        // says nothing about the lease the next command will read. When it is false
+        // the envelope says WHY, in the two routes that can terminalize a lease —
+        // without this the caller saw `active: true, removed: false` and had no way
+        // to tell "you ran the wrong command" from "this command has no opinion".
+        const cleared = !active;
+        printResult(io, ok('skill.presence:clear', {
+            active,
+            removed,
+            cleared,
+            ...(cleared ? {} : { reason: 'live-lease-survives-presence-clear' }),
+            projectContextUpdated: true
+        }, [], cleared
+            ? []
+            : [
+                'A workflow-bound lease terminalizes through `peaks workflow terminalize --workflow <id> --reason <reason>`.',
+                'An ad-hoc lease (`peaks skill presence:set`) is terminalizable only at session exit; `presence:clear` will not remove it, and raw unlink is FORBIDDEN.',
+                'Run `peaks skill presence --json` to read the lease that survived.'
+            ]), options.json);
     });
     // Slice 4.0.8 (RD §4): manual lease GC primitive. LLM-coordinated;
     // never a user-typed requirement. The user / LLM runner invokes