…s compaction

Adds an `engineOwnsPostCompactHeadroom` predicate and wires it through
`applyPiCompactionSettingsFromConfig` so that when the active context engine
either owns compaction outright (`info.ownsCompaction === true`) or intercepts
the runtime's `session_before_compact` event (`info.interceptsCompaction === true`),
Pi's reserve-token floor is treated as 0.

The default 20K-token floor exists to give the next user turn enough headroom
to land without immediately re-tripping the compaction threshold. Engines that
intercept compaction with their own assembly (e.g. lossless-claw with
`compactionTargetFraction = 0.35` — ~65% free post-compact) already provide
far more headroom than the floor, so double-reserving is wasteful and can
starve the assembled prompt of budget.

Wiring:
- `applyPiCompactionSettingsFromConfig` gains an optional `contextEngineInfo`
  param. When the predicate is true, `reserveTokensFloor` is set to 0 before
  the small-context cap is applied (so the cap is a no-op for the zeroed
  floor).
- `createPreparedEmbeddedPiSettingsManager` forwards `contextEngineInfo` to
  the inner `applyPiCompactionSettingsFromConfig` call.
- `run/attempt.ts` passes `activeContextEngine?.info` at BOTH the initial
  prepared-settings build AND the post-`resourceLoader.reload()` re-apply.
  Both calls must be threaded because `reload()` re-evaluates the floor from
  scratch.
- `compact.ts` (inner compaction-LLM session) intentionally does NOT pass
  `contextEngineInfo` — that session is not user-facing and has no active
  engine. The existing comment block is expanded to cover both calls.

Existing default behavior for engines that don't declare either flag is
unchanged: `resolveCompactionReserveTokensFloor(cfg)` (default 20000) is
still applied.

…zero

Adds three test layers for the new context-engine compaction-intercept wiring:

- `compaction-intercept.test.ts` (new file) — direct coverage of the
  extension handler: handled:true round-trip, handled:false fallthrough,
  thrown errors swallowed, AbortSignal propagation, null tokens → undefined
  currentTokenCount, no-runtime / no-method paths return undefined, plus
  runtime-registry set/get/clear/defensive null inputs.

- `extensions.test.ts` (extended) — factory selection in
  `buildEmbeddedExtensionFactories`: intercept factory is included only
  when `info.interceptsCompaction === true` and `info.ownsCompaction !== true`,
  and is pushed AFTER the safeguard factory so that SDK last-truthy-wins
  semantics let intercept override safeguard.

- `pi-settings.test.ts` (extended) — `applyPiCompactionSettingsFromConfig`
  auto-zero behavior: floor is zeroed for `interceptsCompaction` and
  `ownsCompaction` engines, preserved for legacy engines and when info is
  omitted, and explicit `reserveTokens` configurations still apply on top
  of the zeroed floor.

Pure test additions; no source changes.

Three follow-up fixes flagged by reviewer before push:

- **cli-compaction.ts**: thread `contextEngineInfo: contextEngine.info` into
  `createPreparedEmbeddedPiSettingsManager`. The `/compact` CLI path was the
  only remaining caller that resolved the engine but did not forward its
  info, so its reserve-token floor was NOT being auto-zeroed even though the
  same call passed engine info to `applyPiAutoCompactionGuard` on the next
  line. Now both calls are consistent with the in-attempt path.

- **compaction-intercept.ts**: guard `getSessionFile()` returning undefined.
  `ReadonlySessionManager.getSessionFile()` is typed `string | undefined` in
  pi-coding-agent; an in-memory session (not yet persisted) would otherwise
  forward `undefined` as a `string` into the engine. The handler now bails
  to the default compaction path with a debug log when no file is present.

