peaks-loop 4.1.2 → 4.1.4

package/dist/cli/commands/code-gate-step-08-command.js

@@ -0,0 +1,155 @@
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+import { evaluateStep08, STEP_08_BACKUP_REGEX } from '../../services/code/step-08-gate.js';
+import { buildContextAuditHint } from '../../services/context/context-audit-hint.js';
+import { resolveOuterSessionId } from '../../services/session/binding-status-service.js';
+import { readActiveSid } from './code-runtime-session.js';
+export function registerCodeGateStep08Command(code, io) {
+    // v3.1.2 Step 0.8 — Mechanical PreToolUse gate.
+    // Wire-installed by `peaks workspace init` (extends the existing hook
+    // installer). Exit code is the load-bearing contract:
+    //   exit 0 → allow (with structured stdout describing the decision)
+    //   exit 2 → block (stderr contains the BLOCKED: ... reason)
+    addJsonOption(code
+        .command('gate-step-08')
+        .description('v3.1.2: PreToolUse gate for Step 0.8 — allow when job-shape.json exists; ' +
+        'fail-closed backup regex when missing. Exit 0 = allow, exit 2 = block. ' +
+        'When the decision says isJob=true AND progress.json exists, the stdout ' +
+        'also carries `Next: slice #N+1 of M (<currentSlice>)` so the LLM cannot ' +
+        'wake up cold. When the context ratio is ≥ 0.70 the stdout gains ONE more ' +
+        'line naming the largest context consumer (audit cached ≥ 5 min; fail-soft).')
+        .requiredOption('--project <path>', 'target project root (the hook passes "." so resolveCanonicalProjectRoot promotes it to the git root)')
+        .option('--session-id <sid>', 'override session id (default: read from active presence)')
+        .option('--prompt <text>', 'explicit prompt text (default: read last-prompt.txt; stdin ignored)')).action((opts) => runGateStep08(opts, io));
+}
+function runGateStep08(opts, io) {
+    try {
+        const sessionId = opts.sessionId ?? readActiveSid(opts.project);
+        if (sessionId === null) {
+            // No session binding — treat as allow (single-rid mode). The
+            // LLM has not yet anchored; we have nothing to gate against.
+            printGateStep08NoSession(io, opts.json);
+            return;
+        }
+        const context = resolveGateStep08Context(opts, sessionId);
+        const verdict = context.result.verdict;
+        if (verdict.kind === 'allow-job') {
+            printGateStep08AllowJob(verdict, context, io, opts.json);
+            return;
+        }
+        if (verdict.kind === 'allow-single') {
+            printGateStep08AllowSingle(context, io, opts.json);
+            return;
+        }
+        if (verdict.kind === 'block-missing-decision') {
+            // Block: the prompt matched the backup regex, so the LLM is treated as
+            // having skipped `peaks code detect-job` on a Job-shaped request.
+            // Exit code 2 is the load-bearing signal for the PreToolUse hook.
+            printGateStep08Blocked(verdict, context, io, opts.json);
+            return;
+        }
+        if (verdict.kind === 'block-no-decision-with-ledger') {
+            printGateStep08BlockedWithLedger(verdict, context, io, opts.json);
+            return;
+        }
+        // allow-no-decision-recorded — no decision and no ledger. This is a
+        // normal non-Job session and the gate must let it through.
+        printGateStep08Undecided(verdict, context, io, opts.json);
+    }
+    catch (err) {
+        reportGateStep08Failure(io, err, opts.json);
+    }
+}
+function resolveGateStep08Context(opts, sessionId) {
+    // hint. Runs ONLY when the window is ≥ 0.70 full, caches the audit
+    // result for ≥ 5 min so the transcript is scanned at most once per
+    // TTL window, and is fail-soft (null → no extra line). It never
+    // changes the exit code and never blocks.
+    const hintLine = buildContextAuditHint({
+        projectRoot: opts.project,
+        sessionId,
+        outerSessionId: resolveOuterSessionId(opts.project, sessionId)
+    });
+    const hintActions = hintLine === null ? [] : [hintLine];
+    const evalInput = {
+        projectRoot: opts.project,
+        sessionId
+    };
+    if (opts.prompt !== undefined)
+        evalInput.prompt = opts.prompt;
+    const result = evaluateStep08(evalInput);
+    return { result, hintActions };
+}
+function printGateStep08NoSession(io, json) {
+    const envelope = ok('code.gate-step-08', {
+        allow: true,
+        mode: 'no-session',
+        decision: null,
+        nextSlice: null
+    }, [], ['No active session id; gate passes through (single-rid mode).']);
+    printResult(io, envelope, json);
+}
+function printGateStep08AllowJob(verdict, context, io, json) {
+    const result = context.result;
+    const envelope = ok('code.gate-step-08', {
+        allow: true,
+        mode: 'job',
+        decision: verdict.decision,
+        progress: verdict.progress,
+        nextSlice: result.nextSliceLine
+    }, [], [...(result.nextSliceLine !== null ? [result.nextSliceLine] : []), ...context.hintActions]);
+    printResult(io, envelope, json);
+}
+function printGateStep08AllowSingle(context, io, json) {
+    const envelope = ok('code.gate-step-08', {
+        allow: true,
+        mode: 'single',
+        decision: null,
+        nextSlice: null
+    }, [], ['job-shape.json says isJob=false; single-rid mode (gate allows).', ...context.hintActions]);
+    printResult(io, envelope, json);
+}
+function printGateStep08Blocked(verdict, context, io, json) {
+    const blockMessage = 'BLOCKED: prompt looks Job-shaped but peaks code detect-job has not been called. Run `peaks code detect-job --is-job true ...` to record your Job-shape verdict, then retry.';
+    const envelope = fail('code.gate-step-08', 'STEP_08_BLOCKED', blockMessage, {
+        promptSource: verdict.promptSource,
+        backupRegex: STEP_08_BACKUP_REGEX.toString()
+    }, [
+        'Run `peaks code detect-job --is-job true --rationale <text> --suggested-job-id <slug>` to record the Job-shape verdict.',
+        'Then re-run the Bash tool call.',
+        ...context.hintActions
+    ]);
+    io.stderr(`${blockMessage}\n`);
+    printResult(io, envelope, json);
+    process.exitCode = 2;
+}
+function printGateStep08BlockedWithLedger(verdict, context, io, json) {
+    const blockMessage = `BLOCKED: ${verdict.reason}`;
+    const envelope = fail('code.gate-step-08', 'STEP_08_BLOCKED_WITH_LEDGER', blockMessage, {
+        ledgerJobIds: verdict.ledgerJobIds,
+        backupRegex: STEP_08_BACKUP_REGEX.toString()
+    }, [
+        'Run `peaks code detect-job --is-job true --rationale <text> --suggested-job-id <slug>` (or `--is-job false`) to record the Job-shape verdict the Job ledger presumes.',
+        'Then re-run the Bash tool call.',
+        ...context.hintActions
+    ]);
+    io.stderr(`${blockMessage}\n`);
+    printResult(io, envelope, json);
+    process.exitCode = 2;
+}
+function printGateStep08Undecided(verdict, context, io, json) {
+    const envelope = ok('code.gate-step-08', {
+        allow: true,
+        mode: 'undecided-no-regex-hit',
+        decision: null,
+        nextSlice: null,
+        promptSource: verdict.promptSource
+    }, [], [verdict.reason, ...context.hintActions]);
+    printResult(io, envelope, json);
+}
+function reportGateStep08Failure(io, err, json) {
+    printResult(io, fail('code.gate-step-08', 'GATE_STEP_08_FAILED', getErrorMessage(err), null, [
+        'Verify the project path and try again'
+    ]), json);
+    process.exitCode = 1;
+}

