peaks-loop 4.0.54 → 4.1.0

package/dist/cli/commands/code-mode-gate-plan-command.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `peaks code plan` — build and print a CodePlan without executing it.
+ *
+ * Extracted VERBATIM from `code-mode-gate-commands.ts` (job
+ * strict-remediation-abc, slice c1-eslint-family-sweep, leaf c4w1-cli-b) so
+ * the registration file clears the 300-line cap. The description, the
+ * `<change-id>` argument, the `--fast` / `--json` options, the stdout
+ * formatting (`SKIP`/`RUN ` + `repair=on|off` for `qa-cycle`), and the
+ * JSON-envelope shape `{ ok: true, data: plan }` are the code that was already
+ * there. Nothing here swallows anything and no new error handling was
+ * introduced.
+ */
+import type { Command } from 'commander';
+export declare function registerCodeModePlan(code: Command): void;

package/dist/cli/commands/code-mode-gate-plan-command.js

@@ -0,0 +1,23 @@
+import { buildCodePlan } from './code-commands.js';
+export function registerCodeModePlan(code) {
+    code
+        .command('plan')
+        .description('Build and print a CodePlan without executing it')
+        .argument('<change-id>', 'change id to plan against')
+        .option('--fast', 'fast mode: skip memory full-load, standards preflight, and QA repair loop', false)
+        .option('--json', 'emit JSON envelope')
+        .action((sessionId, opts) => {
+        const plan = buildCodePlan({ sessionId, fast: opts.fast === true });
+        if (opts.json === true) {
+            process.stdout.write(JSON.stringify({ ok: true, data: plan }) + '\n');
+        }
+        else {
+            process.stdout.write(`change-id: ${plan.sessionId}\n`);
+            for (const step of plan.steps) {
+                const flag = step.skipped ? 'SKIP' : 'RUN ';
+                const repair = step.id === 'qa-cycle' ? ` repair=${step.repairLoop === true ? 'on' : 'off'}` : '';
+                process.stdout.write(`  [${flag}] ${step.id}${repair}\n`);
+            }
+        }
+    });
+}

package/dist/cli/commands/code-mode-gate-should-pause-command.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `peaks code should-pause` — v2.11.0 D5 mode-gate CLI seam.
+ *
+ * Extracted VERBATIM from `code-mode-gate-commands.ts` (job
+ * strict-remediation-abc, slice c1-eslint-family-sweep, leaf c4w1-cli-b) so
+ * the registration file clears the 300-line cap and the
+ * `max-lines-per-function` / `complexity` findings that sat on the giant
+ * commander action arrow fall with it.
+ *
+ * The order of the four validation rejects (mode → step → hard-floor →
+ * commit-boundary-action), each `process.exitCode = 1`, the stale-presence
+ * override on `step-1-mode-select` (which prints an `ok(...)` envelope with
+ * `shouldPause: true` and reason `stale-presence — re-ask Step 1 (...)`), the
+ * outer try/catch that answers with SHOULD_PAUSE_FAILED +
+ * `process.exitCode = 1` — every one of those is the code that was already
+ * there. The envelope builders themselves live in
+ * `code-mode-gate-should-pause-envelope.ts`; `readActiveSidForModeGate` was
+ * kept in the registration file (a callback parameter here) so its
+ * catch-return-null grace frame keeps counting under the same path.
+ */
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+import { type ReadActiveSid } from './code-mode-gate-should-pause-envelope.js';
+export declare function registerCodeModeShouldPause(code: Command, io: ProgramIO, readActiveSid: ReadActiveSid): void;

package/dist/cli/commands/code-mode-gate-should-pause-command.js

