peaks-loop 4.1.2 → 4.1.3

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

@@ -0,0 +1,124 @@
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { fail } from 'peaks-loop-shared/result';
+import { runAutoCompact } from '../../services/code/auto-compact-orchestrator.js';
+import { probeInFlightBatch } from '../../services/workflow/workflow-inflight-probe.js';
+import { readActiveSid } from './code-runtime-session.js';
+import { buildAutoCompactEnvelope } from './code-auto-compact-envelope.js';
+const 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 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 ' +
+    'the hook could never run at all. rid-027 ' +
+    'adds `--mode <mode>`: `standard` (0.85/0.95) or `partial` (0.70/0.85 ' +
+    'for 24h long-run mode).';
+/** The invalid-`--mode` branch, lifted verbatim out of the action body. */
+function reportInvalidAutoCompactMode(io, modeName, json) {
+    printResult(io, fail('code.auto-compact', 'AUTO_COMPACT_INVALID_MODE', `Invalid --mode '${modeName}'. Valid values: standard | partial.`, null, ['Re-run with --mode standard or --mode partial.']), json);
+    process.exitCode = 1;
+}
+/**
+ * The `runAutoCompact` input object, lifted verbatim: it reads only its two
+ * parameters, so it has no ordering dependency on the call site.
+ */
+function buildAutoCompactInput(opts, modeName) {
+    // Slice 4.0.8 (D4d): production `inFlightBatch` MUST come from
+    // the workflow graph probe. The legacy `--in-flight-batch`
+    // boolean CLI flag is a TEST-ONLY seam (gated by
+    // `PEAKS_TEST_SEAM === '1'`). When the env flag is unset
+    // (the production case), we wire `probeInflightBatch` to the
+    // canonical `workflow-inflight-probe.ts` service so the
+    // production decision is graph-backed, not lease-age.
+    const isTestSeam = process.env.PEAKS_TEST_SEAM === '1';
+    return {
+        projectRoot: opts.project,
+        sessionId: opts.sessionId ?? readActiveSid(opts.project) ?? undefined,
+        ...(isTestSeam && opts.inFlightBatch === true
+            ? { inFlightBatch: { hasInFlightBatch: true } }
+            : {}),
+        ...(!isTestSeam
+            ? {
+                probeInflightBatch: () => {
+                    // Synchronous probe: the workflow-inflight-probe
+                    // service is pure / synchronous (no I/O). The
+                    // empty `graphs` array is the production CLI
+                    // default — callers that want a richer fixture
+                    // (e.g. `peaks session 24h-mode`) should hand-roll
+                    // a probe and pass it via the orchestrator's
+                    // input. When no graph is materialized, the
+                    // probe returns `inFlightBatch: false`, matching
+                    // the 4.0.7 zero-pause contract for stock
+                    // projects.
+                    const out = probeInFlightBatch({ now: new Date().toISOString(), graphs: [] });
+                    return out.inFlightBatch === true;
+                }
+            }
+            : {}),
+        force: opts.force === true,
+        bypassRedLine: opts.bypassRedLine === true,
+        // Forward the FLAG verbatim — `undefined` when the user named no
+        // mode — so the orchestrator's fallback to the presence-derived
+        // mode can actually run. Forwarding the validated `modeName` is
+        // what disabled 24h → partial.
+        mode: opts.mode === undefined ? undefined : modeName
+    };
+}
+/** The catch branch, lifted verbatim out of the action body. */
+function reportAutoCompactFailure(io, err, json) {
+    printResult(io, fail('code.auto-compact', 'AUTO_COMPACT_FAILED', getErrorMessage(err), null, [
+        'Verify the project path + session id and try again'
+    ]), json);
+    process.exitCode = 1;
+}
+/** The action body, lifted to a module-level function so both it and the registrar fit in 50 lines. */
+async function runAutoCompactAction(opts, io) {
+    try {
+        const { isValidMode } = await import('../../services/code/auto-compact-modes.js');
+        const modeName = opts.mode ?? 'standard';
+        if (!isValidMode(modeName)) {
+            reportInvalidAutoCompactMode(io, modeName, opts.json);
+            return;
+        }
+        const result = await runAutoCompact(buildAutoCompactInput(opts, modeName));
+        const code = result.code;
+        const exitOk = result.ok || code === 'AUTO_COMPACT_SKIP' || code === 'AUTO_COMPACT_WAIT';
+        // Adapt AutoCompactResult → ResultEnvelope so printResult's
+        // generic accepts it. The orchestrator envelope carries
+        // `data` on success-path and `nextActions` on the error
+        // path; surface both directly to the user.
+        printResult(io, buildAutoCompactEnvelope(result), opts.json);
+        if (!exitOk)
+            process.exitCode = 1;
+    }
+    catch (err) {
+        reportAutoCompactFailure(io, err, opts.json);
+    }
+}
+export function registerCodeAutoCompactCommand(code, io) {
+    addJsonOption(code
+        .command('auto-compact')
+        .description(AUTO_COMPACT_DESCRIPTION)
+        .requiredOption('--project <path>', 'target project root')
+        .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)')
+        // 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
+        // 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
+        // silently disables "24h mode auto-selects partial" — the help text
+        // below promises it. Absence must stay absent.
+        .option('--mode <mode>', 'auto-compact mode (standard | partial). Default: standard. 24h mode auto-selects partial.')).action((opts) => runAutoCompactAction(opts, io));
+}