package/dist/cli/commands/code-post-compact-detect-command.d.ts

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

package/dist/cli/commands/code-post-compact-detect-command.js

@@ -0,0 +1,50 @@
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+import { detectPostCompactResume, formatPostCompactResumeLogLine } from '../../services/code/post-compact-detector.js';
+import { readActiveSid } from './code-runtime-session.js';
+function printPostCompactNoActiveSession(io, opts) {
+    printResult(io, fail('code.post-compact-detect', 'NO_ACTIVE_SESSION', 'no active session id; pass --session-id or set presence via `peaks skill presence:set peaks-code`', null, ['Re-run with --session-id <sid>']), opts.json);
+    process.exitCode = 1;
+}
+const POST_COMPACT_DETECT_DESCRIPTION = 'v2.11.0 D7: detect whether the current invocation is a same-day post-compact resume. ' +
+    'Auto-resumes (no AskUserQuestion) when the most-recent checkpoint is from today, has a mode field, ' +
+    'and the active skill is peaks-code. Falls through to the normal Step 0.7 flow otherwise.';
+/** The catch branch, lifted verbatim out of the action body. */
+function reportPostCompactDetectFailure(io, err, json) {
+    printResult(io, fail('code.post-compact-detect', 'POST_COMPACT_DETECT_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 runPostCompactDetect(opts, io) {
+    try {
+        const sessionId = opts.sessionId ?? readActiveSid(opts.project);
+        if (sessionId === null) {
+            printPostCompactNoActiveSession(io, opts);
+            return;
+        }
+        const probe = await detectPostCompactResume({
+            sessionId,
+            projectRoot: opts.project,
+            activeSkill: opts.activeSkill
+        });
+        const logLine = formatPostCompactResumeLogLine(probe);
+        printResult(io, ok('code.post-compact-detect', { ...probe, logLine }, [...probe.warnings], [
+            probe.shouldAutoResume
+                ? `Post-compact match → auto-resume mode=${probe.mode ?? '?'} checkpoint=${probe.checkpointPath ?? '?'}`
+                : `No auto-resume: ${probe.reason}`
+        ]), opts.json);
+    }
+    catch (err) {
+        reportPostCompactDetectFailure(io, err, opts.json);
+    }
+}
+export function registerCodePostCompactDetectCommand(code, io) {
+    addJsonOption(code
+        .command('post-compact-detect')
+        .description(POST_COMPACT_DETECT_DESCRIPTION)
+        .requiredOption('--project <path>', 'target project root')
+        .option('--session-id <sid>', 'override session id (default: read from active presence)')
+        .option('--active-skill <skill>', 'override active skill (test seam; default: read from presence)')).action((opts) => runPostCompactDetect(opts, io));
+}

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

@@ -1,50 +1,16 @@
 /**
- * context-now / context-audit / gate-step-08 / emit-handoff.
+ * context-now / context-audit / post-compact-detect / auto-compact / gate-step-08 /
+ * emit-handoff.
  *
  * Owns: 6 sub-commands that read or mutate runtime state.
- * Owns the `readActiveSid` helper (only used by these runtime probes).
  *
- * (what fills the window, grouped by tool + short input key).
+ * This module is the registrar only. Each sub-command owns a file, and the pure
+ * helpers they share live beside them rather than inside one of them. Both
+ * re-exports below are part of the published surface of this module path, so the
+ * callers that reach for them keep their specifier.
  */
 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`.
- *
- * 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>;
+import type { ProgramIO } from '../cli-helpers.js';
+export { buildAutoCompactEnvelope } from './code-auto-compact-envelope.js';
+export { contextNowActionFor } from './code-context-now-mapping.js';
 export declare function registerCodeRuntimeCommands(code: Command, io: ProgramIO): void;