claude-code-session-manager 0.95.0 → 0.97.0

package/src/main/lib/prdSizing.cjs

@@ -0,0 +1,83 @@
+/**
+ * prdSizing.cjs — pure PRD-size warning rules (PRD 1403).
+ *
+ * The measured actual/estimate ratio across scheduler runs sits at 0.24 (p50) with 60% of
+ * jobs finishing in <=10 min, yet nothing at the authoring gate flags an oversized PRD before
+ * it lands. `sizingWarnings` is the single rule set; prdCreate.cjs's createPrd() surfaces its
+ * output in the create-prd response, and scheduler-mcp-server.cjs's scheduler_create_prd
+ * handler prints it as a "Sizing warnings:" block. Warnings never block a write.
+ */
+'use strict';
+
+const SIZING_LIMITS = {
+  estimateMinutes: 15,
+  acLines: 8,
+  acLineChars: 400,
+  bodyChars: 7000,
+};
+
+// Open-ended search-and-fix shape, e.g. "grep the codebase and update every call site." Matches
+// across sentence boundaries within one AC line ([\s\S]*, not [^.]*) — a natural two-sentence
+// phrasing like "Search the codebase for X. Update every call site." is exactly the shape this
+// rule exists to catch, and a period must not be enough to dodge it.
+const OPEN_ENDED_RE = /\b(grep|search|scan|audit|find)\b[\s\S]*\b(and|then)\b[\s\S]*\b(update|fix|adjust|migrate|change)\b/i;
+const TIMEOUT_CMD_RE = /\btimeout\s+\d+/gi;
+
+/**
+ * Pure — no I/O. Returns one human-readable warning per triggered rule, `[]` when nothing
+ * is triggered. `input` mirrors createPrd()'s own input shape; missing/non-array fields are
+ * treated as empty/absent rather than thrown on, since this is advisory only.
+ */
+function sizingWarnings(input) {
+  const { estimateMinutes, goal, implementationNotes } = input || {};
+  const acceptanceCriteria = Array.isArray(input?.acceptanceCriteria) ? input.acceptanceCriteria : [];
+  const acLines = acceptanceCriteria.filter((line) => typeof line === 'string');
+
+  const warnings = [];
+
+  if (typeof estimateMinutes === 'number' && estimateMinutes > SIZING_LIMITS.estimateMinutes) {
+    warnings.push(
+      `estimateMinutes (${estimateMinutes}) exceeds the ${SIZING_LIMITS.estimateMinutes}-minute sizing limit — split this PRD into smaller work items.`,
+    );
+  }
+
+  if (acceptanceCriteria.length > SIZING_LIMITS.acLines) {
+    warnings.push(
+      `acceptanceCriteria has ${acceptanceCriteria.length} lines, exceeding the ${SIZING_LIMITS.acLines}-line sizing limit — split into smaller, single-purpose PRDs.`,
+    );
+  }
+
+  if (acLines.some((line) => line.length > SIZING_LIMITS.acLineChars)) {
+    warnings.push(
+      `One or more acceptance criteria lines exceed ${SIZING_LIMITS.acLineChars} characters — break the line up into smaller, single-purpose criteria.`,
+    );
+  }
+
+  if (acLines.some((line) => OPEN_ENDED_RE.test(line))) {
+    warnings.push(
+      'One or more acceptance criteria lines describe an open-ended search-and-fix task (e.g. "grep ... and update ...") — scope it to a concrete, bounded change instead.',
+    );
+  }
+
+  if (acLines.some((line) => {
+    const matches = line.match(TIMEOUT_CMD_RE);
+    return matches && matches.length >= 2;
+  })) {
+    warnings.push(
+      'One or more acceptance criteria lines run two or more `timeout <n>` commands — split into separate criteria, one command each.',
+    );
+  }
+
+  const bodyChars = String(goal || '').length
+    + String(implementationNotes || '').length
+    + acLines.join('\n').length;
+  if (bodyChars > SIZING_LIMITS.bodyChars) {
+    warnings.push(
+      `Combined goal + implementation notes + acceptance criteria is ${bodyChars} characters, exceeding the ${SIZING_LIMITS.bodyChars}-character sizing limit — split into smaller PRDs.`,
+    );
+  }
+
+  return warnings;
+}
+
+module.exports = { SIZING_LIMITS, sizingWarnings };