package/dist/cli/commands/code-auto-compact-envelope.d.ts

@@ -0,0 +1,22 @@
+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>;

package/dist/cli/commands/code-auto-compact-envelope.js

@@ -0,0 +1,39 @@
+// The `peaks code auto-compact` result adapter, on its own so the CHANNEL each
+// fact chooses can be asserted directly, without a real red-line probe.
+import { fail, ok } from 'peaks-loop-shared/result';
+import { harnessWindowSyncWarning } from '../../services/context/harness-window-config.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
+    };
+}

package/dist/cli/commands/code-context-audit-command.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function registerCodeContextAuditCommand(code: Command, io: ProgramIO): void;

package/dist/cli/commands/code-context-audit-command.js

@@ -0,0 +1,68 @@
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { ok } from 'peaks-loop-shared/result';
+import { auditContext } from '../../services/context/context-audit.js';
+import { resolveOuterSessionId } from '../../services/session/binding-status-service.js';
+import { readActiveSid } from './code-runtime-session.js';
+const CONTEXT_AUDIT_DESCRIPTION = "Slice 2026-09-10 Slice A: report what fills the current session's " +
+    'context window, grouped by tool + short input key (command line / ' +
+    "path tail / pattern), sorted by bytes. Locates the CURRENT session's " +
+    "IDE transcript through the active adapter's " +
+    '`compact.resolveTranscriptPath` (vendor-neutral); emits total bytes, ' +
+    'entry count, and the top-N groups ' +
+    '(`{tool, key, bytes, pctOfTotal, count}`). Read-only and fail-soft — ' +
+    'a missing/oversized/corrupt transcript returns `available:false` ' +
+    'with a reason and never blocks. Never dumps tool result content.';
+/** The catch branch, lifted verbatim out of the action body (fail-soft, exit code untouched). */
+function reportContextAuditFailure(io, err, json) {
+    printResult(io, ok('code.context-audit', {
+        available: false,
+        reason: `audit-failed: ${getErrorMessage(err)}`,
+        transcriptPath: null,
+        totalBytes: 0,
+        entryCount: 0,
+        groupCount: 0,
+        topN: 0,
+        entries: []
+    }, [], ['context-audit is a read-only probe; continue without it.']), json);
+}
+/** The action body, lifted to a module-level function so both it and the registrar fit in 50 lines. */
+function runCodeContextAudit(opts, io) {
+    try {
+        // `resolveOuterSessionId` checks the env signal FIRST, so the peaks
+        // session id is only a fallback lookup key — mirror context-now's
+        // 'unknown' default so an unbound presence still resolves via env.
+        const sessionId = opts.sessionId ?? readActiveSid(opts.project) ?? 'unknown';
+        const outerSessionId = resolveOuterSessionId(opts.project, sessionId);
+        const result = auditContext({
+            outerSessionId: outerSessionId ?? null,
+            ...(opts.top !== undefined ? { topN: opts.top } : {}),
+            ...(opts.transcript !== undefined ? { transcriptPath: opts.transcript } : {})
+        });
+        // Fail-soft contract: unavailability is DATA, not an error. The exit
+        // code stays 0 so a `context-audit` call can never block a workflow.
+        const nextActions = result.available
+            ? [
+                `${result.entryCount} tool result(s) across ${result.groupCount} group(s); showing top ${result.entries.length}.`
+            ]
+            : [
+                `context-audit unavailable: ${result.reason ?? 'unknown'} — continue without it (read-only probe).`
+            ];
+        printResult(io, ok('code.context-audit', { ...result }, [], nextActions), opts.json);
+    }
+    catch (err) {
+        reportContextAuditFailure(io, err, opts.json);
+    }
+}
+export function registerCodeContextAuditCommand(code, io) {
+    // WHAT fills the orchestrator window. `context-now` returns a ratio; this
+    // returns the grouped byte breakdown of tool results from the live
+    // transcript. Read-only + fail-soft: an unavailable transcript reports
+    // `available:false` with a reason and NEVER sets a non-zero exit code.
+    addJsonOption(code
+        .command('context-audit')
+        .description(CONTEXT_AUDIT_DESCRIPTION)
+        .requiredOption('--project <path>', 'target project root')
+        .option('--session-id <sid>', 'override session id (default: read from active presence)')
+        .option('--top <n>', 'number of top entries to emit (default 15, max 100)', (value) => Number(value))
+        .option('--transcript <path>', 'override the transcript jsonl path (test seam)')).action((opts) => runCodeContextAudit(opts, io));
+}