@@ -0,0 +1,137 @@
+import { fail } from 'peaks-loop-shared/result';
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { GATED_STEPS, isCodeMode, isCommitBoundaryAction, isHardFloorCategory } from '../../services/code/mode-gate.js';
+import { checkStalePresence } from '../../services/skills/skill-presence-service.js';
+import { findProjectRoot } from '../../services/config/config-safety.js';
+import { handleDecision, handleStalePresence } from './code-mode-gate-should-pause-envelope.js';
+export function registerCodeModeShouldPause(code, io, readActiveSid) {
+    addJsonOption(code
+        .command('should-pause')
+        .description('v2.11.0 D5: ask the mode-gate whether the LLM should pause for an AskUserQuestion at a given step. ' +
+        'full-auto / 24h auto-proceed (recommended = chosen); assisted / strict pause. ' +
+        'The 3 hard-floor categories always pause regardless of mode. ' +
+        'v2.15.0 slice 002 AC-2: when --step step-1-mode-select AND the recorded skill presence is stale ' +
+        '(outer-session-mismatch / no-presence), the gate returns shouldPause: true with reason "stale-presence" ' +
+        'even if the user passed --mode full-auto. The re-ask is mandatory — sticky-mode from a previous ' +
+        'session is NOT authoritative.')
+        .requiredOption('--step <step>', `one of: ${GATED_STEPS.join(', ')}`)
+        // v2.18.4 slice 002-fix-first-run-step-gates (Bug 2):
+        // `--mode` is now OPTIONAL. Step 1's SEMANTIC is "ask the user
+        // what mode to use" — requiring --mode to ask mode is a
+        // chicken-and-egg. When --mode is omitted, default to
+        // 'full-auto' so the gate can still evaluate; the gate's hard-
+        // pause on `step-1-mode-select` (mode-selection-itself) will
+        // pause regardless, and the LLM-side caller can present
+        // AskUserQuestion without first knowing the mode.
+        .option('--mode <mode>', 'one of: full-auto, assisted, strict, 24h. Defaults to full-auto when omitted (Step 1 chicken-and-egg fix).')
+        .option('--hard-floor <category>', 'optional hard-floor override (irreversible-external-side-effect | authentication-credential | multi-day-investment | commit-boundary-side-effect)')
+        .option('--recommended <option>', 'recommended option label to log when auto-proceeding', 'recommended-option')
+        .option('--project <path>', 'v2.15.0 slice 002 AC-2: project root for presence:check-stale. Default: cwd. Pass only when step=step-1-mode-select.')
+        .option('--ignore-stale-presence', 'v2.15.0 slice 002 AC-2: skip the stale-presence check (test seam). Default false.')
+        .option('--commit-boundary-action <id>', 'v2.15.0 slice 002 AC-4 CLI seam (slice 002 repair): when the LLM is about to run a commit-boundary action (git push / tag / npm publish / global install), pass the action id here to force the hard-floor pause. Valid: git-push | git-tag | npm-publish | npm-install-global | peaks-global-install. Default: omitted (no override).')).action((opts) => {
+        runShouldPauseAction(io, opts, readActiveSid);
+    });
+}
+/**
+ * Run the four validation rejects in the exact order HEAD ran them, narrowing
+ * `mode` / `hardFloor` / `commitBoundaryActionId` to their service-layer
+ * unions. The first failure returns the envelope to print; the caller then
+ * prints it, sets `process.exitCode = 1`, and returns — same observable
+ * sequence as HEAD.
+ */
+function validateShouldPause(opts) {
+    const modeAndStep = validateModeAndStep(opts);
+    if (!modeAndStep.ok)
+        return modeAndStep;
+    const floors = validateHardFloorAndCommitBoundary(opts);
+    if (!floors.ok)
+        return floors;
+    return {
+        ok: true,
+        validated: {
+            mode: modeAndStep.mode,
+            step: modeAndStep.step,
+            hardFloor: floors.hardFloor,
+            commitBoundaryActionId: floors.commitBoundaryActionId
+        }
+    };
+}
+function validateModeAndStep(opts) {
+    const mode = opts.mode ?? 'full-auto';
+    if (!isCodeMode(mode)) {
+        return {
+            ok: false,
+            envelope: fail('code.should-pause', 'INVALID_MODE', `mode must be one of full-auto, assisted, strict, 24h (got "${mode}")`, { provided: mode }, ['Pass --mode full-auto | assisted | strict | 24h'])
+        };
+    }
+    if (!GATED_STEPS.includes(opts.step)) {
+        return {
+            ok: false,
+            envelope: fail('code.should-pause', 'INVALID_STEP', `step must be one of the 14 GATED_STEPS (got "${opts.step}")`, { provided: opts.step, allowed: [...GATED_STEPS] }, ['Pass --step <one of the 14 GATED_STEPS>'])
+        };
+    }
+    return { ok: true, mode, step: opts.step };
+}
+function validateHardFloorAndCommitBoundary(opts) {
+    const hardFloor = opts.hardFloor;
+    if (hardFloor !== undefined && !isHardFloorCategory(hardFloor)) {
+        return {
+            ok: false,
+            envelope: fail('code.should-pause', 'INVALID_HARD_FLOOR', `hard-floor must be one of: irreversible-external-side-effect | authentication-credential | multi-day-investment | commit-boundary-side-effect (got "${hardFloor}")`, { provided: hardFloor }, ['Omit --hard-floor or pass a valid category'])
+        };
+    }
+    // v2.15.0 slice 002 repair (QA blocker): validate the
+    // --commit-boundary-action flag at the CLI boundary. The
+    // service-layer `shouldPauseAtGate` accepts a boolean
+    // `commitBoundaryAction: true`; this flag tells the CLI to
+    // pass it through. An unknown action id is rejected here
+    // (not silently ignored) so typos fail loud.
+    const commitBoundaryActionId = opts.commitBoundaryAction;
+    if (commitBoundaryActionId !== undefined && !isCommitBoundaryAction(commitBoundaryActionId)) {
+        return {
+            ok: false,
+            envelope: fail('code.should-pause', 'INVALID_COMMIT_BOUNDARY_ACTION', `--commit-boundary-action must be one of: git-push | git-tag | npm-publish | npm-install-global | peaks-global-install (got "${commitBoundaryActionId}")`, { provided: commitBoundaryActionId }, ['Omit --commit-boundary-action or pass a valid action id'])
+        };
+    }
+    return { ok: true, hardFloor, commitBoundaryActionId };
+}
+/**
+ * Slice 002 (v2.15.0) AC-2: when the caller is asking about Step 1 AND the
+ * recorded presence is stale, the CLI overrides the gate decision to PAUSE.
+ * Returns `null` when the check does not apply (not a swallow — no catch, no
+ * error path, just the branch HEAD did not take).
+ */
+function resolveStalePresence(opts) {
+    if (opts.step === 'step-1-mode-select' && opts.ignoreStalePresence !== true) {
+        const projectRoot = opts.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+        return checkStalePresence({ projectRootOverride: projectRoot });
+    }
+    return null;
+}
+function runShouldPauseAction(io, opts, readActiveSid) {
+    try {
+        // v2.18.4 slice 002-fix-first-run-step-gates (Bug 2):
+        // --mode is optional. Default to 'full-auto' when omitted
+        // so step-1-mode-select can run without forcing the caller
+        // to know the mode up front. The gate's hard-pause on
+        // step-1-mode-select will still pause regardless.
+        const check = validateShouldPause(opts);
+        if (!check.ok) {
+            printResult(io, check.envelope, opts.json);
+            process.exitCode = 1;
+            return;
+        }
+        const stalePresence = resolveStalePresence(opts);
+        if (stalePresence !== null && stalePresence.stale) {
+            handleStalePresence({ io, opts, mode: check.validated.mode, step: check.validated.step, readActiveSid }, stalePresence);
+            return;
+        }
+        handleDecision({ io, opts, validated: check.validated, readActiveSid });
+    }
+    catch (err) {
+        printResult(io, fail('code.should-pause', 'SHOULD_PAUSE_FAILED', getErrorMessage(err), null, [
+            'Re-run with --json for envelope shape'
+        ]), opts.json);
+        process.exitCode = 1;
+    }
+}

