claude-code-session-manager 0.66.0 → 0.67.0

package/plugins/session-manager-dev/skills/develop/SKILL.md

@@ -210,11 +210,20 @@ can't load skills.
      separate PRDs into one oversized one; if the sub-task groups would each take real time on
      their own, that's a signal to split into a chain link instead of one bloated PRD.
 
+   **Preflight — confirm the tool is even in your tool list before you start composing PRDs.**
+   Check for `mcp__session-manager-scheduler__scheduler_create_prd` in your available tools as
+   the very first thing you do in this step, before any drafting — catching a missing tool here
+   costs nothing; catching it after you've already composed and written PRD bodies means
+   discarding that work. If it's absent, see "Two failure modes" immediately below — case (b),
+   not the reachable-but-erroring fallback.
+
    **`scheduler_create_prd` is the ONLY sanctioned way to author a PRD — not a preference, a
    rule.** Every PRD reaches disk through the MCP tool
    (`mcp__session-manager-scheduler__scheduler_create_prd`). Hand-writing the file directly is a
-   degraded, LAST-RESORT fallback (below) reserved for the single case where the tool itself is
-   unreachable — never a co-equal alternative to reach for out of habit or convenience. Its input
+   degraded, LAST-RESORT fallback (below) reserved for the single case where the tool is present
+   but errors as unreachable — never a co-equal alternative to reach for out of habit or
+   convenience, and never applicable when the tool isn't in your list at all (see "Two failure
+   modes" below). Its input
    (`title`, `cwd`, `estimateMinutes`, `goal`, `acceptanceCriteria[]`, `implementationNotes`,
    `outOfScope[]`) maps directly onto the sections below — pass them straight through. **Always
    pass `sourcePromptId` explicitly, set to the `<epic-id>` resolved in the Epic-gated step
@@ -227,18 +236,37 @@ can't load skills.
    `parallelGroup` is DEPRECATED and ignored — express ordering with the `dependsOn` input
    (slugs that must complete first); independent PRDs simply omit it and may run in parallel.
 
-   **Fallback — only when the tool errors with "app not running" / admin API unreachable**
-   (the session-manager Electron app must be running for this MCP tool to work; if it isn't,
-   don't block on it). This is a deliberate bypass of the service boundary, not a shortcut:
-   using it means the frontmatter validation, atomic `NN` allocation, standards-pointer
+   **Two failure modes — do not conflate them. They have opposite correct responses.**
+
+   - **(a) Tool PRESENT but ERRORS as "app not running" / admin API unreachable.** The tool
+     shows up in your tool list (`mcp__session-manager-scheduler__scheduler_create_prd` is
+     callable), but calling it fails because the session-manager Electron app that hosts the
+     admin API isn't running right now. This is the ONLY case the manual-write fallback below
+     covers. Do not use this path when the tool is reachable but merely returned a validation
+     error (bad frontmatter, unresolvable Epic, etc.) — fix the input and retry the tool; a
+     validation error is not "the app is not running."
+   - **(b) Tool ABSENT from your tool list entirely.** You never see
+     `mcp__session-manager-scheduler__scheduler_create_prd` offered at all — there is no error to
+     catch, because the tool call is never attempted. This means the `session-manager-scheduler`
+     MCP server is not registered for the project you're running against — a **misconfiguration**,
+     not "the app is offline." **STOP. Do not write any PRD file, hand-authored or otherwise.**
+     Report to the human, by name: "the `session-manager-scheduler` MCP tool is not available in
+     this session — the server isn't registered for this project." Point them at the fix: it
+     should be registered once at USER scope (`claude mcp add session-manager-scheduler --scope
+     user -- node <path-to-session-manager-repo>/scripts/scheduler-mcp-server.cjs`, or run
+     `scripts/install-scheduler-mcp-user-scope.sh` from the session-manager repo) so every
+     project gets the tool without a per-repo `.mcp.json` edit — do not work around a missing
+     tool by hand-writing the file, and do not add a project-local `.mcp.json` entry yourself as
+     a substitute; that's the human's call and re-introduces the per-repo drift this fix removes.
+
+   **Fallback for case (a) only.** This is a deliberate bypass of the service boundary, not a
+   shortcut: using it means the frontmatter validation, atomic `NN` allocation, standards-pointer
    insertion, and Epic-existence check that `scheduler_create_prd` normally performs did not
    run. **You MUST call this out, visibly, in your report** — state plainly that the app wasn't
    running, that you hand-authored the PRD file directly instead of using the tool, name the
    exact file, and flag it for human verification (this bypass is also what
    `scripts/audit-ops-hygiene.cjs` and the `ops-sweep` skill look for and report as a hygiene
-   finding, independent of your own report). Do not use this path when the tool is reachable but
-   merely returned a validation error (bad frontmatter, unresolvable Epic, etc.) — fix the input
-   and retry the tool; a validation error is not "the app is not running."
+   finding, independent of your own report).
    When you do use it: compute the highest in-use number deterministically yourself — never
    eyeball or narrow-grep the `ls` (a narrowed pattern like `'^10[0-9]'` silently misses `110+`
    and collides). PRDs are stored per-project, so `NN` allocation for a given PRD only needs
