peaks-loop 4.1.2 → 4.1.4

package/dist/services/code/auto-compact-run-types.d.ts

@@ -0,0 +1,123 @@
+/**
+ * The orchestrator’s input and run-context types.
+ *
+ * Split out of `auto-compact-orchestrator.ts` (file-size cap campaign). The
+ * orchestrator re-exports every name declared here, so existing importers keep
+ * using `./auto-compact-orchestrator.js` unchanged.
+ */
+import type { AutoCompactMode } from './auto-compact-modes.js';
+import type { CompactTarget } from '../context/auto-compact-dispatcher.js';
+import type { ContextPercentProbe, InFlightBatchProbe } from '../context/auto-compact-types.js';
+import type { HarnessWindowSyncResult } from '../context/harness-window-config.js';
+import type { CompactLifecycleRecord, CompactLifecycleStage } from '../compact-statusline/compact-lifecycle-store.js';
+import type { evaluateAutoCompactDecision } from './auto-compact-decision.js';
+export interface AutoCompactInput {
+    /** Project root for context (default cwd). */
+    readonly projectRoot: string;
+    /**
+     * Caller-provided in-flight batch probe (default false). Slice
+     * 4.0.8 (D4d): production callers should pass a `probeInflightBatch`
+     * function (see below). The legacy `inFlightBatch` boolean
+     * remains as a TEST-ONLY seam — the CLI gates it behind
+     * `process.env.PEAKS_TEST_SEAM === '1'` so a production run
+     * never consults the boolean as truth.
+     */
+    readonly inFlightBatch?: InFlightBatchProbe | undefined;
+    /**
+     * Slice 4.0.8 (D4d): graph-only in-flight probe. When supplied,
+     * the orchestrator calls this function and uses the boolean
+     * result as the production `inFlightBatch` signal. The legacy
+     * boolean parameter is suppressed in production callers — the
+     * CLI's `--in-flight-batch` flag is gated behind
+     * `PEAKS_TEST_SEAM === '1'`. The pure decision function
+     * `evaluateAutoCompactDecision` retains the boolean signature
+     * for the test seam + the red-line override.
+     */
+    readonly probeInflightBatch?: (() => boolean) | undefined;
+    /**
+     * Force execute even when ratio < threshold (test seam). In
+     * production this is always `false` — peaks-loop drives compact
+     * autonomously at 0.85+ with zero human / zero LLM intervention.
+     */
+    readonly force?: boolean | undefined;
+    /**
+     * INERT — nothing reads this. It is threaded from the CLI's
+     * `--bypass-red-line` (a published flag, kept for backward compatibility;
+     * see the option's own note) down to `evaluateAutoCompactDecision`, where the
+     * red-line branch ignores it.
+     *
+     * Why nothing reads it any more: it used to skip a gate that refused to
+     * dispatch below 0.85. That gate was removed (slice
+     * compact a running session, so the refusal could not shorten the wait it
+     * was waiting for, and it deadlocked the runner at the worst moment. With the
+     * gate gone, the red line still ASKS the harness to compact (when it always
+     * did) and no longer needs a bypass. Kept as a field so the published
+     * signature does not change under callers that pass it.
+     */
+    readonly bypassRedLine?: boolean | undefined;
+    /** Current session id (default = resolve via session-id-service). */
+    readonly sessionId?: string | undefined;
+    /** Injectable env for IDE detection (test seam). */
+    readonly env?: NodeJS.ProcessEnv | undefined;
+    /** Injectable clock for mtime checks (test seam). */
+    readonly now?: Date | undefined;
+    /**
+     * the compact should target. Default `'main'` — the orchestrator
+     * (peaks-code body) runs in the main-session Claude Code window and
+     * wants to compress *its* context. Sub-agent shells pass
+     * `'sub-agent'` to preserve the legacy shell-spawn behaviour.
+     */
+    readonly target?: CompactTarget | undefined;
+    /**
+     * `'standard'` (v2.13.0 zero-pause contract, 0.85/0.95). `'partial'`
+     * fires earlier (0.70/0.85) for 24h long-run scenarios. CLI flag
+     * `--mode <mode>` overrides the 24h-mode auto-detection.
+     */
+    readonly mode?: AutoCompactMode | undefined;
+    /**
+     * every lifecycle stage this process actually proved. Telemetry
+     * only — it can neither change the threshold decision nor the
+     * dispatch outcome, and a throwing observer is swallowed.
+     */
+    readonly onLifecycleStage?: ((stage: CompactLifecycleStage, record: CompactLifecycleRecord) => void) | undefined;
+    /**
+     * Test-only injection seams for lifecycle failure paths. NEVER set in
+     * production — these exist so the unit suite can drive the `failed`
+     * transition and the store-outage branch without mocking the SUT.
+     * Each flag toggles a single, well-scoped throw at a documented point:
+     *   - `failPreparing`: throw inside the checkpoint/plan/recovery phase
+     *     (so the record rests at `failedAt: 'preparing'`)
+     *   - `failCompacting`: throw inside the IDE-dispatch phase
+     *     (so the record rests at `failedAt: 'compacting'`)
+     *   - `failLifecycleWrite`: make every lifecycle-store write throw
+     *     (so the compact envelope is proven independent of telemetry)
+     */
+    readonly testHooks?: AutoCompactTestHooks | undefined;
+}
+/**
+ * Test-only injection seams. The `boolean` shape (vs. an injected error)
+ * is deliberate: tests assert the *transition*, not the thrown value —
+ * the value would just be a brittle fingerprint. The real error path
+ * is still exercised by `summarizeLifecycleError`'s tests.
+ */
+export interface AutoCompactTestHooks {
+    readonly failPreparing?: boolean | undefined;
+    readonly failCompacting?: boolean | undefined;
+    readonly failLifecycleWrite?: boolean | undefined;
+}
+/** The decision shape `evaluateAutoCompactDecision` returns. */
+export type AutoCompactDecision = ReturnType<typeof evaluateAutoCompactDecision>;
+/**
+ * One probe's worth of resolved state, threaded through the whole run so each
+ * phase takes the same object rather than a widening parameter list.
+ */
+export type CompactRun = {
+    readonly input: AutoCompactInput;
+    readonly sessionId: string;
+    readonly mode: AutoCompactMode;
+    readonly probe: ContextPercentProbe;
+    readonly harnessWindow: HarnessWindowSyncResult | null;
+    readonly decision: AutoCompactDecision;
+    readonly isRedLine: boolean;
+    readonly now: Date;
+};