package/dist/cli/commands/code-mode-gate-should-pause-envelope.d.ts

@@ -0,0 +1,59 @@
+import { shouldPauseAtGate, type CodeMode, type CommitBoundaryActionId, type GatedStepId, type HardFloorCategory } from '../../services/code/mode-gate.js';
+import type { checkStalePresence } from '../../services/skills/skill-presence-service.js';
+import { type ProgramIO } from '../cli-helpers.js';
+/** The mode-gate `should-pause` action's option bag (verbatim commander shape). */
+export type ShouldPauseOptions = {
+    step: string;
+    mode: string;
+    hardFloor?: string;
+    recommended?: string;
+    project?: string;
+    ignoreStalePresence?: boolean;
+    commitBoundaryAction?: string;
+    json?: boolean;
+};
+/** Reader for the active session id (module-private to `code-mode-gate-commands.ts`). */
+export type ReadActiveSid = (projectRoot: string) => string | null;
+/** The `checkStalePresence` return the caller narrowed to `.stale === true`. */
+export type StalePresence = ReturnType<typeof checkStalePresence>;
+/** The mode-gate decision this file renders. */
+export type ShouldPauseDecision = ReturnType<typeof shouldPauseAtGate>;
+/** The values the action's validation branch handed down to the envelope builders. */
+export type ShouldPauseValidated = {
+    mode: CodeMode;
+    step: GatedStepId;
+    hardFloor: HardFloorCategory | undefined;
+    commitBoundaryActionId: CommitBoundaryActionId | undefined;
+};
+type HandleStaleArgs = {
+    io: ProgramIO;
+    opts: ShouldPauseOptions;
+    mode: CodeMode;
+    step: GatedStepId;
+    readActiveSid: ReadActiveSid;
+};
+/**
+ * Build the envelope manually so we can attach the extra structured fields
+ * (stalePresence, logLine) and emit a dedicated observability event tagged
+ * with reason='stale-presence'.
+ */
+export declare function handleStalePresence(args: HandleStaleArgs, stalePresence: StalePresence): void;
+type HandleDecisionArgs = {
+    io: ProgramIO;
+    opts: ShouldPauseOptions;
+    validated: ShouldPauseValidated;
+    readActiveSid: ReadActiveSid;
+};
+/**
+ * Slice C of v2.11.1 — observability hook #4/7. Fire-and-forget per PRD Q4
+ * (full-auto must never fail-loud). projectRoot resolution mirrors
+ * observability-commands.ts (findProjectRoot → cwd fallback).
+ *
+ * v2.15.0 slice 002 repair (QA blocker): translate the CLI
+ * --commit-boundary-action flag into the service-layer boolean. The CLI accepts
+ * the action id (e.g. "git-push") for ergonomic machine consumption; the
+ * service layer only cares that *some* commit-boundary action triggered the
+ * override. The actual action id is echoed in the JSON envelope below.
+ */
+export declare function handleDecision(args: HandleDecisionArgs): void;
+export {};