package/dist/cli/commands/code-context-now-command.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function registerCodeContextNowCommand(code: Command, io: ProgramIO): void;

package/dist/cli/commands/code-context-now-command.js

@@ -0,0 +1,124 @@
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+import { readJobShapeDecision, JobShapeDecisionError } from '../../services/code/job-shape-decision.js';
+import { resolveOuterSessionId } from '../../services/session/binding-status-service.js';
+import { resolveCanonicalProjectRoot } from '../../services/config/config-service.js';
+import { readActiveSid } from './code-runtime-session.js';
+import { buildContextNowData, buildContextNowNextActions, buildContextNowWarnings, readContextNowHarness, resolveContextNowDecision } from './code-context-now-envelope.js';
+const CONTEXT_NOW_DESCRIPTION = "v2.13.0 AC-1: read the active IDE adapter's context-fill % " +
+    'without requiring the LLM to pass --prompt-size <bytes> manually. ' +
+    '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 / 2026-09-12: the mode's pre-compact line emits " +
+    'action=auto-compact-now (MANDATORY, single-rid included) and ' +
+    'the red line 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).';
+/**
+ * The two flags the action derives before any probe: the `--prompt-size`
+ * override (guarded) and the Job-mode label. Pure in `opts` — no ordering
+ * dependency on the call site.
+ */
+function resolveContextNowFlags(opts) {
+    // guard rejects non-finite / negative values; only finite
+    // non-negative numbers reach the reader. Undefined → no override.
+    let promptSizeBytes;
+    if (opts.promptSize !== undefined) {
+        const parsed = Number(opts.promptSize);
+        if (Number.isFinite(parsed) && parsed >= 0) {
+            promptSizeBytes = parsed;
+        }
+    }
+    // v3.1.2: detect Job mode from job-shape.json when --enforce-job-mode
+    // is not explicitly passed. The LLM is the source of truth for
+    // whether the request is Job-shaped; the recorded decision is.
+    let isJobMode = opts.enforceJobMode === true;
+    if (!isJobMode) {
+        try {
+            const sessionIdForDecision = opts.sessionId ?? readActiveSid(opts.project);
+            if (sessionIdForDecision !== null) {
+                const record = readJobShapeDecision(opts.project, sessionIdForDecision);
+                if (record.decision.isJob)
+                    isJobMode = true;
+            }
+        }
+        catch (err) {
+            if (!(err instanceof JobShapeDecisionError))
+                throw err;
+            // missing/malformed decision file is fine — fall back to advisory.
+        }
+    }
+    return { promptSizeBytes, isJobMode };
+}
+/** The catch branch, lifted verbatim out of the action body. */
+function reportContextNowFailure(io, err, json) {
+    printResult(io, fail('code.context-now', 'CONTEXT_NOW_FAILED', getErrorMessage(err), null, [
+        'Verify the project path and try again'
+    ]), json);
+    process.exitCode = 1;
+}
+/** The action body, lifted to a module-level function so both it and the registrar fit in 50 lines. */
+async function runCodeContextNow(opts, io) {
+    try {
+        const { readContextPercent } = await import('../../services/context/auto-compact-reader.js');
+        const flags = resolveContextNowFlags(opts);
+        const sessionId = opts.sessionId ?? readActiveSid(opts.project) ?? 'unknown';
+        const outerSessionId = resolveOuterSessionId(opts.project, sessionId);
+        const probe = readContextPercent({
+            projectRoot: opts.project,
+            sessionId,
+            outerSessionId,
+            env: process.env,
+            promptSizeBytes: flags.promptSizeBytes
+        });
+        // Promote `--project .` (what the PreToolUse hook passes) to the git
+        // root ONCE, for both of the consumers below: the settings path the
+        // harness window is written to, and the session directory the witness
+        // is read from, must not depend on the caller's cwd — and an absolute
+        // path is what the envelope then reports back to the operator. This
+        // resolves through `git rev-parse --show-toplevel`, i.e. a whole
+        // process spawn (measured 2026-09-14: med 111.8 ms per call on this
+        // host), so calling it twice with the same argument charged the witness
+        // read it precedes — 0.027 ms — roughly 4,000x its own cost.
+        const canonicalProjectRoot = resolveCanonicalProjectRoot(opts.project);
+        const harness = readContextNowHarness(canonicalProjectRoot, sessionId, outerSessionId, probe);
+        const decision = resolveContextNowDecision(canonicalProjectRoot, probe.ratio, flags.isJobMode);
+        printResult(io, ok('code.context-now', buildContextNowData({
+            probe,
+            ratioPct: (probe.ratio * 100).toFixed(1),
+            isJobMode: flags.isJobMode,
+            promptSizeBytes: flags.promptSizeBytes,
+            decision,
+            harness
+        }), buildContextNowWarnings(harness), buildContextNowNextActions(decision, harness)), 
+        // `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) {
+        reportContextNowFailure(io, err, opts.json);
+    }
+}
+export function registerCodeContextNowCommand(code, io) {
+    addJsonOption(code
+        .command('context-now')
+        .description(CONTEXT_NOW_DESCRIPTION)
+        .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: 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((opts) => runCodeContextNow(opts, io));
+}

package/dist/cli/commands/code-context-now-envelope.d.ts

@@ -0,0 +1,66 @@
+import type { ContextPercentProbe } from '../../services/context/auto-compact-types.js';
+/**
+ * The harness half of the probe: the window sync, its warning, the witness read
+ * and its notice. Lifted verbatim from the action body — it reads only its
+ * parameters.
+ */
+export declare function readContextNowHarness(canonicalProjectRoot: string, sessionId: string, outerSessionId: string | null | undefined, probe: ContextPercentProbe): {
+    harnessWindow: import("../../services/context/harness-window-config.js").HarnessWindowSyncResult | null;
+    harnessWindowWarning: string | null;
+    harnessWitness: import("../../services/context/harness-context-witness.js").HarnessWitnessComparison;
+    witnessNotice: string | null;
+};
+type ContextNowHarness = ReturnType<typeof readContextNowHarness>;
+/**
+ * Slice H4 (rid=h4-context-now-mode-blind): ONE table, ONE mode
+ * resolver. The hard-coded ladder that used to live in the action read no mode
+ * at all, so on a 24h run (`partial` = 0.65/0.70/0.85) it answered `soft-warn`
+ * + `next: null` across [0.70, 0.85) — the band in which
+ * `peaks code auto-compact` had already decided to compact.
+ */
+export declare function resolveContextNowDecision(canonicalProjectRoot: string, ratio: number, isJobMode: boolean): {
+    action: "ok" | "soft-warn" | "red-line" | "auto-compact-now";
+    next: string | null;
+    verdict: string;
+    bands: {
+        softWarn: string;
+        preCompact: string;
+        redLine: string;
+        preCompactRatio: string;
+        redLineRatio: string;
+    };
+    gateModeNotice: string;
+};
+type ContextNowDecision = ReturnType<typeof resolveContextNowDecision>;
+/** The envelope's `data` record, lifted verbatim out of the action body. */
+export declare function buildContextNowData(args: {
+    probe: ContextPercentProbe;
+    ratioPct: string;
+    isJobMode: boolean;
+    promptSizeBytes: number | undefined;
+    decision: ContextNowDecision;
+    harness: ContextNowHarness;
+}): {
+    ratio: number;
+    ratioPct: string;
+    verdict: string;
+    action: "ok" | "soft-warn" | "red-line" | "auto-compact-now";
+    next: string | null;
+    jobMode: boolean;
+    source: string;
+    ide: string;
+    capacityBytes: number | undefined;
+    rawBytes: number | null;
+    rawTokens: number | null;
+    capacityTokens: number | null;
+    capacitySource: string | null;
+    bytesPrompt: number | null;
+    capturedAt: string;
+    harnessWindow: import("../../services/context/harness-window-config.js").HarnessWindowSyncResult | null;
+    harnessWitness: import("../../services/context/harness-context-witness.js").HarnessWitnessComparison;
+};
+/** The envelope's `warnings` array, lifted verbatim out of the action body. */
+export declare function buildContextNowWarnings(harness: ContextNowHarness): string[];
+/** The envelope's `nextActions` array, lifted verbatim out of the action body. */
+export declare function buildContextNowNextActions(decision: ContextNowDecision, harness: ContextNowHarness): string[];
+export {};

package/dist/cli/commands/code-context-now-envelope.js

@@ -0,0 +1,136 @@
+// The `peaks code context-now` envelope: the harness reading (window sync +
+// witness), the mode-resolved decision, and the `data` / `warnings` /
+// `nextActions` builders. Split out of `code-context-now-command.ts` when
+// compressing its long function pushed that file past the 300-line cap; every
+// body below is the original one, moved verbatim.
+import { resolveAutoCompactProfile } from '../../services/mode/mode-status-service.js';
+import { syncHarnessWindowForProject } from '../../services/context/auto-compact-reader.js';
+import { describeHarnessWindowSync, harnessWindowSyncWarning } from '../../services/context/harness-window-config.js';
+import { describeHarnessWitness, readAndCompareHarnessWitness } from '../../services/context/harness-context-witness.js';
+import { contextNowActionFor, contextNowBandLabels } from './code-context-now-mapping.js';
+/**
+ * The harness half of the probe: the window sync, its warning, the witness read
+ * and its notice. Lifted verbatim from the action body — it reads only its
+ * parameters.
+ */
+export function readContextNowHarness(canonicalProjectRoot, sessionId, outerSessionId, probe) {
+    // 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({
+        projectRoot: canonicalProjectRoot,
+        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);
+    // own number for the same quantity, captured by the statusline. This is
+    // OBSERVATION ONLY — it never feeds `verdict` / `action` / any threshold
+    // below. A wrong reading here must not be able to fire a compact.
+    const harnessWitness = readAndCompareHarnessWitness({
+        // The same promoted root as the harness-window write above, for the
+        // same reason: the statusline resolves its root from the harness
+        // payload (absolute), so a `--project .` from a hook would otherwise
+        // look for the witness somewhere else and report `absent` forever.
+        projectRoot: canonicalProjectRoot,
+        sessionId,
+        peaksRatio: probe.ratio,
+        peaksTokens: probe.rawTokens ?? null,
+        peaksWindowTokens: probe.capacityTokens ?? null,
+        outerSessionId: outerSessionId ?? null
+    });
+    const witnessNotice = describeHarnessWitness(harnessWitness);
+    return { harnessWindow, harnessWindowWarning, harnessWitness, witnessNotice };
+}
+/**
+ * Slice H4 (rid=h4-context-now-mode-blind): ONE table, ONE mode
+ * resolver. The hard-coded ladder that used to live in the action read no mode
+ * at all, so on a 24h run (`partial` = 0.65/0.70/0.85) it answered `soft-warn`
+ * + `next: null` across [0.70, 0.85) — the band in which
+ * `peaks code auto-compact` had already decided to compact.
+ */
+export function resolveContextNowDecision(canonicalProjectRoot, ratio, isJobMode) {
+    const compactMode = resolveAutoCompactProfile(canonicalProjectRoot);
+    const decided = contextNowActionFor(ratio, compactMode);
+    const action = decided.action;
+    const next = decided.next;
+    const verdict = action === 'red-line' ? 'red-line' : action === 'auto-compact-now' ? 'pre-compact' : action;
+    const bands = contextNowBandLabels(compactMode);
+    // in behaviour ABOVE 0.50 — both auto-fire at ≥0.85 and both red-line at
+    // ≥0.95". That was false: `partial` fires at 0.70, red-lines at 0.85.
+    // The lines now come from the table for the mode in force.
+    const gateModeNotice = isJobMode
+        ? `Job mode (job-shape.json isJob=true): the same ≥${bands.preCompactRatio} / ≥${bands.redLineRatio} thresholds apply, and the decision is recorded in job-shape.json.`
+        : `Single-rid mode: the same ≥${bands.preCompactRatio} / ≥${bands.redLineRatio} thresholds apply — ≥${bands.preCompactRatio} is MANDATORY auto-compact, not advisory.`;
+    return { action, next, verdict, bands, gateModeNotice };
+}
+/** The envelope's `data` record, lifted verbatim out of the action body. */
+export function buildContextNowData(args) {
+    const { probe, decision, harness } = args;
+    return {
+        ratio: probe.ratio,
+        ratioPct: `${args.ratioPct}%`,
+        verdict: decision.verdict,
+        action: decision.action,
+        next: decision.next,
+        jobMode: args.isJobMode,
+        source: probe.source,
+        ide: probe.ide,
+        capacityBytes: probe.capacityBytes,
+        rawBytes: probe.rawBytes ?? null,
+        rawTokens: probe.rawTokens ?? null,
+        capacityTokens: probe.capacityTokens ?? null,
+        // capacityTokens (env-override | config | model-heuristic |
+        // default) — null for byte/percent sources, which have no window.
+        capacitySource: probe.capacitySource ?? null,
+        bytesPrompt: args.promptSizeBytes ?? null,
+        capturedAt: probe.capturedAt,
+        // 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: harness.harnessWindow,
+        harnessWitness: harness.harnessWitness
+    };
+}
+/** The envelope's `warnings` array, lifted verbatim out of the action body. */
+export function buildContextNowWarnings(harness) {
+    return [
+        ...(harness.harnessWindowWarning === null ? [] : [harness.harnessWindowWarning]),
+        // AC3: the disagreement rides `warnings` — it is a fact about the
+        // state, not an instruction — and it is one-way. Never an
+        // AskUserQuestion (see .peaks/memory/auto-compact-threshold-policy.md).
+        ...(harness.witnessNotice === null ? [] : [harness.witnessNotice])
+    ];
+}
+/** The envelope's `nextActions` array, lifted verbatim out of the action body. */
+export function buildContextNowNextActions(decision, harness) {
+    const { action, next, bands, gateModeNotice } = decision;
+    return [
+        action === 'red-line'
+            ? `RED LINE: ≥ ${bands.redLine}%. 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'
+                ? `MANDATORY auto-compact (≥${bands.preCompact}%, every mode). Code MUST call \`${next}\` WITHOUT confirmation.`
+                : action === 'soft-warn'
+                    ? `Soft warn (${bands.softWarn}–${bands.preCompact}%). Continue working; the next \`peaks code auto-compact\` will re-check.`
+                    : `Below ${bands.softWarn}%. No action required.`,
+        gateModeNotice,
+        // Single wording, shared with `peaks code auto-compact` — see
+        // `describeHarnessWindowSync`.
+        describeHarnessWindowSync(harness.harnessWindow),
+        // AC3: the one-way hint that accompanies the `warnings` entry. Both
+        // channels carry the SAME fact in the shape each is read for
+        // (machine-readable warning vs human/LLM advice) — see
+        // `harnessWindowSyncWarning` / `describeHarnessWindowSync` above for
+        // the same split, and note this one never asks a question.
+        ...(harness.witnessNotice === null
+            ? []
+            : ['Re-probe with `peaks code context-now` to confirm; this is reported, not blocking.'])
+    ];
+}

package/dist/cli/commands/code-context-now-mapping.d.ts

@@ -0,0 +1,27 @@
+import { type AutoCompactMode } from '../../services/code/auto-compact-modes.js';
+/**
+ * Slice H4 (rid=h4-context-now-mode-blind) — the ONE mapping from the shared
+ * `CompactTrigger` to this command's `action` vocabulary, so the two cannot
+ * drift: the trigger is `evaluateCompactTrigger`, the same function `peaks
+ * code auto-compact` decides with.
+ *
+ * `auto-fire` maps to `soft-warn` in BOTH modes: that tier is `peaks skill
+ * presence`'s — the every-turn probe, which reads this same table and mode
+ * resolver — so `context-now` has no auto-fire tier of its own (SKILL.md
+ * "two probes, two thresholds"). Reporting it as `auto-compact-now` would
+ * change every non-24h session's output, which slice H4 forbids.
+ */
+export declare function contextNowActionFor(ratio: number, mode: AutoCompactMode): {
+    action: 'ok' | 'soft-warn' | 'auto-compact-now' | 'red-line';
+    next: string | null;
+};
+/** Slice H4: the labels `context-now` prints, read out of the table for the mode
+ *  in force — the old hard-coded "≥0.85 / ≥0.95 / 50–85%" told a 24h operator
+ *  the wrong lines. `*Ratio` is the `0.85` form `gateModeNotice` uses. */
+export declare function contextNowBandLabels(mode: AutoCompactMode): {
+    softWarn: string;
+    preCompact: string;
+    redLine: string;
+    preCompactRatio: string;
+    redLineRatio: string;
+};