@@ -448,8 +476,10 @@ single definition of "tracked to done" for both entry paths.
 ## Notes
 
 - Submit each PRD through `scheduler_create_prd`, then confirm — don't draft them inline in chat
-  for review first, and don't hand-write the file yourself unless the tool is unreachable (app
-  not running); see the fallback note above, including its mandatory bypass warning.
+  for review first. Only hand-write the file when the tool is PRESENT but ERRORS as unreachable
+  (app not running) — see the "Two failure modes" note above, including its mandatory bypass
+  warning. If the tool is ABSENT from your tool list, that's a misconfiguration, not an offline
+  app: stop and tell the human, never hand-write the file.
 - Don't combine unrelated features into one PRD. One focused, completable unit each.
 - Don't add a `parallelGroup` frontmatter key — the filename `NN-` prefix drives grouping.
 - Don't write a PRD to `data/prds/`, `docs/prds/`, the project's own folder, or anywhere outside

package/src/main/__tests__/develop-skill-failure-modes.test.cjs

@@ -0,0 +1,70 @@
+/**
+ * develop-skill-failure-modes.test.cjs — drift guard for the two
+ * scheduler_create_prd failure-mode branches in the /develop skill.
+ *
+ * PRD 1024-1030 incident (2026-08-08): social-signals-trader's session
+ * hand-wrote 7 PRDs because scheduler_create_prd was ABSENT from its tool
+ * list (the project's .mcp.json didn't register the server yet) — not
+ * because the tool errored as unreachable. The old wording only named the
+ * "tool errors ... unreachable" case, which an absent tool never matches,
+ * so an agent in that situation had no documented path except hand-writing.
+ * This test asserts the fix (two named failure modes, with the absent-tool
+ * case explicitly forbidding hand-writing) is present and doesn't silently
+ * regress back to the single-case wording.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/develop-skill-failure-modes.test.cjs
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+import { test, expect } from 'vitest';
+
+const SKILL_MD = path.resolve(
+  __dirname,
+  '..',
+  '..',
+  '..',
+  'plugins',
+  'session-manager-dev',
+  'skills',
+  'develop',
+  'SKILL.md'
+);
+
+function readSkill() {
+  return fs.readFileSync(SKILL_MD, 'utf8');
+}
+
+test('SKILL.md names both failure modes explicitly', () => {
+  const text = readSkill();
+  expect(text).toMatch(/tool PRESENT but ERRORS/i);
+  expect(text).toMatch(/tool ABSENT from your tool list/i);
+});
+
+test('the absent-tool branch explicitly forbids hand-writing and says STOP', () => {
+  const text = readSkill();
+  const absentIdx = text.search(/tool ABSENT from your tool list/i);
+  expect(absentIdx).toBeGreaterThan(-1);
+  const nearby = text.slice(absentIdx, absentIdx + 1200);
+  expect(nearby).toMatch(/STOP/);
+  expect(nearby).toMatch(/[Dd]o not write any PRD file/);
+  expect(nearby).toMatch(/misconfiguration/i);
+});
+
+test('the present-but-erroring branch is the only one pointed at the manual-write fallback', () => {
+  const text = readSkill();
+  expect(text).toMatch(/Fallback for case \(a\) only/);
+});
+
+test('the standalone preflight check appears before PRD composition begins', () => {
+  const text = readSkill();
+  expect(text).toMatch(/Preflight — confirm the tool is even in your tool list/);
+});
+
+test('a preflight-tool-registration fix is named for the human (user-scope claude mcp add)', () => {
+  const text = readSkill();
+  expect(text).toMatch(/claude mcp add session-manager-scheduler --scope\s*\n?\s*user/);
+});

package/src/main/__tests__/health-per-project-stall.test.cjs

@@ -0,0 +1,82 @@
+/**
+ * health-per-project-stall.test.cjs — per-project problem-count rollup and
+ * per-project stall-past-threshold escalation for the scheduler_queue health
+ * check. Covers the gap where a project holding ONLY failed/needs_review/
+ * quarantined rows (0 running, 0 pending) never tripped evaluateTickLiveness
+ * (which requires actual pending work) — the exact way the burrow project's
+ * four quarantined PRDs went dark.
+ *
+ * Run: timeout 120 node --test src/main/__tests__/health-per-project-stall.test.cjs
+ */
+
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const {
+  computeProjectProblemCounts,
+  evaluatePerProjectStall,
+  TICK_STALL_THRESHOLD_MS,
+} = require('../health.cjs');
+const { computeStallSummary } = require('../scheduler.cjs');
+
+test('computeProjectProblemCounts: breaks down failed/needs_review/quarantined by project, ignores healthy statuses', () => {
+  const jobs = [
+    { slug: 'a', cwd: '/burrow', status: 'quarantined' },
+    { slug: 'b', cwd: '/burrow', status: 'quarantined' },
+    { slug: 'c', cwd: '/burrow', status: 'quarantined' },
+    { slug: 'd', cwd: '/burrow', status: 'quarantined' },
+    { slug: 'e', cwd: '/other', status: 'failed' },
+    { slug: 'f', cwd: '/other', status: 'needs_review' },
+    { slug: 'g', cwd: '/other', status: 'running' },
+    { slug: 'h', cwd: '/other', status: 'pending' },
+    { slug: 'i', cwd: '/other', status: 'completed' },
+  ];
+  const counts = computeProjectProblemCounts(jobs);
+  assert.deepStrictEqual(counts['/burrow'], { failed: 0, needs_review: 0, quarantined: 4 });
+  assert.deepStrictEqual(counts['/other'], { failed: 1, needs_review: 1, quarantined: 0 });
+});
+
+test('evaluatePerProjectStall: fully-stalled project past threshold flags pastThreshold=true', () => {
+  const state = {
+    lastRunAt: new Date(Date.now() - (TICK_STALL_THRESHOLD_MS + 60_000)).toISOString(),
+    paused: null,
+    jobs: [
+      { slug: 'a', cwd: '/burrow', status: 'quarantined' },
+      { slug: 'b', cwd: '/other', status: 'running' },
+    ],
+    invalidJobs: [],
+  };
+  const summary = computeStallSummary(state);
+  const result = evaluatePerProjectStall(summary, state.lastRunAt, Date.now(), TICK_STALL_THRESHOLD_MS);
+  assert.strictEqual(result['/burrow'].stalled, true);
+  assert.strictEqual(result['/burrow'].pastThreshold, true);
+  assert.strictEqual(result['/other'].stalled, false);
+});
+
+test('evaluatePerProjectStall: stalled but NOT yet past threshold flags pastThreshold=false', () => {
+  const state = {
+    lastRunAt: new Date(Date.now() - 1000).toISOString(), // just ticked
+    paused: null,
+    jobs: [{ slug: 'a', cwd: '/burrow', status: 'quarantined' }],
+    invalidJobs: [],
+  };
+  const summary = computeStallSummary(state);
+  const result = evaluatePerProjectStall(summary, state.lastRunAt, Date.now(), TICK_STALL_THRESHOLD_MS);
+  assert.strictEqual(result['/burrow'].stalled, true);
+  assert.strictEqual(result['/burrow'].pastThreshold, false);
+});
+
+test('evaluatePerProjectStall: no lastRunAt yet — stalled but not asserted past threshold (caveat, not a false RED)', () => {
+  const state = {
+    lastRunAt: null,
+    paused: null,
+    jobs: [{ slug: 'a', cwd: '/burrow', status: 'quarantined' }],
+    invalidJobs: [],
+  };
+  const summary = computeStallSummary(state);
+  const result = evaluatePerProjectStall(summary, state.lastRunAt, Date.now(), TICK_STALL_THRESHOLD_MS);
+  assert.strictEqual(result['/burrow'].stalled, true);
+  assert.strictEqual(result['/burrow'].pastThreshold, false);
+  assert.strictEqual(result['/burrow'].caveat, 'no-lastRunAt');
+});