- **compaction-intercept-runtime.ts + extensions.ts**: add `sessionKey?:
  string` to the runtime registry value so engines that route on session-key
  patterns (e.g. lossless-claw's ignored-/stateless-session patterns) see
  it inside the intercept handler. `ReadonlySessionManager` does not expose
  sessionKey (openclaw-level concept), so it's threaded via the runtime
  registry. `attempt.ts` passes `params.sessionKey` through
  `buildEmbeddedExtensionFactories`.

Tests:
- New `compaction-intercept.test.ts` case asserts handler bails on
  undefined sessionFile and another asserts sessionKey is forwarded.
- New `extensions.test.ts` cases assert sessionKey is wired through the
  runtime registry, and that omitting sessionKey is back-compat.

Test helper `makeCtx` used `overrides.tokens ?? 232_000`, but `??` triggers on
both `null` and `undefined` — so passing `{ tokens: null }` substituted the
default 232K instead of preserving the explicit null. Replace with a
`"tokens" in overrides` discriminator so explicit null is honored.

The contract under test (ContextUsage.tokens === null → currentTokenCount
undefined in the engine request) was correct in `compaction-intercept.ts`;
this was a test-side bug only.

128/128 of the new tests now pass locally:
- compaction-intercept.test.ts: 14 cases
- extensions.test.ts: 9 cases  (including 6 for the new factory wiring)
- pi-settings.test.ts: 47 cases (including 5 for the new auto-zero gate)

Three concrete fixes plus polish, after CI surfaced the issues:

## Compile / lint (P0 — unblocks 7 CI failures)

- `cli-compaction.ts`: add `contextEngineInfo?: ContextEngine["info"]` to
  the `CliCompactionDeps.createPreparedEmbeddedPiSettingsManager` type so
  the test-injectable shape matches the real signature. Without this
  `tsc --noEmit` rejected the call site at line 219 across build-artifacts,
  check-prod-types, check-test-types, check-strict-smoke, check-lint, and
  the three check-additional-extension-* shards.

- `compaction-intercept.ts`: bind `runtime`, `engine`, `interceptFn` as
  separate locals so TypeScript can narrow each independently. The prior
  chained-optional guard `!engine?.interceptCompaction` did not propagate
  to subsequent independent property reads on `engine`, leaving
  `runtime.sessionKey` and `engine.interceptCompaction` flagged as
  possibly-undefined at the call sites. Use `interceptFn.call(engine, ...)`
  so the bound method retains its `this`.

- Lint `'unknown' overrides all other types in this union type` was a
  cascade error from the TS failures (oxlint resolves `RegisteredLineCardCommand`
  to `unknown` when the build can't compile). Resolved by fixing the TS
  errors above.

## Gate semantics (P0 — architecture-review wave-B killer fix)

- `extensions.ts`: drop the `engineInfo.ownsCompaction !== true` exclusion
  from the compaction-intercept factory gate. The two flags advertise
  capability against DISTINCT compaction lanes:
    * `ownsCompaction` → openclaw queued-compaction lane (compact.queued.ts)
    * `interceptsCompaction` → pi-coding-agent SDK event lane (session_before_compact)
  An engine can advertise BOTH because codex fires session_before_compact
  on in-attempt overflow even when an engine owns the queued lane. The
  prior exclusion silently disabled intercept for engines like lossless-claw
  that legitimately own both lanes.

- `extensions.test.ts`: invert the ownsCompaction test to assert that
  engines with BOTH flags get intercept registered, plus a new case
  asserting that engines with ONLY ownsCompaction (no interceptsCompaction)
  do NOT get intercept (declining the SDK lane is opt-out).

## Polish (P1)

- `compaction-intercept.ts`: wire the new `trigger` field on the request
  payload (currently best-effort "in-attempt-auto" until the SDK surface
  grows). The type was declared but never plumbed.

- `pi-settings.ts`: expand the inline comment on `engineOwnsPostCompactHeadroom`
  to explicitly document the conflation of `ownsCompaction || interceptsCompaction`
  — both flags imply the engine manages headroom, so auto-zero is correct
  for either. Names the predicate as the single update point if the two
  lanes ever split.

Local re-verification: 130/130 tests passed (2.91s) on the touched files
and their neighbors after the fixes.

Concrete fixes from the second-wave audit:

## P0 (lint failures from latest CI)

- `compaction-intercept.ts`: replace `if (result.handled !== true)` with
  `if (!result.handled)` and `result.handled === false` with
  `!result.handled`. oxlint `no-unnecessary-boolean-literal-compare`
  rejects comparing discriminated-union booleans against literals. The
  type narrowing is unchanged — the discriminated union still correctly
  routes by truthiness.

- `compaction-intercept.ts`: restructure the engine-presence guard to
  `typeof engine.interceptCompaction !== "function"`. The prior
  `const interceptFn = engine?.interceptCompaction` triggered the
  `typescript/unbound-method` lint rule (extracting a method as a value
  can lose `this` binding at call time). The new form narrows
  `engine.interceptCompaction` to a defined function while avoiding the
  extracted-method-reference pattern; we call it as
  `engine.interceptCompaction(request)` inline so `this` is preserved.

- `compaction-intercept.test.ts`: add braces to two single-line `if`
  bodies that oxlint `curly` rule rejects.

## P1 (wave-B findings)

- `compaction-intercept.ts`: drop `inferTriggerFromEvent`. Wave-B P1-1
  caught that the function always returned `"in-attempt-auto"` whenever
  `event.preparation` was truthy (which is always, per SDK typing) —
  effectively mis-attributing overflow retries and manual /compact events
  as in-attempt-auto. Engines that condition cadence on `request.trigger`
  would see indistinguishable values. The post-fix contract: pass
  `trigger: undefined` and let engines treat absence as "host doesn't
  disambiguate". When the SDK exposes a real trigger field, plumb it then.

- `compaction-intercept.ts`: rewrite the factory docstring to reflect the
  wave-A gate change. The prior text claimed "no-op for engines that
  fully own compaction" which contradicted the new gate (engines may
  declare both `ownsCompaction` and `interceptsCompaction` and intercept
  IS registered for them). New text names the SDK `{cancel: true}`
  short-circuit limitation explicitly so future readers know auth-cancel
  cases bypass intercept.

- `compaction-intercept.test.ts`: add a new handler-level integration
  test that asserts a both-flags engine routes traffic through intercept
  correctly (P1-4 — the wave-A factory-registration test only verified
  the factory was added, not that the handler routed correctly).

- `compaction-intercept.test.ts`: add a test asserting `req.trigger ===
  undefined` so the post-wave-B contract is exercised.

Local re-verification: 30/30 (intercept tests), 0 lint errors on the
affected files, 134/134 on the full pi-hooks + pi-settings + extensions
suite. The handler now passes the discriminated-union narrowing without
the `!== true` / `=== false` comparisons and without extracting the
method as a value.

Wave-3 audit found two stale docstrings that contradicted the wave-A
gate change (which dropped the `ownsCompaction !== true` exclusion from
the intercept factory gate).

- `src/context-engine/types.ts`: `info.interceptsCompaction` docstring
  previously said engines that own compaction "never see the runtime
  event at all" — but the wave-A change made an `ownsCompaction +
  interceptsCompaction` engine see BOTH lanes. Updated to name the two
  distinct lanes (queued vs SDK event) and document that declaring both
  is correct for engines that want to handle both flows (lossless-claw
  v4.1 is the canonical case).

- `src/agents/pi-embedded-runner/extensions.ts`: `activeContextEngine`
  param docstring said the factory registers when "info.interceptsCompaction
  === true AND does NOT own compaction outright" — but the gate code
  only checks `interceptsCompaction === true`. Updated to match.

No behavior change; documentation alignment only.

`shouldDisablePiAutoCompaction` was turning off Pi's threshold check
whenever the engine declared `ownsCompaction: true` (or the user set
safeguard mode). But the new `session_before_compact` intercept lane
depends on Pi's threshold check still emitting that event — the engine
registers an extension that takes over compaction from inside the event
handler.

With the old gate, declaring `interceptsCompaction: true` had no effect:
Pi's `shouldCompact()` short-circuited on `!settings.enabled` before the
threshold was ever evaluated, so the event never fired and the engine's
intercept extension became dead code.

Carve out an exception: when `interceptsCompaction === true`, leave Pi
auto-compaction on so the event still emits. The engine's extension is
last-truthy-wins on `session_before_compact`, so it deterministically
overrides Pi's default summarizer.

The silent-overflow-prone branch is intentionally NOT gated on
`interceptsCompaction` — silent-overflow providers can truncate the
prompt without warning, so Pi's auto-compaction must stay disabled
regardless; the engine is expected to handle preemptive compaction
through its own queued lane in that case.

Refs openclaw#81164.