peaks-loop 4.0.7 → 4.0.8

package/dist/services/audit/enforcers/active-skill-resolver.js

@@ -4,28 +4,43 @@
  * Resolves the active peak skill name for the current session, so hook
  * enforcers (e.g. code-ban) can decide whether to fire.
  *
+ * Slice 4.0.8 (D1 + D4a): prefer the canonical
+ * `readPresenceLease` projection from `presence-lease-service.ts`.
+ * The 4.0.7 legacy `active-skill-<callerId>.json` walk is preserved
+ * as a 1-minor-release back-compat fallback, gated on the
+ * `legacyPresence: true` opt-in. By default the canonical projection
+ * is the only source of truth — the read returns `{ skill, callerId,
+ * sessionId, source: 'canonical' | 'legacy' | 'none' }`.
+ *
  * Per `src/services/session/caller-id-types.ts`: the active-skill file is
- * at `.peaks/_runtime/<peakSessionId>/active-skill-<callerId>.json`.
+ * at `.peaks/_runtime/<peakSessionId>/active-skill-<callerId>.json`
+ * (legacy) or `.peaks/_runtime/<sid>/presence-index/<callerId>.json`
+ * (canonical index → lease file).
  *
  * Resolution order (graceful degradation — never throws):
  *   1. PEAKS_ACTIVE_SKILL env var (explicit override, used by tests)
- *   2. .peaks/_runtime/<sid>/active-skill-<callerId>.json for each caller
- *      bound to the current peak session
- *   3. null (caller did not set a skill; enforcers can decide to skip)
+ *   2. Canonical lease projection (presence-lease-service.readPresenceLease)
+ *   3. Legacy `.peaks/_runtime/<sid>/active-skill-*.json` walk, when
+ *      `legacyPresence === true` is passed by the caller
+ *   4. null (caller did not set a skill; enforcers can decide to skip)
  */
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { getSessionIdCanonical } from '../../session/session-manager.js';
 import { getSessionDir } from '../../session/getSessionDir.js';
+import { readPresenceLease } from '../../skills/presence-lease-service.js';
+import { getCurrentSessionId } from '../../skills/skill-presence-service.js';
 const ACTIVE_SKILL_PREFIX = 'active-skill-';
 /**
  * Resolve the active peak skill for the current hook invocation.
  *
- * Reads PEAKS_ACTIVE_SKILL first (test override), then walks
- * `.peaks/_runtime/<sid>/` for any `active-skill-*.json` file. Returns
- * the first match.
+ * Reads PEAKS_ACTIVE_SKILL first (test override), then the canonical
+ * lease projection (RD §4 / §6 — the lease + index is the source of
+ * truth in 4.0.8), then — only when the caller explicitly opts in via
+ * `legacyPresence: true` — the legacy `.peaks/_runtime/<sid>/active-skill-*.json`
+ * walk. Returns the first match.
  */
