peaks-loop 4.0.11 → 4.0.13

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

@@ -1,28 +1,34 @@
-import { existsSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { findProjectRoot } from '../config/config-safety.js';
 import { decideCompactStatusline } from '../compact-statusline/compact-statusline-service.js';
 import { getSessionIdCanonical } from '../session/session-manager.js';
 import { resolveActiveSkillForCaller } from '../audit/enforcers/active-skill-resolver.js';
+import { listPresenceLeases } from './presence-lease-service.js';
 import { readActiveDispatchIndex } from '../dispatch/dispatch-record-writer.js';
 /**
  * Out-of-band Peaks skill status renderer for the Claude Code statusLine.
  *
  * Claude Code invokes the configured statusLine command on every turn and pipes
- * a JSON session payload on stdin. This renderer reads the durable presence file
- * (`.peaks/_runtime/active-skill.json`, with a one-minor-release back-compat
- * fallback to `.peaks/.active-skill.json`) and prints a single line that
- * Claude Code paints at the bottom of the terminal. Because it is rendered
- * by the harness — not emitted as LLM tokens — the signal cannot be forgotten
- * by the model, cannot be confused with normal output, and survives context
- * compaction.
+ * a JSON session payload on stdin. This renderer reads the canonical
+ * sid-scoped lease projection
+ * (`.peaks/_runtime/<sid>/leases/presence-<caller>-<workflow>.json` +
+ * the per-caller index under `presence-index/<caller>.json`) and prints a
+ * single line that Claude Code paints at the bottom of the terminal. Because
+ * it is rendered by the harness — not emitted as LLM tokens — the signal
+ * cannot be forgotten by the model, cannot be confused with normal output,
+ * and survives context compaction.
  *
  * This module is intentionally READ-ONLY. Unlike getSkillPresence in
  * skill-presence-service.ts, it never deletes or rewrites the presence file:
  * the statusLine runs on every turn and must have zero side effects.
+ *
+ * Slice 2026-08-05-statusline-sid-scoped-lease-B: the read no longer falls
+ * back to the project-level `.peaks/_runtime/active-skill.json` (or its
+ * legacy `.peaks/.active-skill.json`). The canonical lease projection is
+ * the only source. When `callerId === null` (non-IDE caller), the read
+ * picks the most recent in-flight lease across all callers; this is the
+ * documented back-compat path.
  */
-const PRESENCE_FILE = '.peaks/_runtime/active-skill.json';
-const PRESENCE_FILE_LEGACY = '.peaks/.active-skill.json';
 const STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
 function resolveCwdFromStdin(stdin) {
     const fromWorkspace = stdin?.workspace?.current_dir ?? stdin?.workspace?.project_dir;
@@ -113,61 +119,99 @@ function readActiveLeaf(projectRoot, sessionId) {
  * Read the presence file without any side effects. Returns null when the file is
  * absent (idle) and a sentinel object for malformed content (invalid-presence).
  *
- * When `callerId` is non-null, delegates to the canonical lease resolver
- * (presence-lease-service via active-skill-resolver) so the read is
- * session+caller-isolated. When `callerId` is null, falls back to the
- * project-level single-file read (back-compat for callers that don't pass
- * a callerId yet, e.g. legacy CLI invocations).
+ * Both branches now route through the canonical sid-scoped lease projection
+ * (slice 2026-08-05-statusline-sid-scoped-lease-B):
+ *   - `callerId !== null` → `resolveActiveSkillForCaller` with the canonical
+ *     (non-legacy) lease projection, filtered to this callerId. When the
+ *     callerId-filtered resolution returns `source: 'none'` (no lease under
+ *     this callerId), retry once with `callerId: null` so the read falls back
+ *     to the session's most-recent in-flight lease. AC4 multi-tenant isolation
+ *     is preserved: when callerId A DOES have a lease, the first call returns
+ *     it and the fallback never fires — callerId B's lease is never surfaced
+ *     to callerId A. (Slice 2026-08-05-statusline-empty-render-and-short-sid-suffix.)
+ *   - `callerId === null` → enumerate `listPresenceLeases` for the
+ *     canonical session and pick the most recent in-flight lease. Back-compat
+ *     for non-IDE callers (e.g. legacy CLI invocations) that have no callerId.
+ *
+ * No fallback to `.peaks/_runtime/active-skill.json` (or its legacy path):
+ * the canonical lease projection is the single source of truth. When no
+ * in-flight leases exist, the read returns `{ presence: null, invalid: false }`
+ * and the renderer falls back to the idle state.
  */
 function readPresenceReadOnly(projectRoot, callerId) {
     if (callerId !== null) {
+        let firstResolution = null;
         try {
-            const resolution = resolveActiveSkillForCaller(projectRoot, { legacyPresence: true, callerId });
-            if (resolution.source === 'none' || resolution.skill === null) {
-                return { presence: null, invalid: false };
-            }
+            firstResolution = resolveActiveSkillForCaller(projectRoot, { callerId });
+        }
+        catch {
+            return { presence: null, invalid: true };
+        }
+        if (firstResolution.source !== 'none' && firstResolution.skill !== null) {
             return {
                 presence: {
-                    skill: resolution.skill,
-                    ...(resolution.mode !== null ? { mode: resolution.mode } : {}),
+                    skill: firstResolution.skill,
+                    ...(firstResolution.mode !== null ? { mode: firstResolution.mode } : {}),
                 },
                 invalid: false,
             };
         }
-        catch {
-            return { presence: null, invalid: true };
-        }
+        // callerId didn't match any lease — fall back to the session's most
+        // recent in-flight lease (the callerId === null branch below). This
+        // rescues the case where the harness pipes a `CLAUDE_CODE_SESSION_ID`
+        // that differs from the active lease's callerId (peaks-code sessions
+        // started from a different outer session id, etc.).
+        return readPresenceReadOnly(projectRoot, null);
+    }
+    // callerId === null branch: enumerate the canonical session dir's leases
+    // and pick the most recent in-flight lease. This is the back-compat path
+    // for non-IDE callers that don't supply a callerId.
+    let sessionId = null;
+    try {
+        sessionId = getSessionIdCanonical(projectRoot);
     }
-    const presencePath = resolve(projectRoot, PRESENCE_FILE);
-    // Back-compat: prefer the new canonical path; fall back to the legacy
-    // `.peaks/.active-skill.json` for one minor release.
-    const pathToRead = existsSync(presencePath) ? presencePath : resolve(projectRoot, PRESENCE_FILE_LEGACY);
-    if (!existsSync(pathToRead)) {
+    catch {
         return { presence: null, invalid: false };
     }
+    if (sessionId === null) {
+        return { presence: null, invalid: false };
+    }
+    let leases = [];
     try {
-        const parsed = JSON.parse(readFileSync(pathToRead, 'utf8'));
-        if (!parsed || typeof parsed !== 'object') {
-            return { presence: null, invalid: true };
-        }
-        const candidate = parsed;
-        if (typeof candidate.skill !== 'string' || candidate.skill.length === 0) {
-            return { presence: null, invalid: true };
-        }
-        return {
-            presence: {
-                skill: candidate.skill,
-                ...(typeof candidate.mode === 'string' ? { mode: candidate.mode } : {}),
-                ...(typeof candidate.gate === 'string' ? { gate: candidate.gate } : {}),
-                ...(typeof candidate.setAt === 'string' ? { setAt: candidate.setAt } : {}),
-                ...(typeof candidate.claudeSessionId === 'string' ? { claudeSessionId: candidate.claudeSessionId } : {})
-            },
-            invalid: false
-        };
+        leases = listPresenceLeases(projectRoot, sessionId);
     }
     catch {
         return { presence: null, invalid: true };
     }
+    const inFlight = leases
+        .filter((l) => l.status === 'preparing' || l.status === 'running')
+        .filter((l) => typeof l.skill === 'string' && l.skill.length > 0);
+    if (inFlight.length === 0) {
+        return { presence: null, invalid: false };
+    }
+    // Most recent wins — sort by `lastHeartbeat` desc, fall back to `startedAt`.
+    const sorted = inFlight.slice().sort((a, b) => {
+        const hb = b.lastHeartbeat.localeCompare(a.lastHeartbeat);
+        if (hb !== 0)
+            return hb;
+        return b.startedAt.localeCompare(a.startedAt);
+    });
+    const latest = sorted[0];
+    if (latest === undefined || typeof latest.skill !== 'string' || latest.skill.length === 0) {
+        return { presence: null, invalid: false };
+    }
+    // Leases on disk may carry an optional `mode` field (the lease constructor
+    // spreads `input.mode` when present); the typed `SkillPresenceLease` does
+    // not declare it, so widen the read shape here.
+    const latestMode = latest.mode;
+    return {
+        presence: {
+            skill: latest.skill,
+            ...(typeof latestMode === 'string' && latestMode.length > 0 ? { mode: latestMode } : {}),
+            setAt: latest.startedAt,
+        },
+        invalid: false,
+    };
 }
 export function buildStatusLineModel(stdin, nowMs) {
     const cwd = resolveCwdFromStdin(stdin);
@@ -176,17 +220,30 @@ export function buildStatusLineModel(stdin, nowMs) {
     // and reads `.peaks/_runtime/<sid>/compact-lifecycle.json` (or its legacy
     // fallbacks). It replaces the active skill content when kind != 'none'.
     const compact = readCompactState(projectRoot, nowMs);
+    // Slice 2026-08-05-statusline-sid-only-marker: resolve the canonical
+    // session id once, up front, so the renderer can read it from the model
+    // without re-running `getSessionIdCanonical`. `null` when the project
+    // root is unbound OR when no `.peaks/_runtime/<sid>/` session exists.
+    let sessionId = null;
+    if (projectRoot !== null) {
+        try {
+            sessionId = getSessionIdCanonical(projectRoot);
+        }
+        catch {
+            sessionId = null;
+        }
+    }
     if (projectRoot === null) {
-        return { state: 'idle', projectRoot: null, presence: null, ageMs: null, compact, activeLeaf: null };
+        return { state: 'idle', projectRoot: null, presence: null, ageMs: null, compact, activeLeaf: null, sessionId: null };
     }
     // callerId resolves the read-side isolation; back-compat is `null`.
     const callerId = resolveCallerId(stdin);
     const { presence, invalid } = readPresenceReadOnly(projectRoot, callerId);
     if (invalid) {
-        return { state: 'invalid-presence', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null };
+        return { state: 'invalid-presence', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null, sessionId };
     }
     if (presence === null) {
-        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null };
+        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null, sessionId };
     }
     // Session binding: when the presence was stamped with a Claude session id and
     // the live session (from stdin) is a different one, the recorded skill belongs
@@ -195,7 +252,7 @@ export function buildStatusLineModel(stdin, nowMs) {
     // fall back to the time-based behavior below for backward compatibility.
     const liveSessionId = typeof stdin?.session_id === 'string' && stdin.session_id.length > 0 ? stdin.session_id : null;
     if (presence.claudeSessionId && liveSessionId && presence.claudeSessionId !== liveSessionId) {
-        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null };
+        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null, sessionId };
     }
     const setAtMs = presence.setAt ? Date.parse(presence.setAt) : Number.NaN;
     const ageMs = Number.isNaN(setAtMs) ? null : nowMs - setAtMs;
@@ -206,13 +263,12 @@ export function buildStatusLineModel(stdin, nowMs) {
     // bee skill (e.g. `peaks-rd`) alongside the orchestrator (e.g. `peaks-code`).
     let activeLeaf = null;
     try {
-        const sessionId = getSessionIdCanonical(projectRoot);
         activeLeaf = readActiveLeaf(projectRoot, sessionId);
     }
     catch {
         activeLeaf = null;
     }
-    return { state, projectRoot, presence, ageMs, compact, activeLeaf };
+    return { state, projectRoot, presence, ageMs, compact, activeLeaf, sessionId };
 }
 /**
  * Read-only compact state resolver. Resolves the canonical session id for the

package/dist/services/skills/skill-statusline-sid-suffix.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Pure short-sid suffix helpers for the Peaks statusLine.
+ *
+ * Extracted from `skill-statusline-renderer.ts` (slice
+ * 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+ * repair cycle) to keep the renderer under the Karpathy 800-line cap.
+ * The module is I/O-free and only depends on the read-only
+ * `StatusLineModel` shape from `skill-statusline-service.ts` plus the
+ * `StatusPalette` interface still owned by the renderer. Re-exports
+ * both helpers so the existing test surface (`formatShortSid` direct
+ * tests + `computeRootSuffix` helper-level tests in
+ * `tests/unit/skills/skill-statusline-sid-only-marker.test.ts`) keeps
+ * importing from the renderer for back-compat.
+ *
+ * Pure module — no I/O, no clock dependency, no side effects.
+ */
+import type { StatusLineModel } from './skill-statusline-service.js';
+/**
+ * Minimal palette slice consumed by {@link computeRootSuffix}. The full
+ * `StatusPalette` is defined as a module-private interface inside the
+ * renderer; the suffix helper only needs `trailSeparator`. Re-declared
+ * structurally so the helper has no upward import on the renderer.
+ */
+export interface SidSuffixPalette {
+    readonly trailSeparator: string;
+}
+/**
+ * Format a session id as a short, terminal-friendly tag.
+ *
+ * Returns the last kebab-segment of `sessionId` (e.g.
+ * `2026-08-04-session-3fe1be` → `3fe1be`), or the empty string when
+ * the input is empty. Pure; safe for ASCII rendering across
+ * PowerShell, Git Bash, and zsh (AC7).
+ *
+ * Slice 2026-08-05-statusline-empty-render-and-short-sid-suffix.
+ */
+export declare function formatShortSid(sessionId: string): string;
+/**
+ * Compute the project-root cell of the status line. Returns the
+ * `<trailSep><root>` portion (and optionally the ` [shortSid]` suffix).
+ *
+ * Pure helper — no I/O. The `sessionId` is read from the model that the
+ * service already resolved once via `getSessionIdCanonical`. Per-state
+ * matrix (see the docstring inside `renderStatusLine` in
+ * `skill-statusline-renderer.ts` for the AC/PB references):
+ *
+ *   - state === 'invalid-presence'           → no sid (G2 invariant)
+ *   - state === 'idle' | 'stale' | 'active'   → sid iff model.sessionId resolves
+ *     to a non-empty shortSid string
+ *   - rootLabelText === ''                   → empty string
+ *
+ * Exported so tests can drive the helper without spinning up the full
+ * renderer (marquee, palette, etc.).
+ */
+export declare function computeRootSuffix(model: StatusLineModel, rootLabelText: string, palette: SidSuffixPalette): string;

package/dist/services/skills/skill-statusline-sid-suffix.js

@@ -0,0 +1,65 @@
+/**
+ * Pure short-sid suffix helpers for the Peaks statusLine.
+ *
+ * Extracted from `skill-statusline-renderer.ts` (slice
+ * 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+ * repair cycle) to keep the renderer under the Karpathy 800-line cap.
+ * The module is I/O-free and only depends on the read-only
+ * `StatusLineModel` shape from `skill-statusline-service.ts` plus the
+ * `StatusPalette` interface still owned by the renderer. Re-exports
+ * both helpers so the existing test surface (`formatShortSid` direct
+ * tests + `computeRootSuffix` helper-level tests in
+ * `tests/unit/skills/skill-statusline-sid-only-marker.test.ts`) keeps
+ * importing from the renderer for back-compat.
+ *
+ * Pure module — no I/O, no clock dependency, no side effects.
+ */
+/**
+ * Format a session id as a short, terminal-friendly tag.
+ *
+ * Returns the last kebab-segment of `sessionId` (e.g.
+ * `2026-08-04-session-3fe1be` → `3fe1be`), or the empty string when
+ * the input is empty. Pure; safe for ASCII rendering across
+ * PowerShell, Git Bash, and zsh (AC7).
+ *
+ * Slice 2026-08-05-statusline-empty-render-and-short-sid-suffix.
+ */
+export function formatShortSid(sessionId) {
+    if (sessionId.length === 0)
+        return '';
+    const last = sessionId.split('-').pop();
+    return last ?? sessionId;
+}
+/**
+ * Compute the project-root cell of the status line. Returns the
+ * `<trailSep><root>` portion (and optionally the ` [shortSid]` suffix).
+ *
+ * Pure helper — no I/O. The `sessionId` is read from the model that the
+ * service already resolved once via `getSessionIdCanonical`. Per-state
+ * matrix (see the docstring inside `renderStatusLine` in
+ * `skill-statusline-renderer.ts` for the AC/PB references):
+ *
+ *   - state === 'invalid-presence'           → no sid (G2 invariant)
+ *   - state === 'idle' | 'stale' | 'active'   → sid iff model.sessionId resolves
+ *     to a non-empty shortSid string
+ *   - rootLabelText === ''                   → empty string
+ *
+ * Exported so tests can drive the helper without spinning up the full
+ * renderer (marquee, palette, etc.).
+ */
+export function computeRootSuffix(model, rootLabelText, palette) {
+    if (!rootLabelText)
+        return '';
+    let suffix = `${palette.trailSeparator}${rootLabelText}`;
+    if (model.state === 'invalid-presence')
+        return suffix;
+    // Defensive: older callers may build a model without `sessionId`
+    // (the field is optional in some test fixtures predating the
+    // sid-only-marker slice). Treat undefined the same as null.
+    if (model.sessionId === null || model.sessionId === undefined)
+        return suffix;
+    const short = formatShortSid(model.sessionId);
+    if (short.length === 0)
+        return suffix;
+    return `${suffix} [${short}]`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-loop",
-  "version": "4.0.11",
+  "version": "4.0.13",
   "description": "Loop Engineering CLI — workflow primitive / loop guards / evaluators / slice orchestration",
   "author": "SquabbyZ",
   "keywords": [
@@ -100,9 +100,9 @@
     "headroom-ai": "0.22.4",
     "yaml": "^2.9.0",
     "zod": "^3.25.76",
-    "peaks-loop-shared-channel": "0.0.19",
-    "peaks-loop-mut": "0.1.15",
-    "peaks-loop-shared": "0.0.42"
+    "peaks-loop-shared": "0.0.44",
+    "peaks-loop-mut": "0.1.17",
+    "peaks-loop-shared-channel": "0.0.21"
   },
   "peerDependencies": {
     "@alibaba-group/open-code-review": "1.3.1"

package/skills/peaks-code/SKILL.md

@@ -102,6 +102,10 @@ Full content extracted to **`references/startup-sequence.md`** (Steps 0 / 0.5-0.
 
 **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.
 
+### Peaks-Loop Step 0.51 — `orchestrator-can-do` probe (slice 2026-08-05, lesson-encoded CLI)
+
+> **Before deciding to push a slice to the next session**, run `peaks code orchestrator-can-do --slice-spec '<text>' --json`. The command evaluates 4 boundary questions (source code? sub-agent available? requires user decision? context sustainable?) and returns whether the slice can be done in the current session. Default to `canDoInSession=true` unless hard blockers are present; sub-agent dispatch (`peaks sub-agent dispatch rd`) is the canonical delegation path for source-code changes. This encodes the 2026-08-05 lesson — orchestrator MUST NOT Edit/Write `src/` directly, but MUST delegate via sub-agent dispatch. See `.peaks/memory/2026-08-05-peaks-code-orchestrator-capability-misjudgment.md`.
+
 ### Peaks-Loop Step N+2: Auto-compact at the warning line (v2.13.0 zero-pause contract)
 
 > **Zero-pause contract.** When context usage crosses the pre-compact threshold, peaks-loop **automatically fires `peaks compact auto --execute` — the LLM does NOT prompt the user to run `/compact` manually**. Stale prose that says "ask the user to compact" silently stalls the workflow. The v2.13.0 contract makes auto-compact a system responsibility, not a user action.
@@ -127,6 +131,8 @@ Full content extracted to **`references/startup-sequence.md`** (Steps 0 / 0.5-0.
 
 If the prose audit (`peaks audit red-lines`) flags any of the above, the slice is **blocked** until the prose is rewritten.
 
+See also: references/session-overload-signal-index.md for the 7-signal lookup table the LLM consults before deciding to open a new session.
+
 ## CLI Drift Index (sediment 2026-07-09)
 
 > **Reading guide:** Verified against peaks-loop 4.0.0-beta.6. Each drift below is annotated inline at the relevant step with a `> CLI reality check`. On `error: unknown option ...`, **read the inline reality check first** before guessing.

package/skills/peaks-code/references/session-overload-signal-index.md

@@ -0,0 +1,60 @@
+# Session Overload Signal Index
+
+> Single-source lookup for the LLM-side "should I open a new session?" decision.
+> Slice 2026-08-05-session-overload-signal-index.
+
+## What this doc is
+
+When the LLM senses context pressure, it must consult these 7 signals before
+deciding to (a) auto-compact, (b) refuse the next slice, or (c) ask the user to
+open a new session. The contract is: **LLM never re-asks the user about
+cost/length/context** (red line #2 of `references/job-loop.md`). This index is
+the lookup table the LLM must consult in lieu of intuition.
+
+## The 7 signals
+
+| # | Signal source | Threshold | File / CLI | LLM action |
+|---|---|---|---|---|
+| 1 | prompt size (main session) | 50% / 75% / 80% / 90% | `src/services/context/threshold.ts`; probe via `peaks code context-now` | soft-warn at 50%; consider compact at 75%; MUST NOT auto-compact mid-batch (D6.e); Job mode ≥ 0.85 ⇒ MANDATORY `peaks compact auto --execute` |
+| 2 | auto-compact zone | 0.85 pre-compact / 0.95 red-line | `src/services/code/auto-compact-orchestrator.ts`; `--enforce-job-mode` flag | Auto-fires `peaks compact auto --execute`; LLM MUST NOT prompt user to compact (zero-pause contract v2.13.0) |
+| 3 | sub-agent dispatch prompt size | 50% / 75% / 80% | `src/services/context/context-guard.ts`; `peaks sub-agent-dispatch-guard` PreToolUse hook | soft-warn at 50%; CONTEXT_NEAR_LIMIT at 75%; hard-reject at 80% (CLI + hook double-guard) |
+| 4 | statusline compact bar | visual | `src/services/compact-statusline/compact-statusline-service.ts` | ambient UI; surfaces queued/preparing/compacting/verifying/completed/failed/stalled |
+| 5 | in-flight batch deferral | D6.e | `src/services/code/auto-compact-modes.ts` | defer compact until batch lands (NOT "new session") |
+| 6 | compact stalled | 120s heartbeat timeout | `compact-lifecycle-store.ts` | ambient "stalled" detail in statusline |
+| 7 | sub-agent heartbeat missing | per-role TTL | `peaks sub-agent heartbeat`; `peaks heartbeat-watch` | orchestrator-side warning, not LLM-driven "new session" |
+
+## Hard rules
+
+- peaks-code SKILL.md red line #2 (see `references/job-loop.md`):
+  **Re-ask the user about cost / length / context is forbidden**.
+  The LLM MUST NOT prompt the user to open a new session based on overload
+  intuition alone; it MUST consult the 7 signals above and prefer auto-compact /
+  sub-agent dispatch guard / heartbeat-watch first.
+- "Open a new session" is a **last resort** after auto-compact has been
+  attempted and the slice cannot fit. The user's role is to receive the
+  handoff capsule, not to micro-manage session lifecycle.
+
+## Decision flowchart
+
+```
+LLM senses context pressure
+  ├─► Probe `peaks code context-now --json`
+  │   ├─ ratio < 0.50  → continue (no action)
+  │   ├─ 0.50 ≤ ratio < 0.75 → soft-warn; continue
+  │   ├─ 0.75 ≤ ratio < 0.85 → compact-zone candidate
+  │   │     ├─ Job mode → MUST auto-compact now
+  │   │     └─ non-Job  → wait for next idle turn, then compact
+  │   ├─ 0.85 ≤ ratio < 0.95 → pre-compact zone; auto-compact MUST fire
+  │   └─ ratio ≥ 0.95       → red-line; synchronous gate (Karpathy §4)
+  ├─► Check statusline compact bar (signal #4)
+  │   ├─ queued / preparing / compacting / verifying → wait
+  │   ├─ failed → read failure reason, do NOT spawn new session
+  │   └─ stalled (>120s) → surface to user as a blocker, not a new-session ask
+  └─► Check sub-agent dispatch guard (signal #3)
+      ├─ 75% CONTEXT_NEAR_LIMIT → warn, continue with smaller prompt
+      └─ 80% PROMPT_TOO_LARGE → hard-reject; refactor the prompt
+
+Only after ALL three checks above have been attempted without resolution:
+emit the `peaks session split-handoff` capsule (NOT in this slice; follow-up)
+and the user opens a new session in their own time.
+```