peaks-loop 4.0.7 → 4.0.9

package/dist/services/capability-guard-runner/runner.js

@@ -0,0 +1,22 @@
+function assertBaselineRef(contract) {
+    if (!contract.source.baselineRow || !contract.source.invariant) {
+        throw new Error('GUARD_CONTRACT_MISSING_BASELINE_REF: contract must reference a baseline row and invariant');
+    }
+}
+export async function runGuard(contract, ctx) {
+    assertBaselineRef(contract);
+    return contract.execute(ctx);
+}
+export async function runAllGuards(contracts, ctx) {
+    const results = [];
+    for (const c of contracts) {
+        results.push(await runGuard(c, ctx));
+    }
+    return {
+        pass: results.filter((r) => r.status === 'pass').length,
+        fail: results.filter((r) => r.status === 'fail').length,
+        skipped: results.filter((r) => r.status === 'skipped').length,
+        total: results.length,
+        results
+    };
+}

package/dist/services/capability-guard-runner/types.d.ts

@@ -0,0 +1,39 @@
+import type { JourneyId } from '../capability-baseline/types.js';
+export type ContractKind = 'cli-envelope' | 'workflow-trace' | 'hook-assertion' | 'cli-output-golden' | 'asset-roundtrip' | 'concurrency-lease' | 'sop-register' | 'spec-coverage' | 'envelope-arg-shapes';
+export interface GuardContract {
+    readonly journeyId: JourneyId;
+    readonly kind: ContractKind;
+    readonly source: {
+        readonly baselineRow: JourneyId;
+        readonly invariant: string;
+    };
+    readonly execute: (ctx: GuardContext) => Promise<GuardRunResult>;
+    readonly evidence: {
+        readonly kind: ContractKind;
+        readonly artifact: string;
+    };
+}
+export interface GuardContext {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+    readonly contract: GuardContract;
+    readonly baselineInvariant: string;
+}
+export type GuardStatus = 'pass' | 'fail' | 'skipped';
+export interface GuardDiff {
+    readonly before: string;
+    readonly after: string;
+    readonly reason: string;
+}
+export interface GuardRunResult {
+    readonly journeyId: JourneyId;
+    readonly contract: ContractKind;
+    readonly status: GuardStatus;
+    readonly diff?: GuardDiff;
+    readonly artifactPath: string;
+}
+export type GuardErrorCode = 'GUARD_CONTRACT_MISSING_BASELINE_REF' | 'GUARD_DIFF_DETECTED' | 'GUARD_TEST_FLAKY';
+export interface GuardError {
+    readonly code: GuardErrorCode;
+    readonly message: string;
+}

package/dist/services/capability-guard-runner/types.js

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

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 {