package/dist/cli/commands/code-mode-gate-should-pause-envelope.js

@@ -0,0 +1,144 @@
+/**
+ * `peaks code should-pause` — the "print a decision" half of the mode-gate
+ * CLI seam.
+ *
+ * Extracted VERBATIM from `code-mode-gate-commands.ts` (job
+ * strict-remediation-abc, slice c1-eslint-family-sweep, leaf c4w1-cli-b).
+ * This module holds the two envelope builders — the stale-presence override
+ * branch and the normal-decision branch — plus the observability event emit
+ * each performs. The registration + validation lives in
+ * `code-mode-gate-should-pause-command.ts`.
+ *
+ * The envelope contents (reason / gateKind / logLine / stalePresence field /
+ * nextActions hints), the `emitObservabilityEvent` `detail` shape (mode +
+ * step + shouldPause + reason and the optional `hardFloorCategory` spread),
+ * the "only emit when the sid is non-empty" guard, and the two hint strings
+ * on the stale branch all came directly from HEAD. Nothing here swallows
+ * anything: the try/catch that answers SHOULD_PAUSE_FAILED stayed in
+ * `code-mode-gate-commands.ts`.
+ */
+import { ok } from 'peaks-loop-shared/result';
+import { formatAutoProceedLogLine, shouldPauseAtGate } from '../../services/code/mode-gate.js';
+import { findProjectRoot } from '../../services/config/config-safety.js';
+import { emitObservabilityEvent } from '../../services/observability/observability-service.js';
+import { printResult } from '../cli-helpers.js';
+/**
+ * Build the envelope manually so we can attach the extra structured fields
+ * (stalePresence, logLine) and emit a dedicated observability event tagged
+ * with reason='stale-presence'.
+ */
+export function handleStalePresence(args, stalePresence) {
+    const { io, opts, mode, step, readActiveSid } = args;
+    const sid = readActiveSid(opts.project ?? findProjectRoot(process.cwd()) ?? process.cwd()) ?? '';
+    if (sid.length > 0) {
+        emitStalePresenceEvent({ sid, opts, mode, step, stalePresence });
+    }
+    printStalePresenceEnvelope({ io, opts, mode, step, stalePresence });
+}
+function emitStalePresenceEvent(args) {
+    const { sid, opts, mode, step, stalePresence } = args;
+    emitObservabilityEvent({
+        schemaVersion: 1,
+        ts: new Date().toISOString(),
+        sessionId: sid,
+        category: 'mode-gate',
+        detail: {
+            mode: mode,
+            step,
+            shouldPause: true,
+            reason: 'stale-presence',
+            staleReason: stalePresence.reason,
+            recordedOuterSessionId: stalePresence.recordedOuterSessionId,
+            currentOuterSessionId: stalePresence.currentOuterSessionId
+        }
+    }, { projectRoot: opts.project ?? process.cwd() });
+}
+function printStalePresenceEnvelope(args) {
+    const { io, opts, mode, step, stalePresence } = args;
+    printResult(io, ok('code.should-pause', {
+        shouldPause: true,
+        reason: `stale-presence — re-ask Step 1 (${stalePresence.reason}; recorded outer session id does not match current)`,
+        gateKind: 'mode-selection-itself',
+        logLine: `auto-pause (${mode}, stale-presence:${stalePresence.reason}): ${step} → re-ask`,
+        stalePresence: {
+            stale: true,
+            reason: stalePresence.reason,
+            recordedOuterSessionId: stalePresence.recordedOuterSessionId,
+            currentOuterSessionId: stalePresence.currentOuterSessionId
+        }
+    }, [], [
+        `Recorded outer session id "${stalePresence.recordedOuterSessionId ?? '?'}" does not match current outer session id "${stalePresence.currentOuterSessionId ?? '?'}".`,
+        `peaks-code Step 1 must AskUserQuestion to confirm the mode for THIS session (slice 002 AC-2).`
+    ]), opts.json);
+}
+/**
+ * Slice C of v2.11.1 — observability hook #4/7. Fire-and-forget per PRD Q4
+ * (full-auto must never fail-loud). projectRoot resolution mirrors
+ * observability-commands.ts (findProjectRoot → cwd fallback).
+ *
+ * v2.15.0 slice 002 repair (QA blocker): translate the CLI
+ * --commit-boundary-action flag into the service-layer boolean. The CLI accepts
+ * the action id (e.g. "git-push") for ergonomic machine consumption; the
+ * service layer only cares that *some* commit-boundary action triggered the
+ * override. The actual action id is echoed in the JSON envelope below.
+ */
+export function handleDecision(args) {
+    const { io, opts, validated, readActiveSid } = args;
+    const { mode, step, hardFloor, commitBoundaryActionId } = validated;
+    const decision = shouldPauseAtGate({
+        mode: mode,
+        step,
+        hardFloorCategory: hardFloor,
+        commitBoundaryAction: commitBoundaryActionId !== undefined
+    });
+    const projectRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+    const sid = readActiveSid(projectRoot) ?? '';
+    if (sid.length > 0) {
+        emitModeGateDecision({ sid, projectRoot, mode, step, decision });
+    }
+    const logLine = formatAutoProceedLogLine({
+        mode: mode,
+        step,
+        recommendedOption: opts.recommended ?? 'recommended-option',
+        hardFloorCategory: hardFloor
+    });
+    printDecisionEnvelope({ io, opts, mode, decision, logLine, commitBoundaryActionId });
+}
+function emitModeGateDecision(args) {
+    const { sid, projectRoot, mode, step, decision } = args;
+    emitObservabilityEvent({
+        schemaVersion: 1,
+        ts: new Date().toISOString(),
+        sessionId: sid,
+        category: 'mode-gate',
+        detail: {
+            mode: mode,
+            step,
+            shouldPause: decision.shouldPause,
+            reason: decision.reason,
+            ...(decision.hardFloorCategory !== undefined
+                ? { hardFloorCategory: decision.hardFloorCategory }
+                : {})
+        }
+    }, { projectRoot });
+}
+/**
+ * v2.15.0 slice 002 repair: include the commit-boundary
+ * action id in the envelope (when provided) so the LLM-side
+ * caller can echo which boundary was checked. Null when no
+ * --commit-boundary-action flag was passed.
+ */
+function printDecisionEnvelope(args) {
+    const { io, opts, mode, decision, logLine, commitBoundaryActionId } = args;
+    printResult(io, ok('code.should-pause', {
+        ...decision,
+        logLine,
+        ...(commitBoundaryActionId !== undefined
+            ? { commitBoundaryAction: commitBoundaryActionId }
+            : {})
+    }, [], [
+        decision.shouldPause
+            ? `Mode ${mode} + step ${opts.step} → PAUSE for AskUserQuestion${commitBoundaryActionId !== undefined ? ` (commit-boundary: ${commitBoundaryActionId})` : ''}`
+            : `Mode ${mode} + step ${opts.step} → AUTO-PROCEED with recommended option`
+    ]), opts.json);
+}