package/dist/services/code/auto-compact-run-types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/code/emit-handoff.d.ts

@@ -11,9 +11,16 @@
  *     skipped `peaks job init`)
  *   - isJob === true, state.json, remaining > 0,
  *     no --force-under-job                        → JOB_REMAINING_BLOCKED
- *   - isJob === true, state.json, remaining === 0 → ALLOW (Job done)
  *   - isJob === true, state.json, remaining > 0,
  *     --force-under-job                            → ALLOW (override path)
+ *   - isJob === true, state.json, remaining === 0,
+ *     no session sediment, no --force-no-sediment → JOB_COMPLETED_NO_SEDIMENT
+ *   - isJob === true, state.json, remaining === 0,
+ *     session sediment OR --force-no-sediment     → ALLOW (Job done)
+ *
+ * The sediment arm is the refusal point for Step 11: a completed Job whose
+ * session put nothing into `.peaks/memory/` is refused, and an unanswerable
+ * sediment question is refused too (fail closed).
  *
  * Karpathy §2 (Simplicity First): ~70 lines, no LLM call, no regex.
  * Pure read + arithmetic. The CLI wrapper in code-commands.ts
@@ -21,6 +28,15 @@
  */
 export declare const JOB_NOT_INITIALIZED: "JOB_NOT_INITIALIZED";
 export declare const JOB_REMAINING_BLOCKED: "JOB_REMAINING_BLOCKED";