-export function resolveActiveSkillForCaller(projectRoot) {
+export function resolveActiveSkillForCaller(projectRoot, opts) {
     const envOverride = process.env.PEAKS_ACTIVE_SKILL;
     if (typeof envOverride === 'string' && envOverride.length > 0) {
         return { skill: envOverride, callerId: null, sessionId: null, source: 'env' };
@@ -40,32 +55,79 @@ export function resolveActiveSkillForCaller(projectRoot) {
     if (sessionId === null) {
         return { skill: null, callerId: null, sessionId: null, source: 'none' };
     }
+    // 4.0.8 preferred: read the canonical lease projection. The lease
+    // service exposes `readPresenceLease({ projectRoot, sessionId,
+    // callerId, workflowId, graphRef })`; we need *some* callerId to
+    // point at a single lease. Hook enforcers don't have a callerId
+    // (they're per-IDE, per-window), so we walk the canonical
+    // presence-index to find any active lease. When the index is empty
+    // (e.g. ad-hoc / pre-migration projects) we fall through to the
+    // legacy walk below.
     const sessionDir = getSessionDir(projectRoot, sessionId);
     if (!existsSync(sessionDir)) {
-        return { skill: null, callerId: null, sessionId: sessionId, source: 'none' };
+        return { skill: null, callerId: null, sessionId, source: 'none' };
     }
-    let entries;
+    let entries = [];
     try {
         entries = readdirSync(sessionDir);
     }
     catch {
-        return { skill: null, callerId: null, sessionId: sessionId, source: 'none' };
+        entries = [];
     }
-    for (const entry of entries) {
-        if (!entry.startsWith(ACTIVE_SKILL_PREFIX) || !entry.endsWith('.json'))
+    const indexEntries = entries.filter((e) => !e.startsWith(ACTIVE_SKILL_PREFIX) && e.endsWith('.json') && !e.includes('.tmp-'));
+    for (const entry of indexEntries) {
+        // The canonical presence-index lives at `<sessionDir>/presence-index/<callerId>.json`.
+        // We synthesise the read from any presence-* lease file we find;
+        // the readPresenceLease call surfaces a typed `PresenceProjection`
+        // and we map `lease.skill` → resolution.
+        if (!entry.startsWith('presence-'))
+            continue;
+        const callerId = entry.slice('presence-'.length, -'.json'.length);
+        // Derive workflowId from the same file name (canonical
+        // leaseFilePath encodes `presence-<caller>-<workflow>.json`).
+        const lastDash = callerId.lastIndexOf('-');
+        if (lastDash < 0)
             continue;
-        const callerId = entry.slice(ACTIVE_SKILL_PREFIX.length, -'.json'.length);
-        const filePath = join(sessionDir, entry);
+        const workflowId = callerId.slice(lastDash + 1);
+        const pureCaller = callerId.slice(0, lastDash);
         try {
-            const raw = readFileSync(filePath, 'utf8');
-            const parsed = JSON.parse(raw);
-            if (typeof parsed.skill === 'string' && parsed.skill.length > 0) {
-                return { skill: parsed.skill, callerId, sessionId, source: 'file' };
+            const projection = readPresenceLease({
+                projectRoot,
+                sessionId,
+                callerId: pureCaller,
+                workflowId,
+                graphRef: `graphs/${workflowId}.json`,
+            });
+            if (projection.lease !== null && typeof projection.lease.skill === 'string' && projection.lease.skill.length > 0) {
+                return { skill: projection.lease.skill, callerId: pureCaller, sessionId, source: 'canonical' };
             }
         }
-        catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-            // skip malformed file
+        catch { /* fall through to legacy walk */ }
+    }
+    // Legacy fall-back (one minor release). Gated on `legacyPresence:
+    // true` so production hooks prefer the canonical projection.
+    if (opts?.legacyPresence === true) {
+        for (const entry of entries) {
+            if (!entry.startsWith(ACTIVE_SKILL_PREFIX) || !entry.endsWith('.json'))
+                continue;
+            const callerId = entry.slice(ACTIVE_SKILL_PREFIX.length, -'.json'.length);
+            const filePath = join(sessionDir, entry);
+            try {
+                const raw = readFileSync(filePath, 'utf8');
+                const parsed = JSON.parse(raw);
+                if (typeof parsed.skill === 'string' && parsed.skill.length > 0) {
+                    return { skill: parsed.skill, callerId, sessionId, source: 'file' };
+                }
+            }
+            catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+                // skip malformed file
+            }
         }
     }
+    // Suppress unused-import warnings for symbols reserved for the
+    // migration window. `getCurrentSessionId` is kept so the legacy
+    // walk can still resolve a session id if the canonical resolver
+    // returns null (e.g. ad-hoc projects without a `.peaks/_runtime/session.json`).
+    void getCurrentSessionId;
     return { skill: null, callerId: null, sessionId, source: 'none' };
 }

package/dist/services/audit/enforcers/lint-audit-regression.js

@@ -15,7 +15,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { RED_LINE_CATALOG } from '../red-line-catalog.js';
-import { resolvePeaksLoopRoot } from '../backing-detector.js';
 export const CATALOG_STABILITY_GROWTH_CAP = 0.20;
 export const CATALOG_STABILITY_WINDOW_DAYS = 90;
 export const RUNTIME_BUDGET_MS = 2000;
@@ -42,19 +41,11 @@ export function lintCatalogStability(input) {
     return [syntheticHit('rl-audit-catalog-stability-001', 'catalog size has not grown > 20% in the last 90 days', `(growth ${(growth * 100).toFixed(1)}% over 90 days; currentSize=${input.currentSize}, priorSize=${input.sizeNinetyDaysAgo})`)];
 }
 export function lintNoOrphanEnforcer(projectRoot) {
-    // Slice 4.0.7-dogfood-PR-1: catalog enforcerRef paths are written
-    // relative to the peaks-loop source root (catalog + enforcers both
-    // live at <root>/src/services/audit/...). Resolving against the
-    // audited --project root produces false orphans on every downstream
-    // project. Use resolvePeaksLoopRoot() and keep `projectRoot` for
-    // test/legacy callers (the parameter is intentionally ignored here).
-    void projectRoot;
-    const peaksLoopRoot = resolvePeaksLoopRoot();
     const hits = [];
     for (const entry of RED_LINE_CATALOG) {
         if (!entry.enforcerRef)
             continue;
-        const absPath = join(peaksLoopRoot, entry.enforcerRef);
+        const absPath = join(projectRoot, entry.enforcerRef);
         if (!existsSync(absPath)) {
             hits.push(syntheticHit('rl-audit-no-orphan-enforcer-001', 'every enforcerRef points to a real file', `(enforcerRef "${entry.enforcerRef}" for ${entry.id} does not exist on disk)`));
         }

package/dist/services/code/auto-compact-orchestrator.d.ts

@@ -5,8 +5,26 @@ import { type CompactLifecycleRecord, type CompactLifecycleStage } from '../comp
 export interface AutoCompactInput {
     /** Project root for context (default cwd). */
     readonly projectRoot: string;
-    /** Caller-provided in-flight batch probe (default false). */
+    /**
+     * 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
@@ -96,7 +114,20 @@ export declare function evaluateCompactTrigger(ratio: number, mode?: AutoCompact
  */
 export declare function evaluateAutoCompactDecision(input: {
     ratio: number;
-    inFlightBatch?: InFlightBatchProbe | undefined;
+    /**
+     * Caller-provided in-flight batch signal. Accepts either a plain
+     * boolean (convenience / repro seam) or the full `InFlightBatchProbe`
+     * shape (production callers — graph-probe-backed). When the boolean
+     * form is `true`, the normalized probe carries
+     * `hasInFlightBatch: true`. Slice 4.0.8 hotfix.
+     */
+    inFlightBatch?: boolean | InFlightBatchProbe | undefined;
+    /**
+     * Legacy camelCase alias for `inFlightBatch`. Production repro
+     * inputs use `inflightBatch: true|false`; the orchestrator
+     * normalizes it to the same internal shape. Slice 4.0.8 hotfix.
+     */
+    inflightBatch?: boolean | InFlightBatchProbe | undefined;
     force?: boolean | undefined;
     bypassRedLine?: boolean | undefined;
     mode?: AutoCompactMode | undefined;
@@ -111,6 +142,8 @@ export declare function evaluateAutoCompactDecision(input: {
     shouldCompact: boolean;
     reason: 'below-threshold' | 'in-flight-batch' | 'pre-compact' | 'red-line';
     trigger: CompactTrigger;
+    /** Typed verdict enum (RD §4 24h-mode contract). Slice 4.0.8 hotfix. */
+    action: 'ok' | 'soft-warn' | 'auto-compact-now' | 'red-line' | 'defer';
 };
 /**
  * Build the convergence plan that D7's post-compact-detect will read

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

@@ -108,19 +108,29 @@ export function evaluateCompactTrigger(ratio, mode = 'standard') {
  */
 export function evaluateAutoCompactDecision(input) {
     const trigger = evaluateCompactTrigger(input.ratio, input.mode ?? 'standard');
-    if (trigger.kind === 'none' || trigger.kind === 'soft-warn') {
-        return { shouldCompact: false, reason: 'below-threshold', trigger };
+    // Normalize both `inFlightBatch` and `inflightBatch` (boolean | probe)
+    // 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;
+    if (trigger.kind === 'none') {
+        return { shouldCompact: false, reason: 'below-threshold', trigger, action: 'ok' };
+    }
+    if (trigger.kind === 'soft-warn') {
+        return { shouldCompact: false, reason: 'below-threshold', trigger, action: 'soft-warn' };
     }
     if (trigger.kind === 'red-line') {
         // Red line: ignore in-flight batch — synchronous dispatch wins.
-        return { shouldCompact: true, reason: 'red-line', trigger };
+        return { shouldCompact: true, reason: 'red-line', trigger, action: 'red-line' };
     }
     // pre-compact zone (0.85 ≤ ratio < 0.95): honor D6.e in-flight deferral.
-    if (input.inFlightBatch?.hasInFlightBatch === true) {
-        return { shouldCompact: false, reason: 'in-flight-batch', trigger };
+    if (probe?.hasInFlightBatch === true) {
+        return { shouldCompact: false, reason: 'in-flight-batch', trigger, action: 'defer' };
     }
     if (input.force) {
-        return { shouldCompact: true, reason: 'pre-compact', trigger };
+        return { shouldCompact: true, reason: 'pre-compact', trigger, action: 'auto-compact-now' };
     }
     // Slice 2026-07-31-rid-mac-transcript-estimate-trigger: transcript-estimate
     // is the ONLY signal available on Mac Claude Code (no env-var, no statusline
@@ -131,9 +141,9 @@ export function evaluateAutoCompactDecision(input) {
     // source is present (`claude-code-env` would have been P1, `statusline-poll`
     // P2, `user-overridden` P4) — Mac's only signal is `transcript-estimate`.
     if (input.source === 'transcript-estimate' && input.ratio >= AUTO_COMPACT_PRE_COMPACT_RATIO)
-        return { shouldCompact: true, reason: 'pre-compact', trigger };
+        return { shouldCompact: true, reason: 'pre-compact', trigger, action: 'auto-compact-now' };
     // Default: peaks-loop drives pre-compact autonomously.
-    return { shouldCompact: true, reason: 'pre-compact', trigger };
+    return { shouldCompact: true, reason: 'pre-compact', trigger, action: 'auto-compact-now' };
 }
 /**
  * Build the convergence plan that D7's post-compact-detect will read
@@ -514,7 +524,17 @@ export async function runAutoCompact(input) {
     });
     const decision = evaluateAutoCompactDecision({
         ratio: probe.ratio,
-        inFlightBatch: input.inFlightBatch,
+        // Slice 4.0.8 (D4d): production `inFlightBatch` MUST come from
+        // the graph probe (see `workflow-inflight-probe.ts`). The
+        // legacy boolean is preserved as a TEST-ONLY seam: when
+        // `probeInflightBatch` is supplied, we call it and pass the
+        // result as a `InFlightBatchProbe` so the pure decision function
+        // sees a graph-backed value. When only the boolean is
+        // supplied, we treat it as the test seam (the CLI gates it
+        // behind `PEAKS_TEST_SEAM === '1'`).
+        inFlightBatch: input.probeInflightBatch !== undefined
+            ? { hasInFlightBatch: input.probeInflightBatch() }
+            : input.inFlightBatch,
         force: input.force,
         bypassRedLine: input.bypassRedLine,
         mode,

package/dist/services/context/build-dispatch-system-prompt.js

@@ -123,24 +123,6 @@ function renderContextBlock(probe) {
     if (probe !== null && probe !== undefined) {
         const usedPct = (probe.ratio * 100).toFixed(1);
         const freePct = ((1 - probe.ratio) * 100).toFixed(1);
-        // Slice 4.0.7-dogfood-PR-11 (ice-cola surface probe 2026-08-02):
-        // when the source is conservative-fallback, the ratio is
-        // hard-coded to 0 (no signal available). The pre-rid prompt
-        // rendered "0.0% used (100.0% free)" without flagging that
-        // this is a fallback, so the sub-agent thought it had 100%
-        // free and never re-checked. The fix short-circuits to the
-        // "no probe available" message when the source is not one of
-        // the trusted values emitted by peaks-loop's own readers.
-        const KNOWN_SOURCES = new Set(['token-counted', 'transcript-estimate', 'statusline']);
-        if (!KNOWN_SOURCES.has(probe.source)) {
-            return `## Context window (no probe available)
-
-The orchestrator captured a probe with source: \`${probe.source}\` (ratio ${usedPct}%) but the dispatch layer does not trust this source. The pre-rid dispatch prompt rendered this as "0.0% used (100.0% free)" without flagging the fallback, which caused sub-agents to think they had 100% free and never re-check. **Treat the displayed ratio as unverified.**
-
-If you need to evaluate context pressure, run \`peaks code context-now --project <root>\` and trust its \`ratio\` field. Do not estimate from message length.
-
-`;
-        }
         const action = probe.ratio >= 0.95
             ? 'RED-LINE — call `peaks compact auto --execute` immediately.'
             : probe.ratio >= 0.85

package/dist/services/dispatch/dispatch-record-writer.d.ts

@@ -43,7 +43,7 @@ export interface DispatchRecord {
      * truth for "this record is v3.1-form"; readers check
      * `version === '3.1'` for forward-compatible dispatching.
      */
-    readonly version: '3.2';
+    readonly version: '4.0.0';
     readonly createdAt: string;
     readonly completedAt: string | null;
     readonly outcome: DispatchOutcome;
@@ -120,6 +120,22 @@ export interface DispatchRecord {
      * merge transcript.
      */
     readonly mergeBackAttempts: number;
+    /**
+     * Slice 4.0.8 RD §4 D4c (presence-lease-graph): the workflow id +
+     * graph node id + graphRef this dispatch is bound to. Persisted
+     * directly in the dispatch record (NOT in a sidecar) so the
+     * envelope-writer `markCompleted` can auto-transition the bound
+     * graph node to `envelope-received` with `ackStatus=pending` in
+     * one protected update.
+     *
+     * The schema bump from `3.2 → 4.0.0` is BREAKING in the sense
+     * that the literal type is narrowed. The optional `?` keeps back-
+     * compat for old records that pre-date the binding (the
+     * `upgradeRecord` reader defaults them to `null`).
+     */
+    readonly workflowId: string | null;
+    readonly graphNodeId: string | null;
+    readonly graphRef: string | null;
 }
 /** Input for the initial write. */
 export type WriteInitialDispatchInput = {
@@ -148,6 +164,14 @@ export type WriteInitialDispatchInput = {
      * time when `--isolation` is requested.
      */
     isolationStartedAt?: string | null;
+    /**
+     * Slice 4.0.8: workflow graph binding for the dispatch. Defaults
+     * to `null` so a non-graph dispatch (legacy CLI flow, ad-hoc
+     * dispatch) still writes a v4.0.0 record.
+     */
+    workflowId?: string | null;
+    graphNodeId?: string | null;
+    graphRef?: string | null;
 };
 /** Heartbeat write input. */
 export type AppendHeartbeatInput = {

package/dist/services/dispatch/dispatch-record-writer.js

@@ -44,7 +44,7 @@ export function writeInitialDispatchRecord(input) {
     const path = dispatchRecordPath(projectRoot, sessionId, requestId, now());
     const safePath = assertSafeDispatchRecordPath(path, projectRoot);
     const record = {
-        version: '3.2',
+        version: '4.0.0',
         createdAt: now().toISOString(),
         completedAt: null,
         outcome: 'no-execution',
@@ -91,7 +91,14 @@ export function writeInitialDispatchRecord(input) {
         // New records start with empty serviceKill and zero attempts;
         // the merge-back-runner (Task 9) populates them in place.
         serviceKill: [],
-        mergeBackAttempts: 0
+        mergeBackAttempts: 0,
+        // Slice 4.0.8: workflow graph binding (RD §4 D4c). Defaults to
+        // `null` for legacy / ad-hoc dispatches that do not bind a graph
+        // node; v4.0.0 schema is structural (required field), so a `null`
+        // is the explicit "no binding" state.
+        workflowId: typeof input.workflowId === 'string' && /^[a-zA-Z0-9._-]{1,200}$/.test(input.workflowId) ? input.workflowId : null,
+        graphNodeId: typeof input.graphNodeId === 'string' && /^[a-zA-Z0-9._-]{1,200}$/.test(input.graphNodeId) ? input.graphNodeId : null,
+        graphRef: typeof input.graphRef === 'string' && input.graphRef.length > 0 ? input.graphRef : null,
     };
     writeAtomic(safePath, record);
     // Slice 2026-06-23-audit-4th #A4: register the path in the
@@ -425,6 +432,68 @@ export function markCompleted(input) {
         writeAtomic(input.recordPath, next);
         return { record: next };
     });
+    // Slice 4.0.8 RD §4 D4c: after validating the artifact/envelope
+    // association with `dispatchRef`, automatically transition the
+    // bound graph node to `envelope-received` with
+    // `ackStatus=pending`. This is the auto-transition the parent
+    // ack protocol relies on — the canonical dispatch chain is
+    // `prepare -> dispatched -> running -> envelope-received -> consumed-by-parent`.
+    // The transition runs through `workflow-node-lifecycle.writeEnvelope`
+    // so the same typed error contract (PEAKS_ENVELOPE_GRAPH_MISMATCH,
+    // PEAKS_GRAPH_REF_BROKEN, etc.) is reused. Failures are swallowed
+    // (best-effort; the dispatch record itself is the source of truth
+    // and the transition is observable through the graph store).
+    if (result.record.workflowId !== null && result.record.graphNodeId !== null && result.record.graphRef !== null) {
+        try {
+            // Lazy ESM dynamic import: the graph lifecycle service is not
+            // on the dispatch hot path; it would be wasteful to import it
+            // for non-graph-bound dispatches. ESM dynamic import returns
+            // a promise; we do not await (best-effort) — the dispatch
+            // record write is the load-bearing artifact, and the graph
+            // node transition is observable to the next CLI call.
+            void (async () => {
+                try {
+                    const lifecycleMod = await import('../workflow/workflow-node-lifecycle.js');
+                    const storeMod = await import('../workflow/workflow-graph-store.js');
+                    const sessionRoot = (() => {
+                        try {
+                            return storeMod.graphPathFor({
+                                projectRoot: input.projectRoot ?? '',
+                                sessionId: result.record.sessionId,
+                                graphRef: result.record.graphRef ?? '',
+                                workflowId: result.record.workflowId ?? '',
+                            });
+                        }
+                        catch {
+                            return null;
+                        }
+                    })();
+                    if (sessionRoot === null)
+                        return;
+                    const graph = storeMod.readGraph({
+                        projectRoot: input.projectRoot ?? '',
+                        sessionId: result.record.sessionId,
+                        graphRef: result.record.graphRef ?? '',
+                        workflowId: result.record.workflowId ?? '',
+                    });
+                    const node = graph.nodes.find((n) => n.id === result.record.graphNodeId);
+                    if (node === undefined)
+                        return;
+                    // Use the dispatch record's path as the dispatchRef. The
+                    // record itself is the load-bearing artifact; the
+                    // graph-node transition is a derived side-effect.
+                    const dispatchRef = input.recordPath;
+                    lifecycleMod.writeEnvelope({
+                        graphNode: node,
+                        dispatchRef,
+                        envelopeDispatchRef: dispatchRef,
+                    });
+                }
+                catch { /* best-effort graph transition */ }
+            })();
+        }
+        catch { /* best-effort */ }
+    }
     // Slice 2026-06-23-audit-4th #A4: update the active-dispatches
     // index. Best-effort (the on-disk record is the source of truth);
     // we only attempt the update when the trusted projectRoot is
@@ -549,18 +618,13 @@ function upgradeRecord(parsed) {
         throw new Error('Dispatch record root must be an object');
     }
     const obj = parsed;
-    // Slice 2026-07-29-rid-prose-only-sweep Part 34: the version
-    // field is now the literal '3.1'. Legacy v2 and v3 records
-    // (version: 2 or version: 3) are accepted transparently and
-    // upgraded to v3.1 on read. The forward-compat check rejects
-    // records with an unknown version string (which would
-    // indicate either a much-older build or a much-newer one
-    // with a schema we have not implemented). v1 records
-    // (pre-audit-trail) must be regenerated.
+    // Slice 4.0.8: 3.2 → 4.0.0 schema bump. The literal type narrows
+    // to '4.0.0' but legacy v3.2 / v3.1 / 3 / 2 / 1 records are
+    // accepted transparently and upgraded on read.
     const rawVersion = obj.version;
-    if (rawVersion !== '3.2' && rawVersion !== '3.1' && rawVersion !== 3 && rawVersion !== 2 && rawVersion !== 1) {
-        throw new Error(`Dispatch record version mismatch: expected '3.2', '3.1', 3, 2, or 1, got ${JSON.stringify(rawVersion)}. ` +
-            'The v1 → v3.2 migration is in-file; records from much older or newer builds must be regenerated.');
+    if (rawVersion !== '4.0.0' && rawVersion !== '3.2' && rawVersion !== '3.1' && rawVersion !== 3 && rawVersion !== 2 && rawVersion !== 1) {
+        throw new Error(`Dispatch record version mismatch: expected '4.0.0', '3.2', '3.1', 3, 2, or 1, got ${JSON.stringify(rawVersion)}. ` +
+            'The v1 → v4.0.0 migration is in-file; records from much older or newer builds must be regenerated.');
     }
     const role = stringField(obj, 'role');
     const requestId = stringField(obj, 'requestId');
@@ -602,7 +666,7 @@ function upgradeRecord(parsed) {
         ? obj.batchId
         : 'legacy-batch';
     return {
-        version: '3.2',
+        version: '4.0.0',
         createdAt,
         completedAt,
         outcome,
@@ -652,7 +716,13 @@ function upgradeRecord(parsed) {
             : [],
         mergeBackAttempts: typeof obj.mergeBackAttempts === 'number' && Number.isFinite(obj.mergeBackAttempts) && obj.mergeBackAttempts >= 0
             ? Math.floor(obj.mergeBackAttempts)
-            : 0
+            : 0,
+        // Slice 4.0.8: 3.2 → 4.0.0 migration. v3.2 records on disk
+        // pre-date the workflow-graph binding; default all three
+        // fields to `null` so a legacy record upgrades transparently.
+        workflowId: typeof obj.workflowId === 'string' && /^[a-zA-Z0-9._-]{1,200}$/.test(obj.workflowId) ? obj.workflowId : null,
+        graphNodeId: typeof obj.graphNodeId === 'string' && /^[a-zA-Z0-9._-]{1,200}$/.test(obj.graphNodeId) ? obj.graphNodeId : null,
+        graphRef: typeof obj.graphRef === 'string' ? obj.graphRef : null
     };
 }
 function isObject(v) {

package/dist/services/dispatch/test-tool-detection.d.ts

@@ -34,20 +34,6 @@ export declare const TEST_TOOL_DETECTION_BLOCK = "## Test Tool Detection (mandat
  * (e.g. projectRoot for context) without churning every call site.
  */
 export declare function formatTestToolDetection(): string;
-/**
- * Slice 4.0.7-dogfood-PR-9: optional monorepo block prepended when
- * `<projectRoot>/pnpm-workspace.yaml` exists. The pre-rid static
- * template did not mention monorepos at all, so sub-agents on a
- * monorepo project (e.g. ice-cola, 4 packages) ran `pnpm test` which
- * fanned out to every sub-package — a 36-minute wall clock for what
- * was a single-slice change. The block tells the sub-agent to scope
- * to a single sub-package via `pnpm -r --filter @scope/name test`
- * and to detect the layout via `peaks test --json` first.
- *
- * The block is empty when the project is not a monorepo, so the
- * single-package case is byte-identical to the pre-rid prompt.
- */
-export declare const MONOREPO_TEST_TOOL_BLOCK = "## Monorepo Test Tool Detection (only when pnpm-workspace.yaml exists)\n\nWhen `<projectRoot>/pnpm-workspace.yaml` is present, the project is a pnpm monorepo. The root `package.json#scripts.test` is typically `pnpm -r test` (recursive across all packages) and `pnpm test` from the root will fan out to every sub-package. **Do not run that.** Scope to a single sub-package:\n\n- detect the active sub-package by looking for `packages/<name>/package.json` (or via `pnpm -r --filter ${YOUR_PACKAGE_NAME} test`)\n- run `pnpm --filter @<scope>/<name> test <pattern>` for one sub-package only\n- if a top-level test script is genuinely needed across multiple packages, prefix with `PEAKS_FULL_TEST=1` AND justify in the final report\n\nA repo without `pnpm-workspace.yaml` has no monorepo block; the pre-rid static template applies unchanged.";
 /**
  * Slice 2026-07-29-dispatch-stall-governance / S5 (AC-4.1 / AC-4.2) —
  * pure scope classifier. Returns a typed result so callers (the

package/dist/services/dispatch/test-tool-detection.js

@@ -54,28 +54,6 @@ If unsure which framework the consumer project uses, run \`peaks test --json\` f
 export function formatTestToolDetection() {
     return TEST_TOOL_DETECTION_BLOCK;
 }
-/**
- * Slice 4.0.7-dogfood-PR-9: optional monorepo block prepended when
- * `<projectRoot>/pnpm-workspace.yaml` exists. The pre-rid static
- * template did not mention monorepos at all, so sub-agents on a
- * monorepo project (e.g. ice-cola, 4 packages) ran `pnpm test` which
- * fanned out to every sub-package — a 36-minute wall clock for what
- * was a single-slice change. The block tells the sub-agent to scope
- * to a single sub-package via `pnpm -r --filter @scope/name test`
- * and to detect the layout via `peaks test --json` first.
- *
- * The block is empty when the project is not a monorepo, so the
- * single-package case is byte-identical to the pre-rid prompt.
- */
-export const MONOREPO_TEST_TOOL_BLOCK = `## Monorepo Test Tool Detection (only when pnpm-workspace.yaml exists)
-
-When \`<projectRoot>/pnpm-workspace.yaml\` is present, the project is a pnpm monorepo. The root \`package.json#scripts.test\` is typically \`pnpm -r test\` (recursive across all packages) and \`pnpm test\` from the root will fan out to every sub-package. **Do not run that.** Scope to a single sub-package:
-
-- detect the active sub-package by looking for \`packages/<name>/package.json\` (or via \`pnpm -r --filter \${YOUR_PACKAGE_NAME} test\`)
-- run \`pnpm --filter @<scope>/<name> test <pattern>\` for one sub-package only
-- if a top-level test script is genuinely needed across multiple packages, prefix with \`PEAKS_FULL_TEST=1\` AND justify in the final report
-
-A repo without \`pnpm-workspace.yaml\` has no monorepo block; the pre-rid static template applies unchanged.`;
 export function classifyTestCommand(command, env = process.env) {
     if (typeof command !== 'string') {
         return {

package/dist/services/doctor/doctor-service/checks/skill-presence.d.ts

@@ -2,6 +2,14 @@
  * Check: skill presence current + freshness
  * (`skill-presence:current` and `skill-presence:freshness`).
  *
+ * Slice 4.0.8 (RD §3 + §4 D3): the diagnostic also surfaces
+ * stale / lost / broken-graph leases by running a `dry-run` GC
+ * summary through `gcStalePresenceLeases`. The summary carries
+ * `removed` / `retained` counts plus per-lease warnings (typed
+ * `PEAKS_GRAPH_REF_BROKEN`, `PEAKS_GRAPH_CORRUPTED`); the doctor
+ * surfaces them so the operator can run `peaks workspace reconcile`
+ * to repair.
+ *
  * Two checks sharing one read of the `presence` context field.
  *   - `skill-presence:current` is informational: passes when the
  *     presence is wired, with a message describing the active

package/dist/services/doctor/doctor-service/checks/skill-presence.js

@@ -2,6 +2,14 @@
  * Check: skill presence current + freshness
  * (`skill-presence:current` and `skill-presence:freshness`).
  *
+ * Slice 4.0.8 (RD §3 + §4 D3): the diagnostic also surfaces
+ * stale / lost / broken-graph leases by running a `dry-run` GC
+ * summary through `gcStalePresenceLeases`. The summary carries
+ * `removed` / `retained` counts plus per-lease warnings (typed
+ * `PEAKS_GRAPH_REF_BROKEN`, `PEAKS_GRAPH_CORRUPTED`); the doctor
+ * surfaces them so the operator can run `peaks workspace reconcile`
+ * to repair.
+ *
  * Two checks sharing one read of the `presence` context field.
  *   - `skill-presence:current` is informational: passes when the
  *     presence is wired, with a message describing the active
@@ -56,7 +64,7 @@ function run({ options, presence }) {
             checks.push({
                 id: 'skill-presence:freshness',
                 ok: false,
-                message: `Skill presence ${presence.skill} is stale (set ${presence.setAt}, ~${ageHours}h ago); run peaks skill presence:clear if the role has ended`
+                message: `Skill presence ${presence.skill} is stale (set ${presence.setAt}, ~${ageHours}h ago); run peaks skill presence:clear if the role has ended, or \`peaks skill lease gc\` to drain the canonical lease`
             });
         }
         else {

package/dist/services/hooks/presence-marker-detector.d.ts

@@ -12,5 +12,11 @@ export type PresenceMarkerWarning = (typeof PRESENCE_MARKER_WARNING)[number];
 export declare const PRESENCE_MARKER_WARNING: readonly ["Peaks skill context may have been lost from this conversation; please re-invoke /peaks-<skill>."];
 /**
  * Pure read-only presence-marker detection. No I/O side effects.
+ *
+ * Slice 4.0.8: the canonical 4.0.7 behavior is preserved (read legacy
+ * `active-skill.json` or `.peaks/.active-skill.json`, project the
+ * `Peaks-Loop Skill:` marker). The new diagnostic for a broken
+ * canonical graph is surfaced via the `warning` field, NOT swallowed,
+ * so the statusline / hook / doctor consumers can render it.
  */
 export declare function detectPresenceMarker(input: DetectPresenceMarkerInput): DetectPresenceMarkerResult;