package/src/main/__tests__/scheduler-stall-per-project.test.cjs

@@ -0,0 +1,108 @@
+/**
+ * scheduler-stall-per-project.test.cjs — unit tests for computeStallSummary's
+ * per-project `stalled` verdict and findStaleQuarantinedJobs' age-based
+ * escalation.
+ *
+ * Covers the exact burrow-vs-others shape observed live: one project (burrow)
+ * holds only quarantined rows (0 running, 0 pending) while another project
+ * has running + pending work — the machine-wide `stalled` boolean reads
+ * false (masking burrow), but burrow's own byProject entry must read true.
+ *
+ * Run: timeout 120 node --test src/main/__tests__/scheduler-stall-per-project.test.cjs
+ */
+
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { computeStallSummary, findStaleQuarantinedJobs, QUARANTINE_ESCALATE_MS } = require('../scheduler.cjs');
+
+test('computeStallSummary: burrow fully stalled (quarantined only) while another project is busy — machine-wide false, burrow true', () => {
+  const state = {
+    paused: null,
+    jobs: [
+      { slug: '821-a', cwd: '/home/bilko/Projects/burrow', status: 'quarantined' },
+      { slug: '822-b', cwd: '/home/bilko/Projects/burrow', status: 'quarantined' },
+      { slug: '823-c', cwd: '/home/bilko/Projects/burrow', status: 'quarantined' },
+      { slug: '824-d', cwd: '/home/bilko/Projects/burrow', status: 'quarantined' },
+      { slug: '900-e', cwd: '/home/bilko/Projects/other', status: 'running' },
+      { slug: '901-f', cwd: '/home/bilko/Projects/other', status: 'pending' },
+    ],
+    invalidJobs: [],
+  };
+  const summary = computeStallSummary(state);
+  assert.strictEqual(summary.stalled, false, 'machine-wide must NOT read stalled — other project is busy');
+  assert.strictEqual(summary.byProject['/home/bilko/Projects/burrow'].stalled, true, 'burrow must read stalled on its own');
+  assert.strictEqual(summary.byProject['/home/bilko/Projects/other'].stalled, false);
+});
+
+test('computeStallSummary: both projects busy — neither stalled', () => {
+  const state = {
+    paused: null,
+    jobs: [
+      { slug: 'a', cwd: '/p1', status: 'running' },
+      { slug: 'b', cwd: '/p2', status: 'pending' },
+    ],
+    invalidJobs: [],
+  };
+  const summary = computeStallSummary(state);
+  assert.strictEqual(summary.stalled, false);
+  assert.strictEqual(summary.byProject['/p1'].stalled, false);
+  assert.strictEqual(summary.byProject['/p2'].stalled, false);
+});
+
+test('computeStallSummary: both projects stalled — machine-wide AND both per-project read true', () => {
+  const state = {
+    paused: null,
+    jobs: [
+      { slug: 'a', cwd: '/p1', status: 'failed' },
+      { slug: 'b', cwd: '/p2', status: 'needs_review' },
+    ],
+    invalidJobs: [],
+  };
+  const summary = computeStallSummary(state);
+  assert.strictEqual(summary.stalled, true);
+  assert.strictEqual(summary.byProject['/p1'].stalled, true);
+  assert.strictEqual(summary.byProject['/p2'].stalled, true);
+});
+
+test('computeStallSummary: paused scheduler never reads stalled, machine-wide or per-project', () => {
+  const state = {
+    paused: { reason: 'rate_limit' },
+    jobs: [{ slug: 'a', cwd: '/p1', status: 'quarantined' }],
+    invalidJobs: [],
+  };
+  const summary = computeStallSummary(state);
+  assert.strictEqual(summary.stalled, false);
+  assert.strictEqual(summary.byProject['/p1'].stalled, false);
+});
+
+test('findStaleQuarantinedJobs: fires past threshold, not before', () => {
+  const now = Date.parse('2026-08-08T12:00:00.000Z');
+  const jobs = [
+    {
+      slug: 'fresh',
+      cwd: '/p1',
+      status: 'quarantined',
+      statusHistory: [{ to: 'quarantined', at: new Date(now - 1 * 60 * 60_000).toISOString() }],
+    },
+    {
+      slug: 'stale',
+      cwd: '/p1',
+      status: 'quarantined',
+      statusHistory: [{ to: 'quarantined', at: new Date(now - 25 * 60 * 60_000).toISOString() }],
+    },
+    {
+      slug: 'exactly-at-threshold',
+      cwd: '/p1',
+      status: 'quarantined',
+      statusHistory: [{ to: 'quarantined', at: new Date(now - QUARANTINE_ESCALATE_MS).toISOString() }],
+    },
+    { slug: 'no-history', cwd: '/p1', status: 'quarantined' },
+    { slug: 'not-quarantined', cwd: '/p1', status: 'pending' },
+  ];
+  const stale = findStaleQuarantinedJobs(jobs, now, QUARANTINE_ESCALATE_MS);
+  const slugs = stale.map((s) => s.slug).sort();
+  assert.deepStrictEqual(slugs, ['exactly-at-threshold', 'stale']);
+  assert.strictEqual(stale.find((s) => s.slug === 'stale').cwd, '/p1');
+});

