peaks-loop 4.0.6 → 4.0.8

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/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/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;

package/dist/services/hooks/presence-marker-detector.js

@@ -73,6 +73,41 @@ function readPresenceFile(absolutePath) {
         return null;
     return { skill: skillMatch[1] };
 }
+/**
+ * Slice 4.0.8: surface a typed `PEAKS_GRAPH_REF_BROKEN` warning
+ * when the canonical presence lease / index points at a missing or
+ * corrupt graph. The legacy `active-skill.json` walk never
+ * inspected graphRef; in 4.0.8 we surface the broken graph in the
+ * `warnings` array so downstream consumers (statusline, doctor,
+ * hooks) can render the diagnostic instead of silently rendering
+ * "active" for a half-wired presence.
+ */
+function tryDetectBrokenGraph(projectRoot) {
+    try {
+        const presenceIndexDir = resolve(projectRoot, '.peaks', '_runtime');
+        if (!existsSync(presenceIndexDir))
+            return null;
+        // Best-effort: walk a single directory level for the legacy
+        // `active-skill.json` indicator. A broken graphRef would be
+        // surfaced by the canonical lease service (PEAKS_GRAPH_REF_BROKEN
+        // is the typed error), but the marker detector is a *read* —
+        // we don't import the lease service here. The diagnostic is
+        // best-effort: we report the index file's `graphRef` field
+        // when it names a missing file.
+        const legacyPath = resolve(projectRoot, '.peaks', '_runtime', 'active-skill.json');
+        if (!existsSync(legacyPath))
+            return null;
+        const raw = readFileSync(legacyPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.graphRef !== 'string')
+            return null;
+        const graphPath = resolve(projectRoot, '.peaks', '_runtime', parsed.graphRef);
+        if (!existsSync(graphPath))
+            return 'PEAKS_GRAPH_REF_BROKEN';
+    }
+    catch { /* swallow — diagnostic only */ }
+    return null;
+}
 function readPresenceBackCompat(project) {
     const projectRoot = resolve(project);
     const canonicalPath = resolve(projectRoot, PRESENCE_CANONICAL_PATH);
@@ -92,6 +127,12 @@ function messageHasMarker(message) {
 }
 /**
  * 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 function detectPresenceMarker(input) {
     const project = input.project;
@@ -100,10 +141,17 @@ export function detectPresenceMarker(input) {
     if (presence === null) {
         return { active: false, markerFound: false };
     }
+    const brokenGraph = tryDetectBrokenGraph(project);
     const markerFound = messageHasMarker(message);
     if (markerFound) {
+        if (brokenGraph !== null) {
+            return { active: true, skill: presence.skill, markerFound: true, warning: `Peaks presence active but graph is broken (${brokenGraph}); run \`peaks workspace reconcile\` to repair.` };
+        }
         return { active: true, skill: presence.skill, markerFound: true };
     }
+    if (brokenGraph !== null) {
+        return { active: true, skill: presence.skill, markerFound: false, warning: `Peaks presence active but graph is broken (${brokenGraph}); run \`peaks workspace reconcile\` to repair.` };
+    }
     return {
         active: true,
         skill: presence.skill,

package/dist/services/ide/adapters/claude-code-adapter.js

@@ -100,4 +100,24 @@ export const CLAUDE_CODE_ADAPTER = {
         installStrategy: 'symlink',
         envVarOverride: 'PEAKS_CLAUDE_SKILLS_DIR',
     },
+    // Slice 4.0.8 RD §5: Claude Code resolves PEAKS_CALLER_ID (override) →
+    // CLAUDE_CODE_SESSION_ID. Empty/invalid → typed PEAKS_CALLER_NOT_RESOLVED.
+    resolveCallerId: (env) => {
+        const e = env ?? process.env;
+        const override = e.PEAKS_CALLER_ID;
+        if (typeof override === 'string' && override.trim().length > 0) {
+            const trimmed = override.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const v = e.CLAUDE_CODE_SESSION_ID;
+        if (typeof v === 'string' && v.trim().length > 0) {
+            const trimmed = v.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const err = new Error('PEAKS_CALLER_NOT_RESOLVED: no Claude Code session id available');
+        err.code = 'PEAKS_CALLER_NOT_RESOLVED';
+        throw err;
+    },
 };

package/dist/services/ide/adapters/codex-adapter.js

@@ -86,7 +86,26 @@ export const CODEX_ADAPTER = {
         // return a clear "not supported" stderr message (slice #008 P-5
         // capability-check contract preserved).
         statusline: false,
-    }
+    },
+    // Slice 4.0.8 RD §5: Codex vendor signal reserved; fail closed.
+    resolveCallerId: (env) => {
+        const e = env ?? process.env;
+        const override = e.PEAKS_CALLER_ID;
+        if (typeof override === 'string' && override.trim().length > 0) {
+            const trimmed = override.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const candidate = e.CODEX_SESSION_ID;
+        if (typeof candidate === 'string' && candidate.trim().length > 0) {
+            const trimmed = candidate.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const err = new Error('PEAKS_CALLER_NOT_RESOLVED: Codex vendor signal reserved');
+        err.code = 'PEAKS_CALLER_NOT_RESOLVED';
+        throw err;
+    },
     // Standards: UNVERIFIED — see slice #013+ (Codex real-install dogfood for
     // the `standardsProfile` and `skillInstall` fields). Until then, `peaks
     // standards init` on a Codex-detected project falls back to the Claude

package/dist/services/ide/adapters/cursor-adapter.js

@@ -73,7 +73,7 @@ export const CURSOR_ADAPTER = {
         // Cursor has a statusline UI (Cmd+Shift+P → "Cursor: Open Status Bar")
         // that can host peaks statusline output, so opt in to the capability.
         statusline: true,
-    }
+    },
     // Standards: UNVERIFIED — see slice #012+ (Cursor real-install dogfood for
     // the `standardsProfile` and `skillInstall` fields). Until then, `peaks
     // standards init` on a Cursor-detected project falls back to the Claude
@@ -81,4 +81,24 @@ export const CURSOR_ADAPTER = {
     // postinstall script writes skills + output-styles to the legacy
     // `~/.claude/{skills,output-styles}` paths with a stderr warning. Users
     // who want Cursor-specific paths must move the files manually.
+    // Slice 4.0.8 RD §5: Cursor vendor signal is unverified; reserve-only resolver.
+    resolveCallerId: (env) => {
+        const e = env ?? process.env;
+        const override = e.PEAKS_CALLER_ID;
+        if (typeof override === 'string' && override.trim().length > 0) {
+            const trimmed = override.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        // Reserved vendor variable (UNVERIFIED): do not synthesize project identity.
+        const candidate = e.CURSOR_SESSION_ID;
+        if (typeof candidate === 'string' && candidate.trim().length > 0) {
+            const trimmed = candidate.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const err = new Error('PEAKS_CALLER_NOT_RESOLVED: Cursor vendor signal unverified in 4.0.8');
+        err.code = 'PEAKS_CALLER_NOT_RESOLVED';
+        throw err;
+    },
 };

package/dist/services/ide/adapters/hermes-adapter.js

@@ -47,5 +47,24 @@ export const HERMES_ADAPTER = {
     capabilities: {
         gateEnforce: true,
         statusline: true
-    }
+    },
+    // Slice 4.0.8 RD §5: Hermes vendor signal unverified — fail closed.
+    resolveCallerId: (env) => {
+        const e = env ?? process.env;
+        const override = e.PEAKS_CALLER_ID;
+        if (typeof override === 'string' && override.trim().length > 0) {
+            const trimmed = override.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const candidate = e.HERMES_SESSION_ID;
+        if (typeof candidate === 'string' && candidate.trim().length > 0) {
+            const trimmed = candidate.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const err = new Error('PEAKS_CALLER_NOT_RESOLVED: Hermes vendor signal unverified');
+        err.code = 'PEAKS_CALLER_NOT_RESOLVED';
+        throw err;
+    },
 };

package/dist/services/ide/adapters/openclaw-adapter.js

@@ -38,5 +38,24 @@ export const OPENCLAW_ADAPTER = {
     capabilities: {
         gateEnforce: true,
         statusline: true
-    }
+    },
+    // Slice 4.0.8 RD §5: OpenClaw vendor signal unverified — fail closed.
+    resolveCallerId: (env) => {
+        const e = env ?? process.env;
+        const override = e.PEAKS_CALLER_ID;
+        if (typeof override === 'string' && override.trim().length > 0) {
+            const trimmed = override.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const candidate = e.OPENCLAW_SESSION_ID;
+        if (typeof candidate === 'string' && candidate.trim().length > 0) {
+            const trimmed = candidate.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const err = new Error('PEAKS_CALLER_NOT_RESOLVED: OpenClaw vendor signal unverified');
+        err.code = 'PEAKS_CALLER_NOT_RESOLVED';
+        throw err;
+    },
 };

package/dist/services/ide/adapters/qoder-adapter.js

@@ -53,5 +53,24 @@ export const QODER_ADAPTER = {
     capabilities: {
         gateEnforce: true,
         statusline: true
-    }
+    },
+    // Slice 4.0.8 RD §5: Qoder vendor signal unverified — fail closed.
+    resolveCallerId: (env) => {
+        const e = env ?? process.env;
+        const override = e.PEAKS_CALLER_ID;
+        if (typeof override === 'string' && override.trim().length > 0) {
+            const trimmed = override.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const candidate = e.QODER_SESSION_ID;
+        if (typeof candidate === 'string' && candidate.trim().length > 0) {
+            const trimmed = candidate.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const err = new Error('PEAKS_CALLER_NOT_RESOLVED: Qoder vendor signal unverified');
+        err.code = 'PEAKS_CALLER_NOT_RESOLVED';
+        throw err;
+    },
 };

package/dist/services/ide/adapters/tongyi-lingma-adapter.js

@@ -41,5 +41,24 @@ export const TONGYI_LINGMA_ADAPTER = {
     capabilities: {
         gateEnforce: true,
         statusline: true
-    }
+    },
+    // Slice 4.0.8 RD §5: Tongyi Lingma vendor signal unverified — fail closed.
+    resolveCallerId: (env) => {
+        const e = env ?? process.env;
+        const override = e.PEAKS_CALLER_ID;
+        if (typeof override === 'string' && override.trim().length > 0) {
+            const trimmed = override.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const candidate = e.TONGYI_LINGMA_SESSION_ID;
+        if (typeof candidate === 'string' && candidate.trim().length > 0) {
+            const trimmed = candidate.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const err = new Error('PEAKS_CALLER_NOT_RESOLVED: Tongyi Lingma vendor signal unverified');
+        err.code = 'PEAKS_CALLER_NOT_RESOLVED';
+        throw err;
+    },
 };

package/dist/services/ide/adapters/trae-adapter.js

@@ -71,7 +71,7 @@ export const TRAE_ADAPTER = {
     capabilities: {
         gateEnforce: true,
         statusline: true,
-    }
+    },
     // Standards: UNVERIFIED — see slice #012+ (Trae real-install dogfood for
     // the `standardsProfile` and `skillInstall` fields). The slice #011
     // framework lands; per-IDE values for Trae are a follow-up gated on
@@ -80,4 +80,24 @@ export const TRAE_ADAPTER = {
     // (CLAUDE.md + .claude/rules/**) with a stderr warning, and the
     // postinstall script writes skills + output-styles to the legacy
     // `~/.claude/{skills,output-styles}` paths with a stderr warning.
+    // Slice 4.0.8 RD §5: Trae resolves PEAKS_CALLER_ID (override) →
+    // TRAE_SESSION_ID. Empty/invalid → typed PEAKS_CALLER_NOT_RESOLVED.
+    resolveCallerId: (env) => {
+        const e = env ?? process.env;
+        const override = e.PEAKS_CALLER_ID;
+        if (typeof override === 'string' && override.trim().length > 0) {
+            const trimmed = override.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const v = e.TRAE_SESSION_ID;
+        if (typeof v === 'string' && v.trim().length > 0) {
+            const trimmed = v.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const err = new Error('PEAKS_CALLER_NOT_RESOLVED: no Trae session id available');
+        err.code = 'PEAKS_CALLER_NOT_RESOLVED';
+        throw err;
+    },
 };

package/dist/services/ide/adapters/zcode-adapter.js

@@ -217,4 +217,23 @@ export const ZCODE_ADAPTER = {
     // provider → first enabled → first provider). Returns undefined
     // on any failure (consistent with the cross-IDE contract).
     detectCurrentModel: detectZcodeCurrentModel,
+    // Slice 4.0.8 RD §5: z-code vendor signal unverified — fail closed.
+    resolveCallerId: (env) => {
+        const e = env ?? process.env;
+        const override = e.PEAKS_CALLER_ID;
+        if (typeof override === 'string' && override.trim().length > 0) {
+            const trimmed = override.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const candidate = e.ZCODE_SESSION_ID;
+        if (typeof candidate === 'string' && candidate.trim().length > 0) {
+            const trimmed = candidate.trim();
+            if (/^[a-zA-Z0-9._-]{1,200}$/.test(trimmed))
+                return trimmed;
+        }
+        const err = new Error('PEAKS_CALLER_NOT_RESOLVED: z-code vendor signal unverified');
+        err.code = 'PEAKS_CALLER_NOT_RESOLVED';
+        throw err;
+    },
 };