session-orchestrator 3.20.0 → 3.22.0

package/scripts/lib/resource-probe.mjs

@@ -18,6 +18,7 @@
  *     cpu_load_5m: 1.8,
  *     cpu_load_5m_pct: 45 | null,   // 5m load-average as pct-of-cores; null on Windows/zero-load (#943)
  *     claude_processes_count: 3 | null,
+ *     peer_sessions_count: 2 | null,   // live peer SESSIONS from the registry, self excluded (#1089)
  *     codex_processes_count: 0 | null,
  *     other_node_processes: 12 | null,
  *     zombie_processes_count: 1 | null,
@@ -40,13 +41,14 @@
  */
 
 import os from 'node:os';
-import { ramSnapshot, cpuSnapshot, processCounts, swapUsedMb, memoryPressurePctFree, ramAvailableGb } from './resource-probe/probe-platform.mjs';
+import { ramSnapshot, cpuSnapshot, processCounts, swapUsedMb, memoryPressurePctFree, ramAvailableGb, peerSessionsCount } from './resource-probe/probe-platform.mjs';
 
 // ---------------------------------------------------------------------------
 // Re-exports — preserve public API for all existing callers
 // ---------------------------------------------------------------------------
 
-export { evaluate } from './resource-probe/evaluate.mjs';
+export { evaluate, PROCESSES_PER_SESSION, PRESSURE_HARD_PCT, PRESSURE_SOFT_PCT, PRESSURE_HEALTHY_PCT, DEFAULT_RESOURCE_THRESHOLDS } from './resource-probe/evaluate.mjs';
+export { peerSessionsCount } from './resource-probe/probe-platform.mjs';
 export { parseEtimeToMinutes, countZombieProcesses, countProcessMatches, parseSwapUsageOutput, parseMemoryPressureOutput, parseVmStatAvailableGb } from './resource-probe/parsers.mjs';
 
 // ---------------------------------------------------------------------------