package/dist/cli/commands/code-orchestrator-can-do.js

@@ -14,7 +14,7 @@
  */
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
 import { fail, ok } from 'peaks-loop-shared/result';
-import { evaluateOrchestratorCanDo, OrchestratorCanDoError, ORCHESTRATOR_PRECOMPACT_RATIO, ORCHESTRATOR_REDLINE_RATIO, } from '../../services/code/orchestrator-can-do.js';
+import { evaluateOrchestratorCanDo, OrchestratorCanDoError, ORCHESTRATOR_PRECOMPACT_RATIO, ORCHESTRATOR_REDLINE_RATIO } from '../../services/code/orchestrator-can-do.js';
 import { findProjectRoot } from '../../services/config/config-safety.js';
 export function registerCodeOrchestratorCanDoCommand(code, io) {
     addJsonOption(code
@@ -36,7 +36,7 @@ export function registerCodeOrchestratorCanDoCommand(code, io) {
                 sliceSpec: opts.sliceSpec,
                 projectRoot,
                 probeSubAgentAvailable: () => probeSubAgentAvailableWithBin(projectRoot, peaksBin),
-                probeContextRatio: () => probeContextRatioWithBin(projectRoot, peaksBin),
+                probeContextRatio: () => probeContextRatioWithBin(projectRoot, peaksBin)
             });
             printResult(io, ok('code.orchestrator-can-do', result, [...result.warnings], [...result.suggestions, ...summaryLines(result)]), opts.json);
             if (!result.canDoInSession)
@@ -45,13 +45,13 @@ export function registerCodeOrchestratorCanDoCommand(code, io) {
         catch (err) {
             if (err instanceof OrchestratorCanDoError) {
                 printResult(io, fail('code.orchestrator-can-do', err.code, err.message, null, [
-                    'Pass --slice-spec <text> describing what the slice should change',
+                    'Pass --slice-spec <text> describing what the slice should change'
                 ]), opts.json);
                 process.exitCode = 1;
                 return;
             }
             printResult(io, fail('code.orchestrator-can-do', 'PROBE_FAILED', getErrorMessage(err), null, [
-                'Verify --slice-spec is non-empty and --project is a valid path',
+                'Verify --slice-spec is non-empty and --project is a valid path'
             ]), opts.json);
             process.exitCode = 1;
         }

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

@@ -38,7 +38,13 @@ export function registerCodeReviewCommands(program, io) {
             // says so without spawning anything.
             const before = detectOcr18();
             if (before.state === 'ready') {
-                printResult(io, ok(command, { acquired: false, state: before.state, package: before.package, shell: null, shellNote: null }, [], []), options.json);
+                printResult(io, ok(command, {
+                    acquired: false,
+                    state: before.state,
+                    package: before.package,
+                    shell: null,
+                    shellNote: null
+                }, [], []), options.json);
                 return;
             }
             // `asJson` is threaded in so the installer cannot write its stdout into
@@ -58,10 +64,19 @@ export function registerCodeReviewCommands(program, io) {
                 process.exitCode = 1;
                 return;
             }
-            printResult(io, ok(command, { acquired: true, state: after.state, package: after.package, shell: outcome.shell.kind, shellNote: outcome.shell.note, durationMs: outcome.durationMs }, [...outcome.warnings]), options.json);
+            printResult(io, ok(command, {
+                acquired: true,
+                state: after.state,
+                package: after.package,
+                shell: outcome.shell.kind,
+                shellNote: outcome.shell.note,
+                durationMs: outcome.durationMs
+            }, [...outcome.warnings]), options.json);
         }
         catch (error) {
-            printResult(io, fail(command, 'OCR18_ACQUIRE_FAILED', getErrorMessage(error), { state: 'acquire-failed' }, [ACQUIRE_RETRY_ACTION]), options.json);
+            printResult(io, fail(command, 'OCR18_ACQUIRE_FAILED', getErrorMessage(error), { state: 'acquire-failed' }, [
+                ACQUIRE_RETRY_ACTION
+            ]), options.json);
             process.exitCode = 1;
         }
     });