package/src/main/lib/runLogRetention.cjs

@@ -43,13 +43,8 @@
  */
 
 const fs = require('node:fs');
-const os = require('node:os');
 const path = require('node:path');
-
-const DEFAULT_RUNS_DIR = path.join(
-  os.homedir(),
-  '.claude', 'session-manager', 'scheduled-plans', 'runs'
-);
+const schedulerPaths = require('./schedulerPaths.cjs');
 
 // Any status that is not yet a terminal outcome. Mirrors the status literals
 // used throughout scheduler.cjs (see e.g. its DOD_SLUG_RE-adjacent status
@@ -436,14 +431,13 @@ function applyRetention(runsDir, settings, opts) {
  * startup timer, alongside finalizeClosedDays) — never on its own timer.
  */
 function runBootSweep(opts) {
-  const runsDir = (opts && opts.runsDir) || DEFAULT_RUNS_DIR;
+  const runsDir = (opts && opts.runsDir) || schedulerPaths.runsDir();
   const queueStore = require('./queueStore.cjs');
   const state = queueStore.readMergedSync();
   return applyRetention(runsDir, state.config || {}, { jobs: state.jobs || [] });
 }
 
 module.exports = {
-  DEFAULT_RUNS_DIR,
   LIVE_STATUSES,
   isLiveJob,
   liveKeysFromJobs,

package/src/main/lib/telemetryBacklog.cjs

@@ -21,7 +21,7 @@
  * a conservative, delivery-confirmed offset) at once — see the two-phase
  * design below.
  *
- * TWO-PHASE WATERMARK. Per file, ~/.config/session-manager/telemetry-
+ * TWO-PHASE WATERMARK. Per file, ~/.claude/session-manager/telemetry-
  * watermarks.json tracks:
  *   - bytesEnqueued:  how far we've read + handed lines to telemetryClient.
  *                     Advances the instant a line has been processed
@@ -85,8 +85,14 @@ function lastRunSummary() {
   return lastSummary ? { ...lastSummary } : null;
 }
 