package/src/main/health.cjs

@@ -14,6 +14,7 @@ const { checkPersonaImports } = require('./lib/personaImportHealth.cjs');
 const { resolvePrdsDirs } = require('./lib/prdLocations.cjs');
 const { migratePrds } = require('./lib/prdMigration.cjs');
 const queueStore = require('./lib/queueStore.cjs');
+const { computeStallSummary } = require('./scheduler.cjs');
 const { DEFAULT_RUNS_DIR, computeReport, isRetentionEnabled, liveKeysFromJobs } = require('./lib/runLogRetention.cjs');
 
 const MAX_LOG_AGE_MS = 5 * 60_000; // 5 min — warn if no logs this old
@@ -131,6 +132,55 @@ function evaluateTickLiveness(queueState, heartbeat, now, runningCount) {
   };
 }
 
+// computeProjectProblemCounts(jobs) → { [cwd]: { failed, needs_review, quarantined } }
+//
+// health.cjs's machine-wide `failed` count answered "is the machine stuck",
+// never "is any ONE project stuck" — a single project with 4 quarantined
+// PRDs and nothing else running was invisible in a rollup dominated by other
+// projects' healthy jobs. Breaks down every non-terminal-problem status
+// (failed/needs_review/quarantined — deliberately NOT 'completed'/'running'/
+// 'pending'/'investigating', which are not problems) by project cwd.
+function computeProjectProblemCounts(jobs) {
+  const byProject = {};
+  for (const j of jobs || []) {
+    if (j.status !== 'failed' && j.status !== 'needs_review' && j.status !== 'quarantined') continue;
+    const cwd = j.cwd || '(unknown)';
+    byProject[cwd] = byProject[cwd] || { failed: 0, needs_review: 0, quarantined: 0 };
+    byProject[cwd][j.status] += 1;
+  }
+  return byProject;
+}
+
+// evaluatePerProjectStall(stallSummary, lastRunAtIso, now, thresholdMs) →
+// { [cwd]: { stalled, pastThreshold?, ageMs?, caveat? } }
+//
+// computeStallSummary's per-project `stalled` flag (scheduler.cjs) is a
+// point-in-time verdict with no duration attached — a project can flip
+// stalled/unstalled within a single tick as work completes, so flagging RED
+// the instant it's true would false-trip on ordinary queue churn. There is
+// no per-project lastRunAt persisted (only a machine-wide one), so this
+// reuses that machine-wide timestamp as the best available "has the
+// scheduler ticked recently at all" signal, gated per-project by whether
+// THAT project currently holds stalled work.
+function evaluatePerProjectStall(stallSummary, lastRunAtIso, now, thresholdMs) {
+  const lastRunAt = lastRunAtIso ? Date.parse(lastRunAtIso) : null;
+  const results = {};
+  for (const cwd of Object.keys(stallSummary?.byProject || {})) {
+    const counts = stallSummary.byProject[cwd];
+    if (!counts.stalled) {
+      results[cwd] = { stalled: false };
+      continue;
+    }
+    if (lastRunAt == null || Number.isNaN(lastRunAt)) {
+      results[cwd] = { stalled: true, pastThreshold: false, caveat: 'no-lastRunAt' };
+      continue;
+    }
+    const ageMs = now - lastRunAt;
+    results[cwd] = { stalled: true, pastThreshold: ageMs >= thresholdMs, ageMs };
+  }
+  return results;
+}
+
 // Pure evaluator over migratePrds()'s { moved, skipped, unresolved } result —
 // kept separate from the fs-touching check() call site so it's directly
 // unit-testable, matching evaluateTickLiveness's pattern.
