peaks-loop 4.0.54 → 4.1.1

package/dist/services/code/auto-compact-lifecycle.js

@@ -107,7 +107,12 @@ export function readOpenDispatchRun(input) {
     const record = read.record;
     if (record.stage !== 'armed' && record.stage !== 'compacting')
         return { kind: 'none' };
-    return { kind: 'open', runId: record.runId, stage: record.stage, triggerRatio: record.triggerRatio };
+    return {
+        kind: 'open',
+        runId: record.runId,
+        stage: record.stage,
+        triggerRatio: record.triggerRatio
+    };
 }
 /**
  * Slice 2026-08-01-compact-lifecycle (Task 5): the local transition
@@ -211,7 +216,11 @@ export function summarizeLifecycleError(error) {
         raw = 'unknown error';
     const firstLine = raw.split('\n')[0] ?? '';
     const collapsed = firstLine.replace(/\s+/g, ' ').trim();
-    return collapsed.length === 0 ? 'unknown error' : (collapsed.length > COLLAPSED_ERROR_MAX_CHARS ? collapsed.slice(0, COLLAPSED_ERROR_MAX_CHARS) : collapsed);
+    return collapsed.length === 0
+        ? 'unknown error'
+        : collapsed.length > COLLAPSED_ERROR_MAX_CHARS
+            ? collapsed.slice(0, COLLAPSED_ERROR_MAX_CHARS)
+            : collapsed;
 }
 /**
  * Slice 2026-08-01-compact-lifecycle (Task 5, Step 4): close out an
@@ -278,45 +287,57 @@ export function settleOpenLifecycleRun(input) {
     // landed, and this is the only open run to attribute it to.
     if (prior.stage !== 'compacting' && prior.stage !== 'armed')
         return null;
-    const emit = (stage, withAfterRatio) => {
-        const record = {
-            schemaVersion: 1,
-            runId: prior.runId,
-            stage,
-            updatedAt: new Date().toISOString(),
-            triggerRatio: prior.triggerRatio,
-            redLine: prior.redLine,
-            ...(withAfterRatio ? { afterRatio: input.measuredRatio } : {})
-        };
-        try {
-            if (input.failLifecycleWrite)
-                throw new Error('lifecycle store unavailable');
-            writeCompactLifecycle({
-                projectRoot: input.projectRoot,
-                sessionId: input.sessionId,
-                record
-            });
-        }
-        catch {
-            // Best-effort telemetry, as everywhere in this file — but the failure is
-            // REPORTED to the caller as `lifecycleWritten: false` rather than folded
-            // into a record that reads as settled.
-            return false;
-        }
-        try {
-            input.onLifecycleStage?.(stage, record);
-        }
-        catch {
-            // Observer failures are not ours to propagate.
-        }
-        return true;
-    };
     // `verifying` = we hold a measurement and are checking it.
-    emit('verifying', false);
+    emitLifecycleStage(prior, input, 'verifying', false);
     // `completed` = the measurement confirms the drop; publish it. This write
     // is the one that closes the run, so it is the one that is reported.
-    const lifecycleWritten = emit('completed', true);
-    return { runId: prior.runId, triggerRatio: prior.triggerRatio, afterRatio: input.measuredRatio, lifecycleWritten };
+    const lifecycleWritten = emitLifecycleStage(prior, input, 'completed', true);
+    return {
+        runId: prior.runId,
+        triggerRatio: prior.triggerRatio,
+        afterRatio: input.measuredRatio,
+        lifecycleWritten
+    };
+}
+/**
+ * Publish one lifecycle stage for an open run (the `emit` closure of
+ * `settleOpenLifecycleRun`, moved verbatim to a module-level function to
+ * clear that function's `max-lines-per-function` arm; behavior unchanged).
+ * Returns `false` when the store write failed, `true` when the record was
+ * written (observer failures are not propagated — see the two catches).
+ */
+function emitLifecycleStage(prior, input, stage, withAfterRatio) {
+    const record = {
+        schemaVersion: 1,
+        runId: prior.runId,
+        stage,
+        updatedAt: new Date().toISOString(),
+        triggerRatio: prior.triggerRatio,
+        redLine: prior.redLine,
+        ...(withAfterRatio ? { afterRatio: input.measuredRatio } : {})
+    };
+    try {
+        if (input.failLifecycleWrite)
+            throw new Error('lifecycle store unavailable');
+        writeCompactLifecycle({
+            projectRoot: input.projectRoot,
+            sessionId: input.sessionId,
+            record
+        });
+    }
+    catch {
+        // Best-effort telemetry, as everywhere in this file — but the failure is
+        // REPORTED to the caller as `lifecycleWritten: false` rather than folded
+        // into a record that reads as settled.
+        return false;
+    }
+    try {
+        input.onLifecycleStage?.(stage, record);
+    }
+    catch {
+        // Observer failures are not ours to propagate.
+    }
+    return true;
 }
 /**
  * rid `2026-09-13-compact-event-settle`: close out an open compact run because
@@ -387,7 +408,9 @@ export function settleOpenLifecycleRunOnCompactEvent(input) {
     const prior = openRead.record;
     if (prior.stage !== 'compacting' && prior.stage !== 'armed')
         return null;
-    const afterRatio = input.measuredRatio !== null && input.measuredRatio < prior.triggerRatio ? input.measuredRatio : null;
+    const afterRatio = input.measuredRatio !== null && input.measuredRatio < prior.triggerRatio
+        ? input.measuredRatio
+        : null;
     const record = {
         schemaVersion: 1,
         runId: prior.runId,

package/dist/services/code/auto-compact-modes.js

@@ -19,8 +19,8 @@
  * decision-emitted, no separate compaction pathway.
  */
 export const AUTO_COMPACT_THRESHOLDS = {
-    standard: { autoFire: 0.80, preCompact: 0.85, redLine: 0.95 },
-    partial: { autoFire: 0.65, preCompact: 0.70, redLine: 0.85 }
+    standard: { autoFire: 0.8, preCompact: 0.85, redLine: 0.95 },
+    partial: { autoFire: 0.65, preCompact: 0.7, redLine: 0.85 }
 };
 export function thresholdFor(mode, kind) {
     return AUTO_COMPACT_THRESHOLDS[mode][kind];

package/dist/services/code/auto-compact-orchestrator.js

@@ -133,9 +133,7 @@ export function evaluateAutoCompactDecision(input) {
     // into a single `InFlightBatchProbe` shape. The probe reads
     // `hasInFlightBatch`; the boolean reads truthiness.
     const rawProbe = input.inFlightBatch ?? input.inflightBatch;
-    const probe = typeof rawProbe === 'boolean'
-        ? { hasInFlightBatch: rawProbe }
-        : rawProbe;
+    const probe = typeof rawProbe === 'boolean' ? { hasInFlightBatch: rawProbe } : rawProbe;
     if (trigger.kind === 'none') {
         return { shouldCompact: false, reason: 'below-threshold', trigger, action: 'ok' };
     }
@@ -466,7 +464,8 @@ export async function runAutoCompact(input) {
             // the harness's pinned window disagreeing. That is the moment the ratio
             // stops describing the harness's trigger, so staying silent is exactly
             // the failure 要告知 exists to prevent.
-            harnessWindow !== null && harnessWindow !== undefined &&
+            harnessWindow !== null &&
+                harnessWindow !== undefined &&
                 (harnessWindow.action === 'written' || harnessWindowSyncWarning(harnessWindow) !== null)
                 ? ` ${describeHarnessWindowSync(harnessWindow)}`
                 : ''}`,
@@ -733,15 +732,19 @@ export async function runAutoCompact(input) {
                 // T4 calibration: the exact denominator this dispatch divided by, so
                 // `beforeRatio * windowTokens` is the token point we asked for.
                 windowTokens: probe.capacityTokens ?? null,
-                windowSource: probe.capacitySource ?? null,
-            },
+                windowSource: probe.capacitySource ?? null
+            }
         });
     }
-    catch { /* best-effort; do not fail the compact return */ }
+    catch {
+        /* best-effort; do not fail the compact return */
+    }
     return {
         ok: dispatch.ok,
         code: dispatch.ok
-            ? (isRedLine ? 'AUTO_COMPACT_RED_LINE' : 'AUTO_COMPACT_DISPATCHED')
+            ? isRedLine
+                ? 'AUTO_COMPACT_RED_LINE'
+                : 'AUTO_COMPACT_DISPATCHED'
             : 'AUTO_COMPACT_DISPATCH_FAILED',
         message: dispatch.ok
             ? isRedLine
@@ -780,7 +783,9 @@ function appendObservedCompactEvent(input) {
     try {
         appendCompactHistoryEvent(input);
     }
-    catch { /* best-effort; the probe result is already settled */ }
+    catch {
+        /* best-effort; the probe result is already settled */
+    }
 }
 // Keep dirname import live for symmetry with sibling services that
 // use it for path joins; tree-shaking removes it in builds.

package/dist/services/code/batch-heartbeat-poller.d.ts

@@ -48,4 +48,14 @@ export declare class BatchHeartbeatPoller {
     stop(): void;
     /** Force a tick (testing seam + low-level access for explicit invocation). */
     tick(): void;
+    /**
+     * First-sight `stale` notices for the current record set (moved verbatim
+     * out of `tick` to clear its `max-lines-per-function` arm).
+     */
+    private emitStaleNotices;
+    /**
+     * The `done` / stop decision for the current record set (moved verbatim
+     * out of `tick` to clear its `max-lines-per-function` arm).
+     */
+    private finishIfAllTerminal;
 }

package/dist/services/code/batch-heartbeat-poller.js

@@ -80,6 +80,14 @@ export class BatchHeartbeatPoller {
         const views = recs.map((r) => viewSubAgent(r, now));
         const line = renderStatusLine(this.options.prefix, recs, now);
         this.handlers.onStatus?.({ kind: 'status', line, summary, views });
+        this.emitStaleNotices(recs, now);
+        this.finishIfAllTerminal(recs, summary);
+    }
+    /**
+     * First-sight `stale` notices for the current record set (moved verbatim
+     * out of `tick` to clear its `max-lines-per-function` arm).
+     */
+    emitStaleNotices(recs, now) {
         const staleThresholdSec = Math.floor((this.options.staleThresholdMs ?? DEFAULT_STALE_THRESHOLD_MS) / 1000);
         for (const rec of recs) {
             const v = viewSubAgent(rec, now);
@@ -97,7 +105,15 @@ export class BatchHeartbeatPoller {
                 }
             }
         }
-        if (summary.total > 0 && summary.done === summary.total && this.prevSummaryDone !== summary.done) {
+    }
+    /**
+     * The `done` / stop decision for the current record set (moved verbatim
+     * out of `tick` to clear its `max-lines-per-function` arm).
+     */
+    finishIfAllTerminal(recs, summary) {
+        if (summary.total > 0 &&
+            summary.done === summary.total &&
+            this.prevSummaryDone !== summary.done) {
             this.prevSummaryDone = summary.done;
             this.handlers.onDone?.({ kind: 'done', summary });
             this.stop();

package/dist/services/code/compact-event-settle-types.d.ts

@@ -0,0 +1,80 @@
+/**
+ * `src/services/code/compact-event-settle-types.ts`
+ *
+ * The declaration surface of the `PostCompact` settle path
+ * (`compact-event-settle.ts`): the harness's trigger vocabulary, the pathway
+ * label it files under, the post-compact reading, and the result shape the
+ * hook returns. Extracted verbatim (wave 3, file-size cap campaign) so the
+ * settle module stays under the 300 raw-line cap. Types and one label only —
+ * no settlement behaviour lives here. `compact-event-settle.ts` imports and
+ * re-exports every name below, so importers keep resolving them from
+ * `compact-event-settle.js` unchanged.
+ */
+/** The harness's own report of what caused a compaction. */
+export type CompactTrigger = 'manual' | 'auto';
+/**
+ * Which layer settled the run. `post-compact-hook` = the harness's event;
+ * `post-compact-probe` (written by the orchestrator) = a later probe's
+ * measurement. The two are deliberately distinct strings so a reader of
+ * `compact-history.jsonl` can tell a NOTIFICATION from an INFERENCE — which is
+ * the entire instrument this slice exists to build.
+ */
+export declare const COMPACT_EVENT_PATHWAY = "post-compact-hook";
+/**
+ * One post-compact reading: the ratio, the window it was divided by, and the
+ * adapter that produced it — all from a SINGLE probe call, so the three cannot
+ * disagree with each other.
+ */
+export type PostCompactMeasurement = {
+    /** `null` = nothing could be measured. Never `0`, which means "unknown". */
+    readonly ratio: number | null;
+    readonly ide: string;
+    readonly windowTokens: number | null;
+    readonly windowSource: string | null;
+};
+export type CompactSettleResult = {
+    readonly settled: true;
+    readonly runId: string;
+    readonly beforeRatio: number;
+    /** The measured post-compact ratio, or `null` when none was trustworthy. */
+    readonly afterRatio: number | null;
+    /** Present only when the harness reported one. */
+    readonly trigger?: CompactTrigger;
+    /**
+     * Whether the `observed` row for this event is on disk. `false` means
+     * there is none, for one of two DIFFERENT reasons, told apart by
+     * `lifecycleWritten`:
+     *
+     *   - `lifecycleWritten: true` — the append was attempted and threw.
+     *   - `lifecycleWritten: false` — the append was deliberately not made,
+     *     because the settle it would describe is one the store never
+     *     recorded (see `lifecycleWritten`).
+     */
+    readonly historyWritten: boolean;
+    /**
+     * False when the lifecycle record could not be written. The run is then
+     * still open, and this path does NOT append the `observed` row: the row
+     * would assert a settled measurement for a run the store still holds at
+     * `armed` / `compacting`, and each arrival would add another one. The
+     * row is deferred rather than lost — the run stays open, so the retry
+     * that does land owns the row and measures the ratio at that moment.
+     * This is repair R6's answer on the probe path
+     * (`auto-compact-orchestrator.ts`), applied here so the two settle
+     * paths agree.
+     *
+     * The two halves are reported separately rather than collapsed: a caller
+     * that sees only one of them cannot say which half of the settlement
+     * landed.
+     */
+    readonly lifecycleWritten: boolean;
+} | {
+    readonly settled: false;
+    /**
+     * `nothing-to-settle` — there was no open run. `different-session` — the
+     * payload named a harness session that is not this project's, so the open
+     * run was left alone. The second is a refusal of ATTRIBUTION, not an
+     * absence of it, and a reader told "nothing was open" would be told
+     * something false.
+     */
+    readonly reason: 'nothing-to-settle' | 'different-session';
+};

package/dist/services/code/compact-event-settle-types.js

@@ -0,0 +1,20 @@
+/**
+ * `src/services/code/compact-event-settle-types.ts`
+ *
+ * The declaration surface of the `PostCompact` settle path
+ * (`compact-event-settle.ts`): the harness's trigger vocabulary, the pathway
+ * label it files under, the post-compact reading, and the result shape the
+ * hook returns. Extracted verbatim (wave 3, file-size cap campaign) so the
+ * settle module stays under the 300 raw-line cap. Types and one label only —
+ * no settlement behaviour lives here. `compact-event-settle.ts` imports and
+ * re-exports every name below, so importers keep resolving them from
+ * `compact-event-settle.js` unchanged.
+ */
+/**
+ * Which layer settled the run. `post-compact-hook` = the harness's event;
+ * `post-compact-probe` (written by the orchestrator) = a later probe's
+ * measurement. The two are deliberately distinct strings so a reader of
+ * `compact-history.jsonl` can tell a NOTIFICATION from an INFERENCE — which is
+ * the entire instrument this slice exists to build.
+ */
+export const COMPACT_EVENT_PATHWAY = 'post-compact-hook';

package/dist/services/code/compact-event-settle.d.ts

@@ -1,71 +1,6 @@
-/** The harness's own report of what caused a compaction. */
-export type CompactTrigger = 'manual' | 'auto';
-/**
- * Which layer settled the run. `post-compact-hook` = the harness's event;
- * `post-compact-probe` (written by the orchestrator) = a later probe's
- * measurement. The two are deliberately distinct strings so a reader of
- * `compact-history.jsonl` can tell a NOTIFICATION from an INFERENCE — which is
- * the entire instrument this slice exists to build.
- */
-export declare const COMPACT_EVENT_PATHWAY = "post-compact-hook";
-/**
- * One post-compact reading: the ratio, the window it was divided by, and the
- * adapter that produced it — all from a SINGLE probe call, so the three cannot
- * disagree with each other.
- */
-export type PostCompactMeasurement = {
-    /** `null` = nothing could be measured. Never `0`, which means "unknown". */
-    readonly ratio: number | null;
-    readonly ide: string;
-    readonly windowTokens: number | null;
-    readonly windowSource: string | null;
-};
-export type CompactSettleResult = {
-    readonly settled: true;
-    readonly runId: string;
-    readonly beforeRatio: number;
-    /** The measured post-compact ratio, or `null` when none was trustworthy. */
-    readonly afterRatio: number | null;
-    /** Present only when the harness reported one. */
-    readonly trigger?: CompactTrigger;
-    /**
-     * Whether the `observed` row for this event is on disk. `false` means
-     * there is none, for one of two DIFFERENT reasons, told apart by
-     * `lifecycleWritten`:
-     *
-     *   - `lifecycleWritten: true` — the append was attempted and threw.
-     *   - `lifecycleWritten: false` — the append was deliberately not made,
-     *     because the settle it would describe is one the store never
-     *     recorded (see `lifecycleWritten`).
-     */
-    readonly historyWritten: boolean;
-    /**
-     * False when the lifecycle record could not be written. The run is then
-     * still open, and this path does NOT append the `observed` row: the row
-     * would assert a settled measurement for a run the store still holds at
-     * `armed` / `compacting`, and each arrival would add another one. The
-     * row is deferred rather than lost — the run stays open, so the retry
-     * that does land owns the row and measures the ratio at that moment.
-     * This is repair R6's answer on the probe path
-     * (`auto-compact-orchestrator.ts`), applied here so the two settle
-     * paths agree.
-     *
-     * The two halves are reported separately rather than collapsed: a caller
-     * that sees only one of them cannot say which half of the settlement
-     * landed.
-     */
-    readonly lifecycleWritten: boolean;
-} | {
-    readonly settled: false;
-    /**
-     * `nothing-to-settle` — there was no open run. `different-session` — the
-     * payload named a harness session that is not this project's, so the open
-     * run was left alone. The second is a refusal of ATTRIBUTION, not an
-     * absence of it, and a reader told "nothing was open" would be told
-     * something false.
-     */
-    readonly reason: 'nothing-to-settle' | 'different-session';
-};
+import { type CompactSettleResult, type CompactTrigger, type PostCompactMeasurement } from './compact-event-settle-types.js';
+export { COMPACT_EVENT_PATHWAY } from './compact-event-settle-types.js';
+export type { CompactSettleResult, CompactTrigger, PostCompactMeasurement } from './compact-event-settle-types.js';
 /**
  * Read `trigger` out of an already-parsed `PostCompact` payload.
  *

package/dist/services/code/compact-event-settle.js

@@ -50,14 +50,11 @@ import { readContextPercent } from '../context/auto-compact-reader.js';
 import { resolveOuterSessionId } from '../session/binding-status-service.js';
 import { appendCompactHistoryEvent } from './auto-compact-orchestrator.js';
 import { settleOpenLifecycleRunOnCompactEvent } from './auto-compact-lifecycle.js';
-/**
- * Which layer settled the run. `post-compact-hook` = the harness's event;
- * `post-compact-probe` (written by the orchestrator) = a later probe's
- * measurement. The two are deliberately distinct strings so a reader of
- * `compact-history.jsonl` can tell a NOTIFICATION from an INFERENCE — which is
- * the entire instrument this slice exists to build.
- */
-export const COMPACT_EVENT_PATHWAY = 'post-compact-hook';
+import { COMPACT_EVENT_PATHWAY } from './compact-event-settle-types.js';
+// The trigger / pathway label / measurement / result declarations live in
+// `compact-event-settle-types.ts` (wave-3 file-size cap split; moved verbatim).
+// Re-exported here so importers keep resolving them from this module's path.
+export { COMPACT_EVENT_PATHWAY } from './compact-event-settle-types.js';
 /**
  * Read `trigger` out of an already-parsed `PostCompact` payload.
  *
@@ -206,11 +203,18 @@ export function settleCompactFromHarnessEvent(input) {
                 ? ` (measured now at ${(settled.afterRatio * 100).toFixed(1)}%)`
                 : ' (no post-compact measurement available)'),
         ...(settled.afterRatio !== null
-            ? { windowTokens: measurement?.windowTokens ?? null, windowSource: measurement?.windowSource ?? null }
+            ? {
+                windowTokens: measurement?.windowTokens ?? null,
+                windowSource: measurement?.windowSource ?? null
+            }
             : {})
     };
     try {
-        appendCompactHistoryEvent({ projectRoot: input.projectRoot, sessionId: input.sessionId, event });
+        appendCompactHistoryEvent({
+            projectRoot: input.projectRoot,
+            sessionId: input.sessionId,
+            event
+        });
     }
     catch {
         // The lifecycle run is already settled; losing the history row is the

package/dist/services/code/dag-orchestrator.js

@@ -52,6 +52,37 @@ const defaultWriter = (projectRoot, sessionId) => (sliceId, publicSurface) => {
     });
     return r.contract;
 };
+/**
+ * The MVP structured fallback prompt, moved verbatim out of
+ * `buildDispatchSpec` to clear its `max-lines-per-function` arm; the
+ * returned text is identical to what the inline block produced.
+ */
+function buildMvpFallbackPrompt(sliceId, node, contractBlock) {
+    // MVP (1.2) structured fallback prompt. Slice 1.4 will land per-domain
+    // prompt templates (one per role), but for the MVP dogfood we ship a
+    // single structured prompt that:
+    //   1. names the slice id + role + label (so the LLM knows what to do)
+    //   2. states the MVP scope explicitly (avoid confusion with full prod)
+    //   3. includes the ancestor contract injection (so downstream slices
+    //      see their inputs)
+    //   4. states the handoff protocol (write contract, re-invoke for next level)
+    const labelFragment = node.label ? ` — ${node.label}` : '';
+    const ancestorFragment = contractBlock ? `\n\n${contractBlock}` : '';
+    return [
+        formatTestToolDetection(),
+        '',
+        `[slice-dag-dispatcher MVP 1.2] execute slice "${sliceId}" (role=${node.role})${labelFragment}.`,
+        '',
+        'Scope: this is the 2.7.0 MVP dogfood of peaks-loop DAG-aware dispatch. You are one leaf in a multi-slice plan; the orchestrator has already validated the DAG, built a topological order, and injected your upstream contracts above.',
+        '',
+        'Handoff protocol (REQUIRED — orchestrator depends on this):',
+        '  1. Execute the slice to completion.',
+        `  2. Write your public contract via \`peaks contract write --project <root> --session-id <sid> --slice-id ${sliceId} --exports <...> --types <...> --signatures <...>\`. The orchestrator will pick it up on the next dispatch run.`,
+        '  3. Do NOT re-invoke `peaks sub-agent dispatch --from-dag` yourself — the parent orchestrator (peaks-code) drives level advancement.',
+        '',
+        `After your contract is on disk, the orchestrator will auto-advance to the next topological level (if any) by re-invoking \`peaks sub-agent dispatch --from-dag\` with the same batch-id. Your slice will appear in its ancestors via \`formatContractInjection\`.${ancestorFragment}`
+    ].join('\n');
+}
 /**
  * Build a single dispatch spec for `sliceId` given the current contract set.
  *
@@ -88,32 +119,7 @@ export function buildDispatchSpec(dag, sliceId, contracts, defaultPrompt) {
             contractBlock
         };
     }
-    // MVP (1.2) structured fallback prompt. Slice 1.4 will land per-domain
-    // prompt templates (one per role), but for the MVP dogfood we ship a
-    // single structured prompt that:
-    //   1. names the slice id + role + label (so the LLM knows what to do)
-    //   2. states the MVP scope explicitly (avoid confusion with full prod)
-    //   3. includes the ancestor contract injection (so downstream slices
-    //      see their inputs)
-    //   4. states the handoff protocol (write contract, re-invoke for next level)
-    const labelFragment = node.label ? ` — ${node.label}` : '';
-    const ancestorFragment = contractBlock
-        ? `\n\n${contractBlock}`
-        : '';
-    const prompt = [
-        formatTestToolDetection(),
-        '',
-        `[slice-dag-dispatcher MVP 1.2] execute slice "${sliceId}" (role=${node.role})${labelFragment}.`,
-        '',
-        'Scope: this is the 2.7.0 MVP dogfood of peaks-loop DAG-aware dispatch. You are one leaf in a multi-slice plan; the orchestrator has already validated the DAG, built a topological order, and injected your upstream contracts above.',
-        '',
-        'Handoff protocol (REQUIRED — orchestrator depends on this):',
-        '  1. Execute the slice to completion.',
-        `  2. Write your public contract via \`peaks contract write --project <root> --session-id <sid> --slice-id ${sliceId} --exports <...> --types <...> --signatures <...>\`. The orchestrator will pick it up on the next dispatch run.`,
-        '  3. Do NOT re-invoke `peaks sub-agent dispatch --from-dag` yourself — the parent orchestrator (peaks-code) drives level advancement.',
-        '',
-        `After your contract is on disk, the orchestrator will auto-advance to the next topological level (if any) by re-invoking \`peaks sub-agent dispatch --from-dag\` with the same batch-id. Your slice will appear in its ancestors via \`formatContractInjection\`.${ancestorFragment}`
-    ].join('\n');
+    const prompt = buildMvpFallbackPrompt(sliceId, node, contractBlock);
     return {
         sliceId,
         role: node.role,

package/dist/services/code/job-shape-decision.js

@@ -29,7 +29,9 @@ const SUGGESTED_JID_RE = /^[a-z0-9][a-z0-9-]{2,40}$/;
 const JobShapeDecisionSchema = z.object({
     isJob: z.boolean(),
     rationale: z.string().min(1).max(2000),
-    suggestedJobId: z.string().regex(SUGGESTED_JID_RE, 'suggestedJobId must match /^[a-z0-9][a-z0-9-]{2,40}$/'),
+    suggestedJobId: z
+        .string()
+        .regex(SUGGESTED_JID_RE, 'suggestedJobId must match /^[a-z0-9][a-z0-9-]{2,40}$/'),
     suggestedStrategy: z.enum(['single', 'rotating']),
     confidence: z.enum(['high', 'medium', 'low']),
     decidedAt: z.string().datetime()

package/dist/services/code/mode-gate-types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * `src/services/code/mode-gate-types.ts`
+ *
+ * The declaration surface of the D5 gate: the mode alias, the gated-step
+ * vocabulary, and the commit-boundary vocabulary with its regex matchers.
+ * Extracted verbatim from `mode-gate.ts` (wave 3, file-size cap campaign) so
+ * the gate module stays under the 300 raw-line cap. Mechanical move only — no
+ * decision logic lives here. `mode-gate.ts` imports and re-exports every name
+ * below, so importers keep resolving them from `mode-gate.js` unchanged.
+ *
+ * The hard-floor vocabulary deliberately does NOT live here:
+ * `feedback-promotion` certifies a layer-C rule by reading
+ * `HardFloorCategory` and `HARD_FLOOR_CATEGORIES` out of `mode-gate.ts`
+ * itself (see `promotion-artifact-evidence.ts`).
+ */
+import type { SkillPresenceMode } from '../skills/skill-presence-service.js';
+export type CodeMode = SkillPresenceMode;
+export declare const CODE_MODES: readonly CodeMode[];
+/**
+ * The 14 SKILL.md AskUserQuestion sites mapped in the D5 memory's
+ * "Inventory of unconditional confirmation gates" table. Each row
+ * is the bare minimum needed to gate it through `shouldPauseAtGate`.
+ */
+export type GatedStepId = 'step-0.5-openspec-opt-in' | 'step-0.6-audit-goal' | 'step-0.7-resume-detection' | 'step-1-mode-select' | 'step-2.5-session-title' | 'phase-2-prd-confirm' | 'phase-3-swarm-gate-b' | 'phase-6-qa-gate-d' | 'phase-10-txt-memory-extract' | 'step-n+1-final-review' | 'frontend-only-mismatch' | 'step-0.75-checkpoint-resume' | 'standards-preflight';
+export declare const GATED_STEPS: readonly GatedStepId[];
+/**
+ * v2.15.0 slice 002 AC-4: the 5 action identifiers that qualify as
+ * commit-boundary side effects. Matched by the LLM-side caller
+ * (peaks-code body / peaks-rd fork agent) when it is about to run a
+ * Bash command that maps to one of these. Set `commitBoundaryAction:
+ * true` on the `shouldPauseAtGate` call to trigger the hard-floor
+ * override.
+ */
+export type CommitBoundaryActionId = 'git-push' | 'git-tag' | 'npm-publish' | 'npm-install-global' | 'peaks-global-install';
+export declare const COMMIT_BOUNDARY_ACTIONS: readonly CommitBoundaryActionId[];
+/**
+ * v2.15.0 slice 002 AC-4: regex matchers the LLM-side caller uses
+ * to flag a Bash command as a commit-boundary action. Centralised
+ * here so the test seam + the CLI wiring share one source of
+ * truth. Each entry is an anchored pattern matched against the
+ * user-invoked command (after commander / shell normalisation,
+ * before execution).
+ *
+ * Patterns intentionally cover the common canonical forms:
+ *
+ *   - `git-push`            → `git push`, `git push origin main`, `git push --tags`
+ *   - `git-tag`             → `git tag v2.15.0`, `git tag -a v2.15.0 -m ...`
+ *   - `npm-publish`         → `npm publish`, `npm publish --access public`
+ *   - `npm-install-global`  → `npm install -g <pkg>`, `npm i -g <pkg>`
+ *   - `peaks-global-install`→ `npm install -g peaks-loop`, `pnpm add -g peaks-loop`
+ *
+ * These are coarse — false positives are fine (worst case: a
+ * non-actionable command gets paused for confirmation; the user
+ * can confirm in one click). False negatives are NOT fine — a
+ * missed publish would violate the full-auto boundary.
+ */
+export declare const COMMIT_BOUNDARY_PATTERNS: Readonly<Record<CommitBoundaryActionId, RegExp>>;