+export declare const JOB_COMPLETED_NO_SEDIMENT: "JOB_COMPLETED_NO_SEDIMENT";
+/**
+ * What the memory index says about this session.
+ *
+ * `unknown` is a first-class answer, not an error code: it means the question
+ * could not be put to peaks' own store at all, and the handoff refuses on it
+ * rather than assuming the session sedimented nothing.
+ */
+export type SessionSedimentState = 'sedimented' | 'none' | 'unknown';
 export type EmitHandoffVerdict = {
     readonly kind: 'allow-not-job';
 } | {
@@ -38,6 +54,18 @@ export type EmitHandoffVerdict = {
     readonly code: typeof JOB_REMAINING_BLOCKED;
     readonly jobId: string;
     readonly remaining: number;
+} | {
+    readonly kind: 'block-no-sediment';
+    readonly code: typeof JOB_COMPLETED_NO_SEDIMENT;
+    readonly jobId: string;
+    /** `none` = the index was read and holds no entry for this session. */
+    readonly sedimentState: Exclude<SessionSedimentState, 'sedimented'>;
+} | {
+    readonly kind: 'allow-forced-no-sediment';
+    readonly remaining: number;
+    /** The reason the user approved a no-sediment outcome. Never blank. */
+    readonly reason: string;
+    readonly sedimentState: Exclude<SessionSedimentState, 'sedimented'>;
 };
 export interface EvaluateEmitHandoffInput {
     readonly projectRoot: string;
@@ -45,5 +73,11 @@ export interface EvaluateEmitHandoffInput {
     /** Suggested job id — read from job-shape.json when omitted. */
     readonly jobId?: string;
     readonly forceUnderJob?: boolean;
+    /**
+     * The reason the user approved a no-sediment outcome. Present and non-blank
+     * overrides the completed-Job no-sediment block; blank is treated as absent,
+     * so an override nobody justified does not open the gate.
+     */
+    readonly forceNoSedimentReason?: string;
 }
 export declare function evaluateEmitHandoff(input: EvaluateEmitHandoffInput): EmitHandoffVerdict;

package/dist/services/code/emit-handoff.js

@@ -11,9 +11,16 @@
  *     skipped `peaks job init`)
  *   - isJob === true, state.json, remaining > 0,
  *     no --force-under-job                        → JOB_REMAINING_BLOCKED
- *   - isJob === true, state.json, remaining === 0 → ALLOW (Job done)
  *   - isJob === true, state.json, remaining > 0,
  *     --force-under-job                            → ALLOW (override path)
+ *   - isJob === true, state.json, remaining === 0,
+ *     no session sediment, no --force-no-sediment → JOB_COMPLETED_NO_SEDIMENT
+ *   - isJob === true, state.json, remaining === 0,
+ *     session sediment OR --force-no-sediment     → ALLOW (Job done)
+ *
+ * The sediment arm is the refusal point for Step 11: a completed Job whose
+ * session put nothing into `.peaks/memory/` is refused, and an unanswerable
+ * sediment question is refused too (fail closed).
  *
  * Karpathy §2 (Simplicity First): ~70 lines, no LLM call, no regex.
  * Pure read + arithmetic. The CLI wrapper in code-commands.ts
@@ -21,9 +28,11 @@
  */
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { isExpectedFsMiss } from '../../shared/fs-utils.js';
 import { readJobShapeDecision, JobShapeDecisionError, JOB_SHAPE_NOT_DECIDED } from './job-shape-decision.js';
 export const JOB_NOT_INITIALIZED = 'JOB_NOT_INITIALIZED';
 export const JOB_REMAINING_BLOCKED = 'JOB_REMAINING_BLOCKED';
+export const JOB_COMPLETED_NO_SEDIMENT = 'JOB_COMPLETED_NO_SEDIMENT';
 function countRemaining(statePath) {
     let raw;
     try {
@@ -46,6 +55,119 @@ function countRemaining(statePath) {
 function statePath(projectRoot, sessionId, jobId) {
     return join(projectRoot, '.peaks', '_runtime', sessionId, 'job', jobId, 'state.json');
 }
+/**
+ * Which session a memory came from, as the memory index records it.
+ *
+ * The runtime directory is the link: `peaks memory extract` stamps each
+ * extracted memory with the `sourceArtifact` it read, and every artifact a
+ * session can sediment from lives under its own runtime directory, so an
+ * index entry naming this session's runtime directory IS this session's
+ * sediment. Nothing here reads a modification time.
+ */
+function sourceArtifactNamesSession(sourceArtifact, sessionId) {
+    if (typeof sourceArtifact !== 'string')
+        return false;
+    return sourceArtifact.replaceAll('\\', '/').includes(`_runtime/${sessionId}/`);
+}
+function isPlainRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * One `hot` / `warm` bucket flattened to its entries, or null when the bucket
+ * is not the shape this reader knows. A bucket whose kind maps to something
+ * other than a list is a shape deviation, and a shape deviation has to read as
+ * "cannot tell" rather than as "no entries": the two answers disagree about
+ * whether the handoff may proceed.
+ */
+function bucketEntries(bucket) {
+    if (!isPlainRecord(bucket))
+        return null;
+    const entries = [];
+    for (const list of Object.values(bucket)) {
+        if (!Array.isArray(list))
+            return null;
+        for (const entry of list)
+            entries.push(entry);
+    }
+    return entries;
+}
+/** Every index entry, or null when the file is not the shape this reader knows. */
+function readIndexEntries(parsed) {
+    if (!isPlainRecord(parsed))
+        return null;
+    const hot = bucketEntries(parsed.hot);
+    const warm = bucketEntries(parsed.warm);
+    if (hot === null || warm === null)
+        return null;
+    return [...hot, ...warm];
+}
+/**
+ * Did this session sediment anything into the project memory store?
+ *
+ * The basis is peaks' own memory index, which both `peaks memory extract
+ * --apply` paths rebuild after writing, so it is a peaks-owned projection of
+ * the store rather than a guess about timestamps.
+ */
+function readSessionSedimentState(projectRoot, sessionId) {
+    const indexPath = join(projectRoot, '.peaks', 'memory', 'index.json');
+    if (!existsSync(indexPath))
+        return 'unknown';
+    let raw;
+    try {
+        raw = readFileSync(indexPath, 'utf8');
+    }
+    catch (err) {
+        if (!isExpectedFsMiss(err))
+            throw err;
+        return 'unknown';
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return 'unknown';
+    }
+    const entries = readIndexEntries(parsed);
+    if (entries === null)
+        return 'unknown';
+    for (const entry of entries) {
+        if (!isPlainRecord(entry))
+            return 'unknown';
+        if (sourceArtifactNamesSession(entry.sourceArtifact, sessionId))
+            return 'sedimented';
+    }
+    return 'none';
+}
+/** A blank override reason is the same as no override at all. */
+function approvedNoSedimentReason(reason) {
+    if (reason === undefined)
+        return null;
+    const trimmed = reason.trim();
+    return trimmed.length === 0 ? null : trimmed;
+}
+/**
+ * The verdict for a Job with no slices left. This is the moment Step 11 is
+ * owed: the workflow is about to be declared complete, so the session must
+ * have sedimented something, or have been granted an explicit no-sediment
+ * outcome. `unknown` refuses too — cannot tell is not a pass.
+ */
+function decideCompletedJob(input, jobId) {
+    const sedimentState = readSessionSedimentState(input.projectRoot, input.sessionId);
+    if (sedimentState === 'sedimented') {
+        return { kind: 'allow-done', remaining: 0 };
+    }
+    const approvedReason = approvedNoSedimentReason(input.forceNoSedimentReason);
+    if (approvedReason !== null) {
+        return {
+            kind: 'allow-forced-no-sediment',
+            remaining: 0,
+            reason: approvedReason,
+            sedimentState
+        };
+    }
+    return { kind: 'block-no-sediment', code: JOB_COMPLETED_NO_SEDIMENT, jobId, sedimentState };
+}
 export function evaluateEmitHandoff(input) {
     let decision = null;
     try {
@@ -69,11 +191,10 @@ export function evaluateEmitHandoff(input) {
     if (!Number.isFinite(remaining)) {
         return { kind: 'block-not-initialized', code: JOB_NOT_INITIALIZED, jobId };
     }
-    if (remaining === 0) {
-        return { kind: 'allow-done', remaining };
-    }
-    if (input.forceUnderJob === true) {
-        return { kind: 'allow-force-override', remaining };
+    if (remaining > 0) {
+        return input.forceUnderJob === true
+            ? { kind: 'allow-force-override', remaining }
+            : { kind: 'block-remaining', code: JOB_REMAINING_BLOCKED, jobId, remaining };
     }
-    return { kind: 'block-remaining', code: JOB_REMAINING_BLOCKED, jobId, remaining };
+    return decideCompletedJob(input, jobId);
 }

package/dist/services/code/step-08-gate.d.ts

@@ -19,19 +19,24 @@
  *        — so the LLM sees its resume context BEFORE any Bash call lands.
  *   2. `job-shape.json` exists with `decision.isJob === false`.
  *      → allow, print `{ ok, allow, mode: 'single' }`.
- *   3. `job-shape.json` is MISSING — fail-closed guard. The LLM is the
- *      source of truth, but if it never recorded a decision we run a
- *      lightweight backup regex against the user's prompt:
- *        /until|全部|until all done|disavow cost|不用考虑费用|all of them/i
- *      match → block (exit 2) with the BLOCKED: stderr message.
- *      no match → allow (exit 0) — most prompts are not Job-shaped.
+ *   3. `job-shape.json` is MISSING. Every answer here is about the decision
+ *      that was never recorded, not about the prompt:
+ *        a. the backup regex matches the prompt → block (exit 2) with the
+ *           BLOCKED: stderr message.
+ *        b. no regex match, but the session owns a Job ledger
+ *           (`job/<jid>/state.json` exists) → block (exit 2). `peaks job
+ *           init` ran and `peaks code detect-job` did not.
+ *        c. no regex match and no ledger → allow (exit 0), reporting that NO
+ *           decision was recorded. The absence of a judgement is stated as an
+ *           absence, not as a judgement that the prompt is not Job-shaped.
+ *      The gate never blocks on the ABSENCE of a decision alone: it runs on
+ *      every Bash call in every session, so a normal non-Job session must
+ *      keep passing through case (c).
  *
- * Karpathy §2 (Simplicity First): ~120 lines, no LLM call inside. The
- * regex is the FIRST time peaks-loop accepts hardcoded keywords —
- * explicitly scoped as a *fail-closed backup* (case 3), NOT a primary
- * judgement. The LLM still owns the semantic call via
- * `peaks code detect-job`. The regex is a safety net for the v3.1.1
- * incident class (LLM under load never records the decision at all).
+ * Karpathy §2 (Simplicity First): no LLM call inside. The regex is the FIRST
+ * time peaks-loop accepts hardcoded keywords — explicitly scoped as a
+ * *fail-closed backup* (case 3), NOT a primary judgement. The LLM still owns
+ * the semantic call via `peaks code detect-job`.
  */
 export declare const STEP_08_GATE_FILE_NAME: "job-shape.json";
 export declare const STEP_08_PROGRESS_FILE_NAME: "progress.json";
@@ -56,6 +61,7 @@ export interface Step08Progress {
     readonly lastCommitSha: string | null;
     readonly updatedAt: string;
 }
+export type Step08PromptSource = 'flag' | 'last-prompt-file' | 'stdin-empty';
 export type Step08Verdict = {
     readonly kind: 'allow-job';
     readonly decision: import('./job-shape-decision.js').JobShapeDecision;
@@ -64,8 +70,15 @@ export type Step08Verdict = {
     readonly kind: 'allow-single';
 } | {
     readonly kind: 'block-missing-decision';
-    readonly promptHit: boolean;
-    readonly promptSource: 'flag' | 'last-prompt-file' | 'stdin-empty';
+    readonly promptSource: Step08PromptSource;
+} | {
+    readonly kind: 'allow-no-decision-recorded';
+    readonly promptSource: Step08PromptSource;
+    readonly reason: string;
+} | {
+    readonly kind: 'block-no-decision-with-ledger';
+    readonly ledgerJobIds: readonly string[];
+    readonly reason: string;
 };
 export declare function runtimeSessionDir(projectRoot: string, sessionId: string): string;
 export interface EvaluateStep08Input {
@@ -83,9 +96,5 @@ export interface EvaluateStep08Result {
     readonly verdict: Step08Verdict;
     readonly nextSliceLine: string | null;
 }
-/**
- * Pure evaluator — does NOT write, does NOT exit. CLI wrapper in
- * `src/cli/commands/code-commands.ts` reads `allow` to set the process
- * exit code (0 allow / 2 block) and prints the structured envelope.
- */
+/** Pure evaluator — does NOT write, does NOT exit. The CLI wrapper reads `allow`. */
 export declare function evaluateStep08(input: EvaluateStep08Input): EvaluateStep08Result;

package/dist/services/code/step-08-gate.js

@@ -19,21 +19,26 @@
  *        — so the LLM sees its resume context BEFORE any Bash call lands.
  *   2. `job-shape.json` exists with `decision.isJob === false`.
  *      → allow, print `{ ok, allow, mode: 'single' }`.
- *   3. `job-shape.json` is MISSING — fail-closed guard. The LLM is the
- *      source of truth, but if it never recorded a decision we run a
- *      lightweight backup regex against the user's prompt:
- *        /until|全部|until all done|disavow cost|不用考虑费用|all of them/i
- *      match → block (exit 2) with the BLOCKED: stderr message.
- *      no match → allow (exit 0) — most prompts are not Job-shaped.
+ *   3. `job-shape.json` is MISSING. Every answer here is about the decision
+ *      that was never recorded, not about the prompt:
+ *        a. the backup regex matches the prompt → block (exit 2) with the
+ *           BLOCKED: stderr message.
+ *        b. no regex match, but the session owns a Job ledger
+ *           (`job/<jid>/state.json` exists) → block (exit 2). `peaks job
+ *           init` ran and `peaks code detect-job` did not.
+ *        c. no regex match and no ledger → allow (exit 0), reporting that NO
+ *           decision was recorded. The absence of a judgement is stated as an
+ *           absence, not as a judgement that the prompt is not Job-shaped.
+ *      The gate never blocks on the ABSENCE of a decision alone: it runs on
+ *      every Bash call in every session, so a normal non-Job session must
+ *      keep passing through case (c).
  *
- * Karpathy §2 (Simplicity First): ~120 lines, no LLM call inside. The
- * regex is the FIRST time peaks-loop accepts hardcoded keywords —
- * explicitly scoped as a *fail-closed backup* (case 3), NOT a primary
- * judgement. The LLM still owns the semantic call via
- * `peaks code detect-job`. The regex is a safety net for the v3.1.1
- * incident class (LLM under load never records the decision at all).
+ * Karpathy §2 (Simplicity First): no LLM call inside. The regex is the FIRST
+ * time peaks-loop accepts hardcoded keywords — explicitly scoped as a
+ * *fail-closed backup* (case 3), NOT a primary judgement. The LLM still owns
+ * the semantic call via `peaks code detect-job`.
  */
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { readJobShapeDecision, JobShapeDecisionError, JOB_SHAPE_NOT_DECIDED } from './job-shape-decision.js';
 import { describeNextSlice } from '../job/job-progress-store.js';
@@ -122,10 +127,41 @@ function readPromptFromLastPromptFile(projectRoot, sessionId) {
     }
 }
 /**
- * Pure evaluator — does NOT write, does NOT exit. CLI wrapper in
- * `src/cli/commands/code-commands.ts` reads `allow` to set the process
- * exit code (0 allow / 2 block) and prints the structured envelope.
+ * Job ids this session owns a ledger for, sorted.
+ *
+ * A ledger is `job/<jid>/state.json`, which only `peaks job init` writes, and
+ * `job-shape.json` is written by `peaks code detect-job` and by nothing else —
+ * so a ledger with no decision is the decision step having been skipped.
  */
+function ledgerJobIds(projectRoot, sessionId) {
+    const jobDir = join(runtimeSessionDir(projectRoot, sessionId), 'job');
+    if (!existsSync(jobDir))
+        return [];
+    let names;
+    try {
+        names = readdirSync(jobDir);
+    }
+    catch (err) {
+        if (!isExpectedFsMiss(err))
+            throw err;
+        return [];
+    }
+    return names
+        .filter((name) => existsSync(join(jobDir, name, 'state.json')))
+        .sort((left, right) => left.localeCompare(right));
+}
+/**
+ * The reason a Job ledger with no decision is refused — it names both commands,
+ * so the reader sees WHICH step was skipped.
+ */
+function noDecisionWithLedgerReason(ledger) {
+    const paths = ledger.map((jid) => `job/${jid}/state.json`).join(', ');
+    return (`No Job-shape decision was recorded for this session, but it owns a Job ledger (${paths}). ` +
+        'That means `peaks job init` ran and `peaks code detect-job` did not, so every ' +
+        'Job-mode step this gate keys on was skipped. Record the verdict with ' +
+        '`peaks code detect-job --is-job true|false ...`, then retry.');
+}
+/** Pure evaluator — does NOT write, does NOT exit. The CLI wrapper reads `allow`. */
 export function evaluateStep08(input) {
     try {
         const record = readJobShapeDecision(input.projectRoot, input.sessionId);
@@ -142,26 +178,47 @@ export function evaluateStep08(input) {
     }
     catch (err) {
         if (err instanceof JobShapeDecisionError && err.code === JOB_SHAPE_NOT_DECIDED) {
-            const promptText = input.prompt ?? readPromptFromLastPromptFile(input.projectRoot, input.sessionId);
-            const hit = promptText.length > 0 && STEP_08_BACKUP_REGEX.test(promptText);
-            const source = input.prompt !== undefined
-                ? 'flag'
-                : promptText.length > 0
-                    ? 'last-prompt-file'
-                    : 'stdin-empty';
-            if (hit) {
-                return {
-                    allow: false,
-                    verdict: { kind: 'block-missing-decision', promptHit: true, promptSource: source },
-                    nextSliceLine: null
-                };
-            }
-            return {
-                allow: true,
-                verdict: { kind: 'block-missing-decision', promptHit: false, promptSource: source },
-                nextSliceLine: null
-            };
+            return decideWithoutJobShapeDecision(input);
         }
         throw err;
     }
 }
+/** `job-shape.json` is missing — see the module header for the three answers. */
+function decideWithoutJobShapeDecision(input) {
+    const promptText = input.prompt ?? readPromptFromLastPromptFile(input.projectRoot, input.sessionId);
+    const promptSource = input.prompt !== undefined
+        ? 'flag'
+        : promptText.length > 0
+            ? 'last-prompt-file'
+            : 'stdin-empty';
+    if (promptText.length > 0 && STEP_08_BACKUP_REGEX.test(promptText)) {
+        return {
+            allow: false,
+            verdict: { kind: 'block-missing-decision', promptSource },
+            nextSliceLine: null
+        };
+    }
+    const ledger = ledgerJobIds(input.projectRoot, input.sessionId);
+    if (ledger.length > 0) {
+        return {
+            allow: false,
+            verdict: {
+                kind: 'block-no-decision-with-ledger',
+                ledgerJobIds: ledger,
+                reason: noDecisionWithLedgerReason(ledger)
+            },
+            nextSliceLine: null
+        };
+    }
+    return {
+        allow: true,
+        verdict: {
+            kind: 'allow-no-decision-recorded',
+            promptSource,
+            reason: 'No Job-shape decision was recorded for this session and no Job ledger exists, ' +
+                'so this gate has no Job-shape judgement to report. It allows, and names the ' +
+                'absence of the decision rather than claiming the prompt is not Job-shaped.'
+        },
+        nextSliceLine: null
+    };
+}

package/dist/services/config/config-coercion.d.ts

@@ -0,0 +1,7 @@
+import type { ModelProviderConfig, PeaksConfig, ProviderModelConfig, TokenConfig, WorkspaceConfig } from './config-types.js';
+export declare function toWorkspaceConfigs(value: unknown): WorkspaceConfig[];
+export declare function toProviderModelConfig(value: unknown): ProviderModelConfig;
+export declare function toTokenConfig(value: unknown): TokenConfig;
+export declare function toModelProviderConfig(value: unknown): ModelProviderConfig;
+export declare function inferHumanLanguage(value: string): string;
+export declare function toPeaksConfig(value: unknown): Partial<PeaksConfig>;