peaks-loop 4.1.2 → 4.1.3

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

@@ -0,0 +1,43 @@
+// The one table-to-vocabulary mapping `peaks code context-now` decides with: the
+// shared `CompactTrigger` kind translated to this command's `action`, and the labels
+// it prints, both read out of the mode in force.
+import { thresholdFor } from '../../services/code/auto-compact-modes.js';
+import { AUTO_COMPACT_SOFT_WARN_RATIO } from '../../services/context/auto-compact-types.js';
+import { evaluateCompactTrigger } from '../../services/code/auto-compact-orchestrator.js';
+/** The one dispatch verb the action and red-line tiers name. */
+const COMPACT_CMD = 'peaks code auto-compact';
+/**
+ * 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 function contextNowActionFor(ratio, mode) {
+    const kind = evaluateCompactTrigger(ratio, mode).kind;
+    if (kind === 'red-line')
+        return { action: 'red-line', next: COMPACT_CMD };
+    if (kind === 'pre-compact')
+        return { action: 'auto-compact-now', next: COMPACT_CMD };
+    return { action: kind === 'none' ? 'ok' : 'soft-warn', next: 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 function contextNowBandLabels(mode) {
+    const pct = (r) => `${(r * 100).toFixed(0)}`;
+    const pre = thresholdFor(mode, 'preCompact');
+    const red = thresholdFor(mode, 'redLine');
+    return {
+        softWarn: pct(AUTO_COMPACT_SOFT_WARN_RATIO),
+        preCompact: pct(pre),
+        redLine: pct(red),
+        preCompactRatio: pre.toFixed(2),
+        redLineRatio: red.toFixed(2)
+    };
+}

package/dist/cli/commands/code-emit-handoff-command.d.ts

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

package/dist/cli/commands/code-emit-handoff-command.js

@@ -0,0 +1,99 @@
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+import { evaluateEmitHandoff, JOB_NOT_INITIALIZED, JOB_REMAINING_BLOCKED } from '../../services/code/emit-handoff.js';
+import { readActiveSid } from './code-runtime-session.js';
+export function registerCodeEmitHandoffCommand(code, io) {
+    // v3.1.2 Step 11 / final handoff — Size-fear ban.
+    // Refuses to emit a final handoff while a Job has remaining slices.
+    addJsonOption(code
+        .command('emit-handoff')
+        .description('v3.1.2 Step 11 size-fear ban: under Job mode, refuse to emit a final ' +
+        'handoff while remaining > 0. Exit 0 = allow, exit 1 = block. Pass ' +
+        '--force-under-job to override (requires explicit user approval).')
+        .requiredOption('--project <path>', 'target project root')
+        .option('--session-id <sid>', 'override session id (default: read from active presence)')
+        .option('--job-id <jid>', 'override job id (default: read from job-shape.json decision.suggestedJobId)')
+        .option('--force-under-job', 'override the remaining>0 block (explicit user approval required)')).action((opts) => runEmitHandoff(opts, io));
+}
+function runEmitHandoff(opts, io) {
+    try {
+        const sessionId = opts.sessionId ?? readActiveSid(opts.project);
+        if (sessionId === null) {
+            printEmitHandoffNoSession(io, opts.json);
+            return;
+        }
+        const evalInput = {
+            projectRoot: opts.project,
+            sessionId
+        };
+        if (opts.jobId !== undefined)
+            evalInput.jobId = opts.jobId;
+        if (opts.forceUnderJob === true)
+            evalInput.forceUnderJob = true;
+        const verdict = evaluateEmitHandoff(evalInput);
+        reportEmitHandoffVerdict(verdict, io, opts.json);
+    }
+    catch (err) {
+        reportEmitHandoffFailure(io, err, opts.json);
+    }
+}
+function reportEmitHandoffVerdict(verdict, io, json) {
+    if (verdict.kind === 'allow-not-job') {
+        printEmitHandoffAllowNotJob(io, json);
+        return;
+    }
+    if (verdict.kind === 'allow-done') {
+        printEmitHandoffAllowDone(verdict, io, json);
+        return;
+    }
+    if (verdict.kind === 'allow-force-override') {
+        printEmitHandoffAllowForceOverride(verdict, io, json);
+        return;
+    }
+    if (verdict.kind === 'block-not-initialized') {
+        printEmitHandoffBlockNotInitialized(verdict, io, json);
+        return;
+    }
+    printEmitHandoffBlockRemaining(verdict, io, json);
+}
+function printEmitHandoffNoSession(io, json) {
+    const envelope = ok('code.emit-handoff', { allow: true, mode: 'no-session' }, [], ['No active session id; gate passes through (single-rid mode).']);
+    printResult(io, envelope, json);
+}
+function printEmitHandoffAllowNotJob(io, json) {
+    const envelope = ok('code.emit-handoff', { allow: true, mode: 'single' }, [], ['job-shape.json says isJob=false (or absent); normal handoff allowed.']);
+    printResult(io, envelope, json);
+}
+function printEmitHandoffAllowDone(verdict, io, json) {
+    const envelope = ok('code.emit-handoff', { allow: true, mode: 'job-done', remaining: verdict.remaining }, [], [`Job is complete (remaining=0); handoff allowed.`]);
+    printResult(io, envelope, json);
+}
+function printEmitHandoffAllowForceOverride(verdict, io, json) {
+    const envelope = ok('code.emit-handoff', { allow: true, mode: 'job-force-override', remaining: verdict.remaining }, [], [
+        `Job has ${verdict.remaining} remaining slices; --force-under-job override applied. Handoff allowed (explicit user approval).`
+    ]);
+    printResult(io, envelope, json);
+}
+function printEmitHandoffBlockNotInitialized(verdict, io, json) {
+    const envelope = fail('code.emit-handoff', JOB_NOT_INITIALIZED, `Job ${verdict.jobId} has no state.json; peaks job init was skipped.`, { jobId: verdict.jobId }, [`Run \`peaks job init --job-id ${verdict.jobId} --slice-list <...>\` before emitting handoff.`]);
+    printResult(io, envelope, json);
+    process.exitCode = 1;
+}
+function printEmitHandoffBlockRemaining(verdict, io, json) {
+    // block-remaining
+    const blockMessage = `BLOCKED: Job ${verdict.jobId} has ${verdict.remaining} remaining slices. Run \`peaks job status\`. Use --force-under-job only with explicit user approval.`;
+    const envelope = fail('code.emit-handoff', JOB_REMAINING_BLOCKED, blockMessage, { jobId: verdict.jobId, remaining: verdict.remaining }, [
+        `Run \`peaks job status --job-id ${verdict.jobId}\` to see remaining slices.`,
+        'Resume Step 0.81 (per-slice checkpoint loop) and continue until remaining === 0.',
+        'Use --force-under-job only with explicit user approval (size-fear ban override).'
+    ]);
+    io.stderr(`${blockMessage}\n`);
+    printResult(io, envelope, json);
+    process.exitCode = 1;
+}
+function reportEmitHandoffFailure(io, err, json) {
+    printResult(io, fail('code.emit-handoff', 'EMIT_HANDOFF_FAILED', getErrorMessage(err), null, [
+        'Verify the project path and try again'
+    ]), json);
+    process.exitCode = 1;
+}

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

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

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

@@ -0,0 +1,139 @@
+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;
+        }
+        // block-missing-decision
+        if (verdict.promptHit) {
+            // Block: backup regex hit. Exit code 2 is the load-bearing
+            // signal for the PreToolUse hook.
+            printGateStep08Blocked(verdict, context, io, opts.json);
+            return;
+        }
+        // No decision + no regex hit → allow.
+        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 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
+    }, [], [
+        'No job-shape.json AND no backup-regex match on prompt → allow (most prompts are not Job-shaped).',
+        ...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;