+let migrated = false;
 function watermarksPath() {
-  return path.join(os.homedir(), '.config', 'session-manager', 'telemetry-watermarks.json');
+  const p = path.join(os.homedir(), '.claude', 'session-manager', 'telemetry-watermarks.json');
+  if (!migrated) {
+    migrated = true;
+    config.migrateLegacyHomeFile(path.join(os.homedir(), '.config', 'session-manager', 'telemetry-watermarks.json'), p);
+  }
+  return p;
 }
 
 function resolveDeps(deps = {}) {
@@ -154,7 +160,7 @@ function entryFor(wm, key) {
 
 /**
  * Known projects come from the same source of truth the renderer restores
- * tabs from (sessionsStore.cjs's ~/.config/session-manager/tabs.json — TAB =
+ * tabs from (sessionsStore.cjs's ~/.claude/session-manager/tabs.json — TAB =
  * cwd = Main Project), deduped by normalized cwd, with ephemeral (worktree /
  * tmpdir) cwds excluded before normalization even runs, since a worktree cwd
  * would otherwise resolve back to its real project and be scanned twice

package/src/main/lib/telemetryClient.cjs

@@ -7,7 +7,7 @@
  * through the same queue/dedup/backoff machinery but sent one record at a
  * time via sendSingle() rather than sendBatch().
  *
- * Records accumulate durably in ~/.config/session-manager/telemetry-queue.jsonl
+ * Records accumulate durably in ~/.claude/session-manager/telemetry-queue.jsonl
  * the instant they're accepted, and are only ever sent by flush(reason) — on
  * a deliberate cadence (boot / daily / version-change / quit / manual), never
  * on a short interval. Every record is idempotent by recordId and stamped at
@@ -111,12 +111,21 @@ function logWarn(message, meta) {
 
 /**
  * SM_TELEMETRY_SPOOL, when set, overrides the spool directory in place of
- * `~/.config/session-manager` — the explicit opt-in a test that genuinely
+ * `~/.claude/session-manager` — the explicit opt-in a test that genuinely
  * needs to exercise real queue/sent-file I/O uses to prove it isn't about to
  * write into a real user's spool (see isTestEnvironment() below).
  */
+let spoolMigrated = false;
 function spoolDir() {
-  return process.env.SM_TELEMETRY_SPOOL || path.join(os.homedir(), '.config', 'session-manager');
+  if (process.env.SM_TELEMETRY_SPOOL) return process.env.SM_TELEMETRY_SPOOL;
+  const dir = path.join(os.homedir(), '.claude', 'session-manager');
+  if (!spoolMigrated) {
+    spoolMigrated = true;
+    const oldDir = path.join(os.homedir(), '.config', 'session-manager');
+    config.migrateLegacyHomeFile(path.join(oldDir, 'telemetry-queue.jsonl'), path.join(dir, 'telemetry-queue.jsonl'));
+    config.migrateLegacyHomeFile(path.join(oldDir, 'telemetry-sent.json'), path.join(dir, 'telemetry-sent.json'));
+  }
+  return dir;
 }
 
 function queuePath() {

package/src/main/lib/telemetrySettings.cjs

@@ -1,7 +1,7 @@
 /**
  * telemetrySettings — persists product-telemetry consent/config + install identity.
  *
- * Storage: ~/.config/session-manager/telemetry.json
+ * Storage: ~/.claude/session-manager/telemetry.json
  * Shape: {
  *   enabled: boolean,                // ON by default — hard kill switch is SM_TELEMETRY=0
  *   installId: string,               // crypto.randomUUID(), minted once, the only identity
@@ -45,8 +45,14 @@ const DEFAULTS = Object.freeze({
 
 const KNOWN_KEYS = new Set(Object.keys(DEFAULTS));
 
+let migrated = false;
 function storePath() {
-  return path.join(os.homedir(), '.config', 'session-manager', 'telemetry.json');
+  const p = path.join(os.homedir(), '.claude', 'session-manager', 'telemetry.json');
+  if (!migrated) {
+    migrated = true;
+    config.migrateLegacyHomeFile(path.join(os.homedir(), '.config', 'session-manager', 'telemetry.json'), p);
+  }
+  return p;
 }
 
 function isValid(cfg) {

package/src/main/lib/validationSentinels.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+/**
+ * validationSentinels.cjs — parses the `VALIDATION: <slug> VERIFIED` /
+ * `VALIDATION: <slug> REFUTED — <reason>` lines a plan-level validator job
+ * (persona `validator`, PRD 1405) emits, one per PRD it checked, at the end
+ * of its run. Pure text-in/array-out; no filesystem or scheduler knowledge.
+ */
+
+const SENTINEL_RE = /^VALIDATION:\s+(\S+)\s+(VERIFIED|REFUTED)(?:\s*[—–-]+\s*(.*))?\s*$/gm;
+
+/**
+ * parseValidationSentinels(text) → Array<{ slug, verdict, reason }>
+ *
+ * `verdict` is lowercased ('verified' | 'refuted'); `reason` is '' when
+ * absent. Last matching line per slug wins, but the ORDER of the returned
+ * array follows each slug's first appearance in `text`, not its last.
+ */
+function parseValidationSentinels(text) {
+  if (!text) return [];
+  const bySlug = new Map();
+  for (const match of text.matchAll(SENTINEL_RE)) {
+    const [, slug, verdict, reason] = match;
+    bySlug.set(slug, { slug, verdict: verdict.toLowerCase(), reason: reason || '' });
+  }
+  return Array.from(bySlug.values());
+}
+
+module.exports = { parseValidationSentinels };

package/src/main/memoryAggregate.cjs

@@ -8,9 +8,10 @@
  * owns) and, via a single cost-gated `claude -p` pass, organizes them into
  * named semantic clusters with `[[wikilink]]`-derived connections.
  *
- * Cache: ~/.claude/session-manager/memory-clusters/<workspace>.json
- * The `claude -p` call only fires when the caller passes `refresh: true` —
- * this is the cost gate; the renderer wires it to an explicit button.
+ * Cache: <cwd>/session-manager-operations/memory-clusters/clusters.json (one
+ * file per project — see memory-clusters/README.md). The `claude -p` call
+ * only fires when the caller passes `refresh: true` — this is the cost gate;
+ * the renderer wires it to an explicit button.
  *
  * Spawn/capture/timeout pattern mirrors kg.cjs's runClaude (~line 316-351):
  * stdin closed, model pinned, hard timeout that resolves {ok:false} rather
@@ -26,17 +27,34 @@ const { extractJson } = require('./lib/extractJson.cjs');
 const { runClaudeP } = require('./lib/runClaudeP.cjs');
 const { writeJson } = require('./config.cjs');
 const config = require('./config.cjs');
+const { opsPath } = require('./lib/opsOwnership.cjs');
 const { MEMORY_SLUG_RE } = require('./lib/memorySlug.cjs');
 
 const HOME = os.homedir();
-const CLUSTERS_DIR = path.join(HOME, '.claude', 'session-manager', 'memory-clusters');
+const CACHE_WRITER = 'memory-clusters';
 
 function memoryDir(workspace) {
   return path.join(HOME, '.claude', 'projects', workspace, 'memory');
 }
 
-function cachePath(workspace) {
-  return path.join(CLUSTERS_DIR, `${workspace}.json`);
+function clustersCachePath(cwd) {
+  return opsPath(cwd, 'memory-clusters', 'clusters.json');
+}
+
+/**
+ * Resolves `cwd` to a real, boundary-checked project root, or null when
+ * `cwd` is absent/invalid. Mirrors memoryTool.cjs's stale() cwd handling:
+ * an absent/unusable cwd disables the per-project cache entirely rather than
+ * throwing — the cache is purely regenerable, so a caller with no cwd (or a
+ * cwd this process cannot vouch for) just gets an uncached aggregate.
+ */
+function resolveCwd(cwd) {
+  if (typeof cwd !== 'string' || !cwd) return null;
+  try {
+    return config.validatePath(cwd);
+  } catch {
+    return null;
+  }
 }
 
 // System prompt for clustering — sets the role server-side so the CLI treats
@@ -143,17 +161,19 @@ function parseClusters(rawLlmText, slugs) {
   return { clusters, orphans };
 }
 
-async function readCache(workspace) {
-  const r = await config.readText(cachePath(workspace));
+async function readCache(cwd) {
+  const realCwd = resolveCwd(cwd);
+  if (!realCwd) return null;
+  const r = await config.readText(clustersCachePath(realCwd));
   if (!r.exists) return null;
   try { return JSON.parse(r.text); } catch { return null; }
 }
 
-async function aggregate({ workspace, refresh }) {
+async function aggregate({ workspace, refresh, cwd }) {
   const ws = typeof workspace === 'string' && workspace ? workspace : encodeCwd(null);
 
   if (!refresh) {
-    const cached = await readCache(ws);
+    const cached = await readCache(cwd);
     if (cached) return { ...cached, cached: true };
     return { workspace: ws, generatedAt: null, clusters: [], orphans: [], cached: false };
   }
@@ -174,7 +194,11 @@ async function aggregate({ workspace, refresh }) {
   }
 
   const result = { workspace: ws, generatedAt: Date.now(), clusters, orphans };
-  await writeJson(cachePath(ws), result);
+  const realCwd = resolveCwd(cwd);
+  if (realCwd) {
+    config.addAllowedRoot(realCwd);
+    await writeJson(clustersCachePath(realCwd), result, { writer: CACHE_WRITER });
+  }
   return { ...result, cached: false };
 }
 
@@ -189,4 +213,5 @@ module.exports = {
   aggregate,
   // exported for tests
   parseFrontmatter,
+  clustersCachePath,
 };

package/src/main/otelSettings.cjs

@@ -1,7 +1,7 @@
 /**
  * otelSettings — persists OTEL telemetry export configuration.
  *
- * Storage: ~/.config/session-manager/otel.json
+ * Storage: ~/.claude/session-manager/otel.json
  * Shape: {
  *   enabled: boolean,
  *   endpoint: string,        // OTLP/HTTP traces endpoint
@@ -30,8 +30,14 @@ const DEFAULTS = Object.freeze({
   schemaVersion: SCHEMA_VERSION,
 });
 
+let migrated = false;
 function storePath() {
-  return path.join(os.homedir(), '.config', 'session-manager', 'otel.json');
+  const p = path.join(os.homedir(), '.claude', 'session-manager', 'otel.json');
+  if (!migrated) {
+    migrated = true;
+    config.migrateLegacyHomeFile(path.join(os.homedir(), '.config', 'session-manager', 'otel.json'), p);
+  }
+  return p;
 }
 
 function isValid(cfg) {