@@ -222,18 +272,42 @@ async function check() {
     const failedCount = Object.values(queueState.jobs || {}).filter(
       (j) => j.status === 'failed'
     ).length;
+    const needsReviewCount = Object.values(queueState.jobs || {}).filter(
+      (j) => j.status === 'needs_review'
+    ).length;
+    const quarantinedCount = Object.values(queueState.jobs || {}).filter(
+      (j) => j.status === 'quarantined'
+    ).length;
     const heartbeatPath = path.join(
       os.homedir(),
       '.claude/session-manager/scheduler-heartbeat.log'
     );
     const heartbeat = readFreshHeartbeat(heartbeatPath);
     const liveness = evaluateTickLiveness(queueState, heartbeat, Date.now(), runningCount);
+
+    // Per-project rollup (PRD: monitoring must not collapse per-project
+    // reality into one machine-wide boolean — see computeStallSummary /
+    // computeProjectProblemCounts headers). A project holding ONLY
+    // failed/needs_review/quarantined rows (0 running, 0 pending) never
+    // trips evaluateTickLiveness above, since that check requires actual
+    // pending work — this is what let the burrow project go dark.
+    const stallSummary = computeStallSummary(queueState);
+    const now = Date.now();
+    const perProjectStall = evaluatePerProjectStall(stallSummary, queueState.lastRunAt, now, TICK_STALL_THRESHOLD_MS);
+    const projectsPastThreshold = Object.entries(perProjectStall)
+      .filter(([, v]) => v.pastThreshold)
+      .map(([cwd]) => cwd);
+
     status.components.scheduler_queue = {
-      ok: !liveness.stalled,
+      ok: !liveness.stalled && projectsPastThreshold.length === 0,
       path: queuePath,
       jobs: Object.keys(queueState.jobs || {}).length,
       running: runningCount,
       failed: failedCount,
+      needsReview: needsReviewCount,
+      quarantined: quarantinedCount,
+      byProject: computeProjectProblemCounts(queueState.jobs),
+      perProjectStall,
       tickLiveness: liveness.reason,
     };
     if (liveness.stalled) {
@@ -249,6 +323,18 @@ async function check() {
           ? `Tick hasn't advanced in a while but scheduler-heartbeat.log is missing/stale, so current billing utilization can't be checked — cannot rule out a legitimate when-available hold`
           : 'No lastRunAt recorded yet — cannot assess tick liveness';
     }
+    if (projectsPastThreshold.length > 0) {
+      status.components.scheduler_queue.stalledProjects = projectsPastThreshold;
+      for (const cwd of projectsPastThreshold) {
+        const ageMin = Math.round(perProjectStall[cwd].ageMs / 60_000);
+        const counts = status.components.scheduler_queue.byProject[cwd] || {};
+        status.issues.push(
+          `Project fully stalled: ${cwd} — 0 running, 0 pending, only problem jobs `
+          + `(failed=${counts.failed ?? 0} needs_review=${counts.needs_review ?? 0} quarantined=${counts.quarantined ?? 0}), `
+          + `no scheduler tick in ~${ageMin}m (threshold ${Math.round(TICK_STALL_THRESHOLD_MS / 60_000)}m)`
+        );
+      }
+    }
   } catch (e) {
     if (e.code !== 'ENOENT') {
       status.issues.push(`Scheduler queue unreadable: ${e.message}`);
@@ -422,4 +508,13 @@ if (require.main === module) {
   })();
 }
 
-module.exports = { check, evaluateTickLiveness, readFreshHeartbeat, evaluatePrdMigrationHealth, TICK_STALL_THRESHOLD_MS, HEARTBEAT_STALE_MS };
+module.exports = {
+  check,
+  evaluateTickLiveness,
+  readFreshHeartbeat,
+  evaluatePrdMigrationHealth,
+  computeProjectProblemCounts,
+  evaluatePerProjectStall,
+  TICK_STALL_THRESHOLD_MS,
+  HEARTBEAT_STALE_MS,
+};

package/src/main/lib/schedulerConfig.cjs

@@ -36,4 +36,11 @@ module.exports = {
   // rollup line current (see historyAggregator.cjs's refreshIntradayToday).
   // Cheap: LRU-warm live parse, no full transcript re-read.
   HISTORY_INTRADAY_REFRESH_MS: 5 * 60_000,
+  // A 'quarantined' PRD (no createdVia provenance) sitting un-adopted past
+  // this age is escalated: warn-logged naming project + slug + age, and
+  // surfaced distinctly on Home (see homeNeedsYou.ts's matching constant)
+  // so it cannot be stranded indefinitely with nothing looking at it — see
+  // findStaleQuarantinedJobs in scheduler.cjs. Overridable via
+  // SM_QUARANTINE_ESCALATE_HOURS for testing/tuning.
+  QUARANTINE_ESCALATE_MS: 24 * 60 * 60_000,
 };