peaks-loop 4.0.10 → 4.0.12

package/dist/services/code/orchestrator-can-do.js

@@ -0,0 +1,205 @@
+/**
+ * Slice 2026-08-05-orchestrator-can-do-probe — service layer for
+ * `peaks code orchestrator-can-do`.
+ *
+ * Encodes the 2026-08-05 lesson (`.peaks/memory/2026-08-05-peaks-code-
+ * orchestrator-capability-misjudgment.md`): the peaks-code orchestrator
+ * MUST NOT Edit/Write `src/` files directly, but MUST delegate via
+ * `peaks sub-agent dispatch`. The decision "can this slice run in the
+ * current session" must be a structured probe — not a vibes call.
+ *
+ * The probe answers 4 boundary questions:
+ *   Q1 — Is the change to source code? (keywords: src/, *.ts, *.tsx,
+ *        *.js, package.json, tsconfig, workflows/). If yes → NOT a
+ *        blocker; orchestrator delegates to sub-agent.
+ *   Q2 — Can a sub-agent be dispatched? (probe `peaks sub-agent
+ *        dispatch --role rd --help`). If no → blocker.
+ *   Q3 — Does the slice require user decisions? (keywords: design,
+ *        decide, ?, 选择, 决定). If yes → soft warning, NOT a blocker
+ *        (the LLM should AskUserQuestion, which is cheap).
+ *   Q4 — Is context usage sustainable? (probe `peaks code context-now
+ *        --json`). ratio ≥ 0.95 → blocker (red-line); ≥ 0.85 →
+ *        blocker (auto-compact-now).
+ *
+ * Decision rule:
+ *   canDoInSession === (blockers.length === 0)
+ *
+ * Concrete suggestion when canDoInSession=true and slice touches
+ * source code:
+ *   `peaks sub-agent dispatch rd --prompt "<slice-spec>" --request-id
+ *   <rid> --project . --batch-id <uuid>`
+ *
+ * Pure-function module. The CLI shim (code-orchestrator-can-do.ts)
+ * adapts the envelope into the program's `ResultEnvelope<T>` shape.
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { randomUUID } from 'node:crypto';
+const execFileAsync = promisify(execFile);
+/** Slice 2026-08-05-orchestrator-can-do-probe: red-line threshold. */
+export const ORCHESTRATOR_REDLINE_RATIO = 0.95;
+/** Slice 2026-08-05-orchestrator-can-do-probe: pre-compact threshold. */
+export const ORCHESTRATOR_PRECOMPACT_RATIO = 0.85;
+/** Source-code keywords that signal "do NOT Edit/Write directly". */
+export const SOURCE_CODE_KEYWORDS = [
+    'src/',
+    'source/',
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    'package.json',
+    'tsconfig',
+    'workflows/',
+    '.py',
+    '.go',
+    '.rs',
+];
+/** Decision-marker keywords that signal "needs user AskUserQuestion". */
+export const DECISION_KEYWORDS = [
+    'design',
+    'decide',
+    'choose',
+    '?',
+    '选择',
+    '决定',
+    'design decision',
+    'user choice',
+];
+export class OrchestratorCanDoError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'OrchestratorCanDoError';
+    }
+}
+/**
+ * Q1: does the slice touch source code? Pure keyword scan over
+ * the slice-spec string. Case-insensitive substring match.
+ */
+export function detectSourceCodeTouched(sliceSpec) {
+    const lower = sliceSpec.toLowerCase();
+    return SOURCE_CODE_KEYWORDS.some((kw) => lower.includes(kw.toLowerCase()));
+}
+/**
+ * Q3: does the slice require user decisions? Pure keyword scan
+ * over the slice-spec string.
+ */
+export function detectRequiresUserDecision(sliceSpec) {
+    const lower = sliceSpec.toLowerCase();
+    return DECISION_KEYWORDS.some((kw) => lower.includes(kw.toLowerCase()));
+}
+/**
+ * Q2: probe `peaks sub-agent dispatch --role rd --help`. Returns
+ * true when the subprocess exits 0. Resolves to false on spawn
+ * failure or non-zero exit.
+ */
+export async function probeSubAgentAvailable(projectRoot, peaksBin = 'peaks') {
+    try {
+        await execFileAsync(peaksBin, ['sub-agent', 'dispatch', '--role', 'rd', '--help'], {
+            cwd: projectRoot,
+            timeout: 5000,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Q4: probe `peaks code context-now --json`. Parses the data.ratio
+ * field. Falls back to {ratio: 0, source: 'unavailable'} when the
+ * subprocess fails or returns malformed JSON.
+ */
+export async function probeContextRatio(projectRoot, peaksBin = 'peaks') {
+    try {
+        const { stdout } = await execFileAsync(peaksBin, ['code', 'context-now', '--project', projectRoot, '--json'], {
+            cwd: projectRoot,
+            timeout: 10000,
+        });
+        const parsed = JSON.parse(stdout);
+        const ratio = typeof parsed.data?.ratio === 'number' ? parsed.data.ratio : 0;
+        const source = typeof parsed.data?.source === 'string' ? parsed.data.source : 'unavailable';
+        return { ratio, source };
+    }
+    catch {
+        return { ratio: 0, source: 'unavailable' };
+    }
+}
+/**
+ * Build the structured OrchestratorCanDoResult. Pure over the 4 Q
+ * signals + sliceSpec. Decision rule is: canDoInSession === !blockers.
+ */
+export function buildOrchestratorCanDoResult(input, signals) {
+    const blockers = [];
+    const warnings = [];
+    const suggestions = [];
+    // Q2 — sub-agent availability is a hard precondition.
+    if (!signals.q2SubAgentAvailable) {
+        blockers.push('sub-agent dispatch unavailable (peaks sub-agent dispatch --help failed)');
+        suggestions.push('verify peaks CLI is on PATH; check `peaks --version`');
+    }
+    // Q4 — context ratio gate. ≥0.95 → red-line; ≥0.85 → pre-compact.
+    if (signals.q4ContextRatio >= ORCHESTRATOR_REDLINE_RATIO) {
+        blockers.push(`context red-line (ratio=${signals.q4ContextRatio.toFixed(2)} ≥ ${ORCHESTRATOR_REDLINE_RATIO}); auto-compact now or push to next session`);
+        suggestions.push('peaks compact auto --execute');
+    }
+    else if (signals.q4ContextRatio >= ORCHESTRATOR_PRECOMPACT_RATIO) {
+        blockers.push(`context near limit (ratio=${signals.q4ContextRatio.toFixed(2)} ≥ ${ORCHESTRATOR_PRECOMPACT_RATIO}); auto-compact or push to next session`);
+        suggestions.push('peaks compact auto --execute');
+    }
+    // Q3 — user-decision keywords → soft warning, NOT a blocker. The
+    // LLM should AskUserQuestion, which is cheap.
+    if (signals.q3RequiresUserDecision) {
+        warnings.push('slice-spec contains decision keywords; AskUserQuestion before proceeding');
+    }
+    // Q1 — source-code touched is NOT a blocker. The orchestrator
+    // delegates via sub-agent dispatch.
+    if (signals.q1SourceCodeTouched && signals.q2SubAgentAvailable) {
+        const batchId = randomUUID();
+        const rid = 'rid-' + Date.now().toString(36);
+        suggestions.push(`peaks sub-agent dispatch rd --prompt "<slice-spec>" --request-id ${rid} --project ${input.projectRoot} --batch-id ${batchId}`);
+    }
+    // When canDoInSession=true and there's no source code touched,
+    // surface a generic "do it" suggestion.
+    const canDoInSession = blockers.length === 0;
+    if (canDoInSession && !signals.q1SourceCodeTouched) {
+        suggestions.push(`non-source-code slice; orchestrator may handle in-session (e.g. via Write/Edit tools or directly)`);
+    }
+    return {
+        canDoInSession,
+        blockers,
+        warnings,
+        suggestions,
+        contextRatio: signals.q4ContextRatio,
+        subAgentAvailable: signals.q2SubAgentAvailable,
+        q1SourceCodeTouched: signals.q1SourceCodeTouched,
+        q2SubAgentAvailable: signals.q2SubAgentAvailable,
+        q3RequiresUserDecision: signals.q3RequiresUserDecision,
+        q4ContextRatio: signals.q4ContextRatio,
+    };
+}
+/**
+ * Evaluate a slice-spec end-to-end. Probes Q2/Q4 via subprocess
+ * (overridable via test seams in `input`). Q1/Q3 are pure.
+ */
+export async function evaluateOrchestratorCanDo(input) {
+    if (!input.sliceSpec || input.sliceSpec.trim().length === 0) {
+        throw new OrchestratorCanDoError('--slice-spec is required', 'MISSING_SLICE_SPEC');
+    }
+    const q1SourceCodeTouched = detectSourceCodeTouched(input.sliceSpec);
+    const q3RequiresUserDecision = detectRequiresUserDecision(input.sliceSpec);
+    const probeSubAgent = input.probeSubAgentAvailable ?? (() => probeSubAgentAvailable(input.projectRoot));
+    const probeContext = input.probeContextRatio ?? (() => probeContextRatio(input.projectRoot));
+    const [subAgentAvailable, ctxProbe] = await Promise.all([
+        probeSubAgent(),
+        probeContext(),
+    ]);
+    return buildOrchestratorCanDoResult(input, {
+        q1SourceCodeTouched,
+        q2SubAgentAvailable: subAgentAvailable,
+        q3RequiresUserDecision,
+        q4ContextRatio: ctxProbe.ratio,
+    });
+}

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

@@ -33,7 +33,7 @@ function run({ options, presence }) {
             {
                 id: 'skill-presence:current',
                 ok: true,
-                message: 'No active Peaks skill presence (.peaks/.active-skill.json absent or invalid)'
+                message: 'No active Peaks skill presence (no canonical lease under .peaks/_runtime/<sid>/leases/)'
             },
             {
                 id: 'skill-presence:freshness',

package/dist/services/doctor/doctor-service/checks/workspace-layout.d.ts

@@ -4,8 +4,10 @@
  *
  * Build-hygiene check that surfaces any leftover top-level session
  * dirs (`.peaks/<YYYY-MM-DD-session-<hex>>/`), the legacy runtime
- * dotfiles (`.peaks/.session.json`, `.peaks/.active-skill.json`),
- * OR per-change-id top-level dirs (`.peaks/NNN-YYYY-MM-DD-<slug>/`).
+ * dotfiles (`.peaks/.session.json`), the stale single-slot
+ * presence file (`.peaks/_runtime/active-skill.json`, the deprecated
+ * project-level marker removed in slice 4.0.11), OR per-change-id
+ * top-level dirs (`.peaks/NNN-YYYY-MM-DD-<slug>/`).
  *
  * The post-F3 canonical layout puts session dirs under
  * `.peaks/_runtime/<sid>/` and the runtime binding at
@@ -29,5 +31,6 @@ export declare function inspectWorkspaceLayout(opts: {
     topLevelScanner?: (root: string) => string[];
     dotfileScanner?: (root: string) => string[];
     perChangeIdScanner?: (root: string) => string[];
+    staleSingleSlotScanner?: (root: string) => string[];
 }): WorkspaceLayoutInspection;
 export declare const check: DoctorCheckPlugin;

package/dist/services/doctor/doctor-service/checks/workspace-layout.js

@@ -4,8 +4,10 @@
  *
  * Build-hygiene check that surfaces any leftover top-level session
  * dirs (`.peaks/<YYYY-MM-DD-session-<hex>>/`), the legacy runtime
- * dotfiles (`.peaks/.session.json`, `.peaks/.active-skill.json`),
- * OR per-change-id top-level dirs (`.peaks/NNN-YYYY-MM-DD-<slug>/`).
+ * dotfiles (`.peaks/.session.json`), the stale single-slot
+ * presence file (`.peaks/_runtime/active-skill.json`, the deprecated
+ * project-level marker removed in slice 4.0.11), OR per-change-id
+ * top-level dirs (`.peaks/NNN-YYYY-MM-DD-<slug>/`).
  *
  * The post-F3 canonical layout puts session dirs under
  * `.peaks/_runtime/<sid>/` and the runtime binding at
@@ -31,7 +33,24 @@ const SESSION_DIR_PATTERN = /^\d{4}-\d{2}-\d{2}-session-[a-f0-9]+$/;
  * `0NN-session-...`, `YYYY-MM-DD-session-...`).
  */
 const PER_CHANGE_ID_PATTERN = /^\d{3}-\d{4}-\d{2}-\d{2}-[a-z][a-z0-9-]*[a-z0-9]$/;
-const LEGACY_DOTFILES = ['.session.json', '.active-skill.json'];
+// Slice 4.0.11 statusline-sid-scoped-lease C: `.peaks/.active-skill.json`
+// is REMOVED from LEGACY_DOTFILES (the file should not exist on
+// healthy post-4.0.11 projects; treating it as a generic legacy
+// dotfile is misleading). The new single-slot presence file
+// `.peaks/_runtime/active-skill.json` is reported separately under
+// `STALE_SINGLE_SLOT_FILES` so the operator gets a clear "stale
+// single-slot presence" message instead of a generic legacy warning.
+const LEGACY_DOTFILES = ['.session.json'];
+// Top-level single-slot presence files that are stale after the
+// sid-scoped lease projection (slice 4.0.8) shipped. Reported
+// separately from LEGACY_DOTFILES so the doctor message names the
+// specific issue ("stale single-slot presence") and the operator
+// can delete the file. The canonical sid-scoped lease at
+// `.peaks/_runtime/<sid>/leases/presence-*.json` is the source of truth.
+const STALE_SINGLE_SLOT_FILES = [
+    'active-skill.json',
+    '.active-skill.json'
+];
 /**
  * Pure helper that inspects the on-disk workspace layout for
  * post-F3-canonical violations. Exported so tests can drive the
@@ -42,10 +61,12 @@ export function inspectWorkspaceLayout(opts) {
     const topLevel = opts.topLevelScanner ?? defaultTopLevelSessionDirScanner;
     const dotfiles = opts.dotfileScanner ?? defaultLegacyDotfileScanner;
     const perChangeId = opts.perChangeIdScanner ?? defaultPerChangeIdDirScanner;
+    const staleSingleSlot = opts.staleSingleSlotScanner ?? defaultStaleSingleSlotScanner;
     return {
         topLevelSessionDirs: safeList(() => topLevel(opts.projectRoot)),
         legacyDotfiles: safeList(() => dotfiles(opts.projectRoot)),
-        perChangeIdDirs: safeList(() => perChangeId(opts.projectRoot))
+        perChangeIdDirs: safeList(() => perChangeId(opts.projectRoot)),
+        staleSingleSlotFiles: safeList(() => staleSingleSlot(opts.projectRoot))
     };
 }
 function safeList(reader) {
@@ -103,6 +124,39 @@ function defaultLegacyDotfileScanner(projectRoot) {
     }
     return offenders;
 }
+/**
+ * Slice 4.0.11 statusline-sid-scoped-lease C: surface the deprecated
+ * single-slot presence files (`.peaks/_runtime/active-skill.json` and
+ * the legacy `.peaks/.active-skill.json`) as a separate offender
+ * category. The canonical sid-scoped lease projection
+ * (`.peaks/_runtime/<sid>/leases/presence-*.json`) is the source of
+ * truth; these single-slot files should be deleted so the doctor
+ * report is clean.
+ *
+ * The reported path is the project-relative form so the doctor's
+ * human-readable output stays consistent with `legacyDotfiles`.
+ */
+function defaultStaleSingleSlotScanner(projectRoot) {
+    const offenders = [];
+    const candidates = [
+        join(projectRoot, '.peaks', '_runtime', 'active-skill.json'),
+        join(projectRoot, '.peaks', '.active-skill.json')
+    ];
+    const reported = [
+        join('.peaks', '_runtime', 'active-skill.json'),
+        join('.peaks', '.active-skill.json')
+    ];
+    for (let i = 0; i < candidates.length; i++) {
+        const candidate = candidates[i];
+        const reportedPath = reported[i];
+        if (candidate === undefined || reportedPath === undefined)
+            continue;
+        if (existsSync(candidate)) {
+            offenders.push(reportedPath);
+        }
+    }
+    return offenders;
+}
 function defaultPerChangeIdDirScanner(projectRoot) {
     const peaksRoot = join(projectRoot, '.peaks');
     if (!existsSync(peaksRoot))
@@ -136,7 +190,7 @@ function defaultPerChangeIdDirScanner(projectRoot) {
 function defaultWorkspaceLayoutProbe(projectRootResolver) {
     const projectRoot = projectRootResolver();
     if (projectRoot === null) {
-        return { topLevelSessionDirs: [], legacyDotfiles: [], perChangeIdDirs: [] };
+        return { topLevelSessionDirs: [], legacyDotfiles: [], perChangeIdDirs: [], staleSingleSlotFiles: [] };
     }
     return inspectWorkspaceLayout({ projectRoot });
 }
@@ -148,22 +202,29 @@ function run({ options, projectRootResolver }) {
         // return a 2-field shape (no perChangeIdDirs). Treat missing
         // field as empty.
         const perChangeIdDirs = layout.perChangeIdDirs ?? [];
-        if (layout.topLevelSessionDirs.length === 0 && layout.legacyDotfiles.length === 0 && perChangeIdDirs.length === 0) {
+        // Slice 4.0.11: probes injected by pre-4.0.11 tests also omit
+        // staleSingleSlotFiles. Treat missing field as empty.
+        const staleSingleSlotFiles = layout.staleSingleSlotFiles ?? [];
+        if (layout.topLevelSessionDirs.length === 0 &&
+            layout.legacyDotfiles.length === 0 &&
+            perChangeIdDirs.length === 0 &&
+            staleSingleSlotFiles.length === 0) {
             return [{
                     id: 'build:workspace-layout-canonical',
                     ok: true,
-                    message: 'Workspace layout is canonical: no top-level session dirs, no legacy runtime dotfiles, no per-change-id top-level dirs'
+                    message: 'Workspace layout is canonical: no top-level session dirs, no legacy runtime dotfiles, no per-change-id top-level dirs, no stale single-slot presence files'
                 }];
         }
         const offenders = [
             ...layout.topLevelSessionDirs.map((p) => `top-level session dir: ${p}`),
             ...layout.legacyDotfiles.map((p) => `legacy dotfile: ${p}`),
-            ...perChangeIdDirs.map((p) => `per-change-id top-level dir: ${p}`)
+            ...perChangeIdDirs.map((p) => `per-change-id top-level dir: ${p}`),
+            ...staleSingleSlotFiles.map((p) => `stale single-slot presence: ${p}`)
         ];
         return [{
                 id: 'build:workspace-layout-canonical',
                 ok: false,
-                message: `Workspace layout is not canonical. Offenders: ${offenders.join('; ')}. Run \`peaks workspace migrate --to-runtime --project <repo> --apply\` to consolidate.`
+                message: `Workspace layout is not canonical. Offenders: ${offenders.join('; ')}. Run \`peaks workspace migrate --to-runtime --project <repo> --apply\` to consolidate; delete stale single-slot presence files manually after migration.`
             }];
     }
     catch (error) {

package/dist/services/doctor/doctor-service/types.d.ts

@@ -55,6 +55,15 @@ export type WorkspaceLayoutInspection = {
      * to an empty array when the field is missing.
      */
     perChangeIdDirs?: string[];
+    /**
+     * Slice 4.0.11 statusline-sid-scoped-lease C — single-slot
+     * presence files that are stale after the sid-scoped lease
+     * projection shipped in 4.0.8. Reported separately from
+     * `legacyDotfiles` so the doctor message names the specific
+     * "stale single-slot presence" condition. Optional for back-compat
+     * with probes injected by older tests.
+     */
+    staleSingleSlotFiles?: string[];
 };
 export type WorkspaceLayoutProbe = () => WorkspaceLayoutInspection;
 /**

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

@@ -13,10 +13,12 @@ export declare const PRESENCE_MARKER_WARNING: readonly ["Peaks skill context may
 /**
  * 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.
+ * Slice 4.0.11 statusline-sid-scoped-lease C: the deprecated
+ * `.peaks/_runtime/active-skill.json` (and legacy
+ * `.peaks/.active-skill.json`) read paths are removed. The
+ * canonical sid-scoped lease projection at
+ * `.peaks/_runtime/<sid>/leases/presence-*.json` is the only source.
+ * The `warning` field is preserved for downstream consumers
+ * (statusline, doctor, hooks).
  */
 export declare function detectPresenceMarker(input: DetectPresenceMarkerInput): DetectPresenceMarkerResult;

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

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { getSessionId } from '../session/session-manager.js';
+import { listPresenceLeases } from '../skills/presence-lease-service.js';
 /**
  * Slice 028 (Q1=A): hook-based skill-presence marker detection.
  *
@@ -17,7 +17,7 @@ import { resolve } from 'node:path';
  * `detectPresenceMarker({ project, latestAssistantMessage })`
  * and gets back:
  *
- *   - `active`:      whether an active-skill marker was found on disk.
+ *   - `active`:      whether an active lease was found on disk.
  *   - `skill?`:      the active skill name, if any.
  *   - `markerFound`: whether the latest assistant message carries the
  *                    expected `Peaks-Loop Skill:` / `Peaks-Loop Gate:`
@@ -30,94 +30,52 @@ import { resolve } from 'node:path';
  * expected to provide the absolute project root (peaks-loop convention
  * from the standards-commands family — see dev-preference rule
  * `project-option-is-canonical-project-root-source`).
+ *
+ * Slice 4.0.11 statusline-sid-scoped-lease C: the deprecated
+ * project-level `active-skill.json` single-slot file is REMOVED
+ * from this module. The canonical sid-scoped lease projection
+ * (`.peaks/_runtime/<sid>/leases/presence-*.json`) is the only
+ * source of truth; no legacy fallback is retained.
  */
-const PRESENCE_CANONICAL_PATH = '.peaks/_runtime/active-skill.json';
-const PRESENCE_LEGACY_PATH = '.peaks/.active-skill.json';
 const MARKER_PRIMARY = 'Peaks-Loop Skill:';
 const MARKER_SECONDARY = 'Peaks-Loop Gate:';
-const SKILL_NAME_RE = /"skill"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/;
 export const PRESENCE_MARKER_WARNING = [
     'Peaks skill context may have been lost from this conversation; please re-invoke /peaks-<skill>.'
 ];
-function readPresenceFile(absolutePath) {
-    if (!existsSync(absolutePath))
-        return null;
-    let raw;
-    try {
-        raw = readFileSync(absolutePath, 'utf8');
-    }
-    catch (err) { // TODO(g2): legacy silent catch — now narrows to IO errors only (grace: 1 minor release, v2.14.0)
-        if (err instanceof ReferenceError)
-            throw err; // surface module-load bugs
-        if (err instanceof SyntaxError)
-            throw err; // surface parse bugs
-        return null; // only swallow IO errors
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (err) { // TODO(g2): legacy silent catch — now narrows to IO errors only (grace: 1 minor release, v2.14.0)
-        if (err instanceof ReferenceError)
-            throw err; // surface module-load bugs
-        if (err instanceof SyntaxError)
-            throw err; // surface parse bugs
-        return null; // only swallow IO errors
-    }
-    if (parsed === null || typeof parsed !== 'object')
+/**
+ * Slice 4.0.11 statusline-sid-scoped-lease C: read the canonical
+ * sid-scoped lease projection. Returns the in-flight lease with the
+ * most recent `lastHeartbeat`, or null when no leases exist for the
+ * bound session. Picked the most-recent-in-flight lease (mirrors the
+ * statusline `callerId === null` back-compat path).
+ */
+function readCanonicalLease(projectRoot) {
+    const sessionId = getSessionId(projectRoot);
+    if (sessionId === null)
         return null;
-    const skillMatch = SKILL_NAME_RE.exec(JSON.stringify(parsed));
-    if (skillMatch === null)
+    const leases = listPresenceLeases(projectRoot, sessionId);
+    const inFlight = leases.filter((l) => l.status === 'running' || l.status === 'preparing');
+    if (inFlight.length === 0)
         return null;
-    if (typeof skillMatch[1] !== 'string' || skillMatch[1].length === 0)
+    // Sort by lastHeartbeat desc, return the freshest.
+    inFlight.sort((a, b) => b.lastHeartbeat.localeCompare(a.lastHeartbeat));
+    const freshest = inFlight[0];
+    if (freshest === undefined)
         return null;
-    return { skill: skillMatch[1] };
+    return { skill: freshest.skill };
 }
 /**
- * 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.
+ * Slice 4.0.11 statusline-sid-scoped-lease C: the deprecated
+ * broken-graph diagnostic walked the legacy `active-skill.json`
+ * `graphRef` field. The canonical lease projection surfaces broken
+ * graphs as a typed `PEAKS_GRAPH_REF_BROKEN` lease status at read
+ * time (see `presence-lease-service.readJsonStrict`), so a separate
+ * diagnostic walk is no longer needed. Kept as a no-op for the
+ * public-surface stability of `detectPresenceMarker` (the warning
+ * field shape stays the same); returns null unless the canonical
+ * graph lookup is wired in a future slice.
  */
-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);
-    const legacyPath = resolve(projectRoot, PRESENCE_LEGACY_PATH);
-    for (const candidate of [canonicalPath, legacyPath]) {
-        const parsed = readPresenceFile(candidate);
-        if (parsed === null)
-            continue;
-        return { skill: parsed.skill, path: candidate };
-    }
+function tryDetectBrokenGraph(_projectRoot) {
     return null;
 }
 function messageHasMarker(message) {
@@ -128,16 +86,18 @@ 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.
+ * Slice 4.0.11 statusline-sid-scoped-lease C: the deprecated
+ * `.peaks/_runtime/active-skill.json` (and legacy
+ * `.peaks/.active-skill.json`) read paths are removed. The
+ * canonical sid-scoped lease projection at
+ * `.peaks/_runtime/<sid>/leases/presence-*.json` is the only source.
+ * The `warning` field is preserved for downstream consumers
+ * (statusline, doctor, hooks).
  */
 export function detectPresenceMarker(input) {
     const project = input.project;
     const message = input.latestAssistantMessage ?? '';
-    const presence = readPresenceBackCompat(project);
+    const presence = readCanonicalLease(project);
     if (presence === null) {
         return { active: false, markerFound: false };
     }

package/dist/services/migration/v2-10-to-v2-11-service.js

@@ -42,9 +42,7 @@ const SKIP_DIRS = new Set([
     'caller',
     'callers',
     'sop-state',
-    'system',
-    'active-skill.json',
-    '.active-skill.json'
+    'system'
 ]);
 const SESSION_DIR_RE = /^\d{4}-\d{2}-\d{2}-session-/;
 const TECH_DOC_MARKERS = ['## Architecture', '## Component', '## API', '## Dependencies'];