@@ -60,6 +62,9 @@ export { parseEtimeToMinutes, countZombieProcesses, countProcessMatches, parseSw
  * @param {boolean} [opts.skipExtendedSignals] — skip swap + memory_pressure calls (faster in tests)
  * @param {number|null} [opts.zombieThresholdMin] — when non-null, detect zombie Claude/Node
  *   processes older than this many minutes with low CPU. Default null (feature disabled).
+ * @param {string|null} [opts.sessionId] — own session id, excluded from `peer_sessions_count`
+ *   (#1089). Omit and the count simply includes every live registry entry, which
+ *   over-counts by exactly one — pass it whenever the caller knows its own id.
  * @returns {Promise<object>}
  */
 export async function probe(opts = {}) {
@@ -85,6 +90,13 @@ export async function probe(opts = {}) {
     ? { claude_processes_count: null, codex_processes_count: null, other_node_processes: null, zombie_processes_count: null }
     : await processCounts(zombieThresholdMin);
 
+  // #1089: the registry-denominated concurrency signal. Gated on the same
+  // skipProcessCounts flag as the `ps` pass — both answer "who else is on this
+  // host", and tests that skip one always mean to skip the other.
+  const peer_sessions_count = opts.skipProcessCounts
+    ? null
+    : await peerSessionsCount({ sessionId: opts.sessionId ?? null });
+
   let swap_used_mb = null;
   let memory_pressure_pct_free = null;
   let ram_available_gb = null;
@@ -104,6 +116,10 @@ export async function probe(opts = {}) {
     cpu_load_5m,
     cpu_load_5m_pct,
     ...procs,
+    // Live peer SESSIONS (registry, self excluded) — the unit
+    // `concurrent-sessions-warn` is named for. null = registry unreadable, in
+    // which case evaluate() falls back to the rescaled process count (#1089).
+    peer_sessions_count,
     swap_used_mb,
     memory_pressure_pct_free,
     // macOS-only numeric available-RAM (free + reclaimable) from vm_stat; null

package/scripts/lib/scope-baseline.mjs

@@ -124,6 +124,7 @@ import { execFileSync } from 'node:child_process';
 
 import { parseStateMd, serializeStateMd, resolveStateMdPath, writeStateMd } from './state-md.mjs';
 import { pathMatchesPattern } from './scope-gate.mjs';
+import { resolveBaselineRange, isQueryFailure } from './vcs-repo-spec.mjs';
 
 // ---------------------------------------------------------------------------
 // DRIFT_EXCLUDE_PATTERNS — the SINGLE filter source for both the denominator
@@ -472,23 +473,60 @@ export async function writeBaseline({ repoRoot, intent, ownerBoundary, plannedFi
  *
  * Skip precedence (first match wins, so `reason` is deterministic):
  *   `no-state-md` → `unreadable-state-md` → `no-baseline` →
- *   `stale-baseline` → `unresolvable-ref`
+ *   `stale-baseline` → (`no-baseline-ref` | `unresolvable-ref`)
  *
- * `session-start-ref` handling — MISSING vs UNRESOLVABLE are different:
- *   - Field absent from frontmatter → falls back to
- *     `git diff --name-only origin/main...HEAD` (the documented fallback,
- *     skills/session-end/plan-verification.md:37). This is NOT a skip —
- *     `refUsed` reports the fallback ref actually used.
- *   - Field present but the diff against it fails (rebase, force-push,
- *     deleted commit, …) → skip with `reason: 'unresolvable-ref'`.
+ * `session-start-ref` handling — THREE outcomes, deliberately distinct.
+ * `skills/_shared/state-ownership.md:28` declares the field OPTIONAL
+ * ("readers MUST tolerate their absence"), so the absent-field branch is a
+ * REACHABLE production path, not a defensive corner:
+ *
+ *   - **Field present**, diff against it succeeds → measured; `refUsed`
+ *     reports the bare ref verbatim (NOT a range — pre-existing contract,
+ *     unchanged).
+ *   - **Field absent** → the range is RESOLVED via `resolveBaselineRange()`
+ *     (scripts/lib/vcs-repo-spec.mjs): preferred remote `R` →
+ *     `refs/remotes/<R>/HEAD` → `refs/remotes/<R>/{main,master}` → local
+ *     `{main,master}`. NOT a skip — `refUsed` reports the range actually
+ *     resolved (`gitlab/main...HEAD`, `origin/master...HEAD`, …).
+ *     This REPLACES the hard-coded `'origin/main...HEAD'` literal the
+ *     function carried until #1039, which hard-coded BOTH the remote name
+ *     AND the default branch in one string. In any repo whose remote is not
+ *     named `origin`, or whose default branch is not `main`, that diff
+ *     always failed → the tripwire skipped → and
+ *     `skills/wave-executor/wave-loop.md` renders every `skipped === true`
+ *     with NO WARN. A guard that neither bit nor reported that it was not
+ *     biting.
+ *   - **Field absent AND nothing resolves** (fresh `git init`, no remotes,
+ *     no `main`/`master` anywhere) → skip with `reason: 'no-baseline-ref'`.
+ *     This is an ABSENCE — there is genuinely no session base to measure
+ *     against — and is deliberately NOT folded onto `unresolvable-ref`,
+ *     which means the QUERY failed (not a git repo, git not on PATH, a
+ *     present-but-dead `session-start-ref` after a rebase/force-push).
+ *     The split follows `isQueryFailure()` from the same module, the single
+ *     predicate that separates "I could not ask" from "I asked; the answer
+ *     is no". Folding them was the pre-#1039 behaviour and made an operator
+ *     unable to tell a broken checkout from a fresh repo.
+ *
+ * Named ceiling (BV-004) on the local-branch tail of the resolution chain:
+ * when the chain lands on a LOCAL `main`/`master` and HEAD is already that
+ * branch, `main...HEAD` has merge-base === HEAD and the diff is empty, so
+ * the ratio reads `0` instead of skipping. That is the honest floor of the
+ * available information (no remote-tracking ref exists to say where the
+ * session started) and it is harmless here because both a `0` ratio and a
+ * skip are silent under `wave-loop.md`'s WARN-on-breach rule. Revisit if
+ * this function ever gains a non-warn consumer that treats `skipped:false`
+ * as "measured successfully".
  *
  * @param {object} args
  * @param {string|undefined} args.repoRoot
  * @param {number} [args.threshold] — breach threshold, `>=` counts as
  *   breached (default `2.0`).
- * @returns {{ ok: true, skipped: true, reason: 'no-state-md'|'unreadable-state-md'|'no-baseline'|'stale-baseline'|'unresolvable-ref' }
+ * @returns {{ ok: true, skipped: true, reason: 'no-state-md'|'unreadable-state-md'|'no-baseline'|'stale-baseline'|'no-baseline-ref'|'unresolvable-ref' }
  *   | { ok: true, skipped: false, filesRatio: number, plannedFiles: number,
  *       actualFiles: number, breached: boolean, threshold: number, refUsed: string }}
+ *   Additive since #1039: `no-baseline-ref` is a NEW member of the skip-reason
+ *   union. No existing member was renamed or removed, and the measured-result
+ *   shape (all eight keys) is byte-identical to the pre-#1039 contract.
  */
 export function computeDrift({ repoRoot, threshold = 2.0 } = {}) {
   const parsedFm = readFrontmatterOrReason(repoRoot);
@@ -514,18 +552,40 @@ export function computeDrift({ repoRoot, threshold = 2.0 } = {}) {
     ? baseline.sessionStartRef
     : null;
 
-  const diffArgs = rawRef !== null
-    ? ['diff', '--name-only', `${rawRef}..HEAD`]
-    : ['diff', '--name-only', 'origin/main...HEAD'];
-  const refUsed = rawRef ?? 'origin/main...HEAD';
+  // Resolve the diff range. The `session-start-ref` branch keeps its exact
+  // pre-#1039 shape (two-dot `<ref>..HEAD`, `refUsed` = the bare ref); only
+  // the absent-field branch changed, from a hard-coded literal to a real
+  // resolution. See the JSDoc above for the three outcomes.
+  let diffRange;
+  let refUsed;
+  if (rawRef !== null) {
+    diffRange = `${rawRef}..HEAD`;
+    refUsed = rawRef;
+  } else {
+    const resolved = resolveBaselineRange({ repoRoot: cwd });
+    if (!resolved.ok) {
+      // `isQueryFailure()` is the frozen predicate that keeps the two causes
+      // apart: a broken/absent git ⇒ `unresolvable-ref` (degraded
+      // measurement), a repo that simply has no baseline ref ⇒
+      // `no-baseline-ref` (a real, benign repo state).
+      return {
+        ok: true,
+        skipped: true,
+        reason: isQueryFailure(resolved.reason) ? 'unresolvable-ref' : 'no-baseline-ref',
+      };
+    }
+    diffRange = resolved.range;
+    refUsed = resolved.range;
+  }
 
   let stdout;
   try {
-    stdout = execFileSync('git', diffArgs, { cwd, encoding: 'utf8' });
+    stdout = execFileSync('git', ['diff', '--name-only', diffRange], { cwd, encoding: 'utf8' });
   } catch {
-    // Ref present-but-unresolvable (rebase, force-push, deleted commit) OR
-    // the fallback diff itself failed (e.g. no origin/main) — both land in
-    // the same skip bucket; neither can produce a trustworthy numerator.
+    // The range resolved but the diff against it failed — a present-but-dead
+    // `session-start-ref` (rebase, force-push, deleted commit), or a
+    // resolved base that vanished between resolution and diff. Neither can
+    // produce a trustworthy numerator.
     return { ok: true, skipped: true, reason: 'unresolvable-ref' };
   }