package/dist/cli/commands/code-run-command.js

@@ -1,6 +1,6 @@
 import { resolveCanonicalProjectRoot } from '../../services/config/config-service.js';
 import { read24hState, write24hState } from '../../services/24h-mode/index.js';
-import { applyAutoEngagePresenceMode } from '../../services/24h-mode/auto-engage.js';
+import { applyAutoEngagePresenceMode, presenceModeAdvisory } from '../../services/24h-mode/auto-engage.js';
 import { getErrorMessage } from '../cli-helpers.js';
 function emit(io, payload, json) {
     io.stdout((json === true ? JSON.stringify(payload) : JSON.stringify(payload, null, 2)) + '\n');
@@ -25,24 +25,41 @@ export function registerCodeRunCommand(code, io) {
         .option('--json', 'emit machine-readable JSON')
         .action(async (changeId, options) => {
         if (options['24h'] !== true) {
-            emit(io, { ok: false, code: 'CODE_RUN_24H_REQUIRED', message: 'code run requires --24h for this integration surface' }, options.json);
+            emit(io, {
+                ok: false,
+                code: 'CODE_RUN_24H_REQUIRED',
+                message: 'code run requires --24h for this integration surface'
+            }, options.json);
             process.exitCode = 1;
             return;
         }
         const projectRoot = resolveCanonicalProjectRoot(options.project ?? process.cwd());
         const sid = await sessionId(options, projectRoot);
         if (!sid) {
-            emit(io, { ok: false, code: 'NO_ACTIVE_SESSION', message: 'no --session-id and no canonical binding' }, options.json);
+            emit(io, {
+                ok: false,
+                code: 'NO_ACTIVE_SESSION',
+                message: 'no --session-id and no canonical binding'
+            }, options.json);
             process.exitCode = 1;
             return;
         }
-        const autoEngage = options.tier === 'T3' || options.tier === 'T4' || options.trigger === 'T3' || options.trigger === 'T4';
+        const autoEngage = options.tier === 'T3' ||
+            options.tier === 'T4' ||
+            options.trigger === 'T3' ||
+            options.trigger === 'T4';
         try {
             const current = read24hState(projectRoot, sid);
             if (!autoEngage) {
                 emit(io, {
                     ok: true,
-                    data: { changeId: changeId ?? null, mode: '24H_REQUESTED', state: current.state, brainstorming: 'reference-only', sessionId: sid },
+                    data: {
+                        changeId: changeId ?? null,
+                        mode: '24H_REQUESTED',
+                        state: current.state,
+                        brainstorming: 'reference-only',
+                        sessionId: sid
+                    },
                     next: 'Use the brainstorming reference-only bridge, then let peaks-code continue the normal runbook.'
                 }, options.json);
                 return;
@@ -61,14 +78,34 @@ export function registerCodeRunCommand(code, io) {
             // lease so the mode gate / statusline / `peaks code mode status`
             // see the same autonomy level the 24h state machine is running.
             const presenceMode = applyAutoEngagePresenceMode({ projectRoot, sessionId: sid });
+            // Slice H3 (rid=h3-24h-threshold-not-wired): surface a failed
+            // stamp at the envelope level instead of leaving it unread in
+            // `data.presenceMode`.
+            const advisory = presenceModeAdvisory(presenceMode);
             emit(io, {
                 ok: true,
-                data: { changeId: changeId ?? null, mode: '24H_ACTIVE', state: nextState, autoEngaged: true, trigger: options.trigger ?? options.tier, sessionId: sid, path: next.path, presenceMode },
+                data: {
+                    changeId: changeId ?? null,
+                    mode: '24H_ACTIVE',
+                    state: nextState,
+                    autoEngaged: true,
+                    trigger: options.trigger ?? options.tier,
+                    sessionId: sid,
+                    path: next.path,
+                    presenceMode
+                },
+                warnings: [...advisory.warnings],
+                nextActions: [...advisory.nextActions],
                 next: 'Continue the existing 24H_ACTIVE flow; no brainstorming gate is required for T3/T4.'
             }, options.json);
         }
         catch (error) {
-            emit(io, { ok: false, code: 'CODE_RUN_24H_FAILED', message: getErrorMessage(error), sessionId: sid }, options.json);
+            emit(io, {
+                ok: false,
+                code: 'CODE_RUN_24H_FAILED',
+                message: getErrorMessage(error),
+                sessionId: sid
+            }, options.json);
             process.exitCode = 1;
         }
     });

package/dist/cli/commands/code-runtime-commands.d.ts

@@ -13,6 +13,23 @@ 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';
+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;
+};
 /**
  * Adapt `runAutoCompact`'s domain result to a `ResultEnvelope`.
  *