session-orchestrator 3.16.0 → 3.19.0

package/scripts/lib/evolve/autopilot-effectiveness.mjs

@@ -26,6 +26,8 @@
 
 import { randomUUID } from 'node:crypto';
 
+import { filterRealSessions } from '../session-schema.mjs';
+
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -69,18 +71,40 @@ function isoPlusDays(nowIso, days) {
   }
 }
 
+/**
+ * Return the `effectiveness` sub-object of a session record, or an empty object
+ * when absent/malformed. Session records NEST their effectiveness metrics under
+ * this key — see `skills/session-end/metrics-collection.md` (the writer) and
+ * `scripts/lib/eval/session-resolve.mjs` (a sibling reader).
+ *
+ * @param {object} s
+ * @returns {object} the nested block, or `{}` when there is none
+ */
+function effectivenessOf(s) {
+  const e = s?.effectiveness;
+  return e && typeof e === 'object' && !Array.isArray(e) ? e : {};
+}
+
 /**
  * Extract a completion ratio from a session record. Sessions encode this in a
  * few historically-evolved shapes; we tolerate all of them and fall back to
  * `null` (excluded from the average) when nothing usable is present.
  *
+ * Shape precedence (#835): the NESTED `effectiveness.completion_rate` is the
+ * shape the session-end writer actually emits and is therefore read FIRST. The
+ * top-level read is retained as a fallback for legacy/hand-written records —
+ * dropping it would silently zero out any record predating the nesting.
+ *
  * @param {object} s
  * @returns {number|null} ratio in [0, 1], or null when unknown
  */
 function completionOf(s) {
   if (!s || typeof s !== 'object') return null;
-  // Direct ratio fields
-  const direct = num(s.completion_rate ?? s.completion_ratio);
+  const eff = effectivenessOf(s);
+  // Direct ratio fields — nested (canonical) first, then legacy top-level.
+  const direct = num(
+    eff.completion_rate ?? eff.completion_ratio ?? s.completion_rate ?? s.completion_ratio,
+  );
   if (direct !== null && direct >= 0 && direct <= 1) return direct;
   // Planned vs completed counts
   const planned = num(s.planned_count ?? s.tasks_planned);
@@ -93,15 +117,18 @@ function completionOf(s) {
 
 /**
  * Extract a carryover ratio from a session record. Carryover = work not closed
- * within the session that flowed to a follow-up. Same tolerance pattern as
- * `completionOf`.
+ * within the session that flowed to a follow-up. Same tolerance pattern —
+ * and the same nested-first precedence (#835) — as `completionOf`.
  *
  * @param {object} s
  * @returns {number|null} ratio in [0, 1], or null when unknown
  */
 function carryoverOf(s) {
   if (!s || typeof s !== 'object') return null;
-  const direct = num(s.carryover_ratio ?? s.carryover_rate);
+  const eff = effectivenessOf(s);
+  const direct = num(
+    eff.carryover_ratio ?? eff.carryover_rate ?? s.carryover_ratio ?? s.carryover_rate,
+  );
   if (direct !== null && direct >= 0 && direct <= 1) return direct;
   const planned = num(s.planned_count ?? s.tasks_planned);
   const carried = num(s.carryover_count ?? s.tasks_carried_over);
@@ -132,6 +159,18 @@ function mean(values) {
  * whose autopilot_run_id matches a known run). For the skeleton it is used
  * only as a non-emptiness signal.
  *
+ * Abandoned-session filtering (#834): `sessions` is filtered to REAL (non-
+ * phantom) records via `filterRealSessions()` before bucketing. Phantom
+ * `status: 'abandoned'` stubs are legitimate DATA but not legitimate SIGNAL —
+ * they must not inflate `n_manual`/`n_autopilot` or dilute the
+ * completion/carryover averages. See `scripts/lib/session-schema/filters.mjs`.
+ *
+ * Mode resolution (#834): `mode` is a LEGACY alias for the canonical
+ * `session_type` field (`session-schema/constants.mjs` `SESSION_KEY_ALIASES`).
+ * `session_type` is read first; `mode` is a fallback for legacy records that
+ * predate the rename (production ledgers overwhelmingly carry `session_type`,
+ * not `mode` — reading `mode` alone left this analyzer largely inert).
+ *
  * @param {Array} autopilotRuns
  * @param {Array} sessions
  * @returns {Map<string, {n_manual:number, n_autopilot:number,
@@ -142,6 +181,9 @@ export function groupByMode(autopilotRuns, sessions) {
   const out = new Map();
   if (!Array.isArray(sessions) || sessions.length === 0) return out;
 
+  const realSessions = filterRealSessions(sessions);
+  if (realSessions.length === 0) return out;
+
   // Optional: known autopilot_run_id set for stricter pairing. Empty set means
   // accept any session with a non-empty autopilot_run_id field.
   const knownRunIds = new Set();
@@ -156,9 +198,14 @@ export function groupByMode(autopilotRuns, sessions) {
 
   // Bucket: mode → {manual: [], autopilot: []}
   const buckets = new Map();
-  for (const s of sessions) {
+  for (const s of realSessions) {
     if (!s || typeof s !== 'object') continue;
-    const mode = typeof s.mode === 'string' ? s.mode : null;
+    const mode =
+      typeof s.session_type === 'string'
+        ? s.session_type
+        : typeof s.mode === 'string'
+          ? s.mode
+          : null;
     if (!mode) continue;
     const apId = typeof s.autopilot_run_id === 'string' ? s.autopilot_run_id : null;
     const isAutopilot =

package/scripts/lib/gates/gate-full.mjs

@@ -40,11 +40,14 @@ const tcErrorCount =
     : 0;
 
 // --- Test ---
+// NOTE: `testFailed`, NOT `failed` — a local `failed` is already bound near the
+// bottom of this file and drives `process.exit(failed ? 2 : 0)`. Shadowing it
+// would corrupt the gate's exit code.
 const testResult = runCheck(testCmd);
-const { passed: testPassed, total: testTotal } =
+const { passed: testPassed, failed: testFailed, total: testTotal } =
   testResult.status !== 'skip'
     ? extractTestCounts(testResult.output)
-    : { passed: 0, total: 0 };
+    : { passed: 0, failed: 0, total: 0 };
 
 // --- Lint ---
 const lintResult = runCheck(lintCmd);
@@ -70,7 +73,16 @@ const output = {
   variant: 'full-gate',
   duration_seconds: durationSeconds,
   typecheck: { status: tcResult.status, error_count: tcErrorCount },
-  test: { status: testResult.status, total: testTotal, passed: testPassed },
+  // `failed` is published explicitly (#967 item 1) rather than left to be
+  // re-derived as `total - passed` downstream: the derivation and the parse can
+  // disagree, and only an explicit third number lets a consumer check
+  // `passed + failed === total` as a real producer/consumer drift guard.
+  test: {
+    status: testResult.status,
+    total: testTotal,
+    passed: testPassed,
+    failed: testFailed,
+  },
   lint: { status: lintResult.status, warnings: lintWarnings },
   debug_artifacts: debugArtifacts,
   stubbed,

package/scripts/lib/gates/gate-helpers.mjs

@@ -133,18 +133,61 @@ export function extractCount(output, pattern) {
 }
 
 /**
- * Parse vitest-style output for pass/fail/total counts.
+ * Matches a runner summary line that reports TEST-CASE counts.
  *
- * Looks for patterns like "42 passed", "3 failed".
+ * Deliberately anchored on `Tests` + a word boundary so it matches vitest's
+ * `      Tests  12904 passed | 11 skipped (12915)` and jest's
+ * `Tests:       1 failed, 4 passed, 5 total`, but NOT vitest's preceding
+ * `  Test Files  550 passed (550)` line ("Test" is not followed by "s").
+ */
+const TEST_SUMMARY_LINE = /^\s*Tests\b/;
+
+/**
+ * Parse test-runner output for pass/fail/total TEST-CASE counts.
  *
- * @param {string} output
- * @returns {{ passed: number, failed: number, total: number }}
+ * ## Which line is parsed
+ *
+ * Real vitest prints TWO `<N> passed` summary lines, files first:
+ *
+ * ```
+ *  Test Files  550 passed (550)
+ *       Tests  12904 passed | 11 skipped (12915)
+ * ```
+ *
+ * A naive whole-output scan hits the FILE count (550) and publishes it as the
+ * test count — the number then rides `gate-full.mjs`'s `test.passed` into the
+ * `orchestrator.quality_gate.*` event stream looking authoritative. So: when a
+ * `Tests`-anchored summary line exists, ONLY that line is parsed (the LAST one,
+ * which is the final summary after any rerun). Terse or non-vitest output with
+ * no such line falls back to scanning the whole string, which preserves the
+ * bare `"42 passed"` / `"10 passed, 5 failed"` forms.
+ *
+ * ## What `total` means — passed + failed, NOT vitest's parenthesised number
+ *
+ * `total` is `passed + failed` and deliberately EXCLUDES skipped/todo tests.
+ * This is load-bearing, not an oversight: `scripts/run-quality-gate.mjs`
+ * reconstructs the third number from the published envelope as
+ * `failed = total - passed`. Adopting vitest's parenthesised total (12915,
+ * which counts the 11 skipped) would make that derivation report 11 phantom
+ * FAILURES. `total` therefore answers "how many test cases produced a verdict",
+ * and `total - passed === failed` holds by construction for every consumer.
+ *
+ * Skipped is not returned: neither call site (`gate-full.mjs`,
+ * `quality-gate.mjs`) consumes it, and its only use would be to rebuild the
+ * parenthesised total — precisely the number the downstream derivation must not
+ * see. Add it together with a consumer, never ahead of one.
+ *
+ * @param {string} output - Captured test-runner stdout/stderr (or a tail of it).
+ * @returns {{ passed: number, failed: number, total: number }} `total === passed + failed`.
  */
 export function extractTestCounts(output) {
   if (!output) return { passed: 0, failed: 0, total: 0 };
 
-  const passMatch = output.match(/(\d+)\s+passed/);
-  const failMatch = output.match(/(\d+)\s+failed/);
+  const summaryLines = output.split('\n').filter((line) => TEST_SUMMARY_LINE.test(line));
+  const scope = summaryLines.length > 0 ? summaryLines[summaryLines.length - 1] : output;
+
+  const passMatch = scope.match(/(\d+)\s+passed/);
+  const failMatch = scope.match(/(\d+)\s+failed/);
 
   const passed = passMatch ? parseInt(passMatch[1], 10) : 0;
   const failed = failMatch ? parseInt(failMatch[1], 10) : 0;
@@ -153,6 +196,89 @@ export function extractTestCounts(output) {
   return { passed, failed, total };
 }
 
+/**
+ * Admit a suite-count triple, or refuse to claim a measurement.
+ *
+ * ## Why this exists (#967 item 2)
+ *
+ * Two functions used to write the `counts` field of the SAME
+ * `orchestrator.quality_gate.*` event under DIFFERENT admission policies:
+ * `suiteCountsFromGateStdout` (`scripts/run-quality-gate.mjs`) rejected
+ * inconsistent triples, while `suiteCountsFromOutput` (`scripts/lib/quality-gate.mjs`)
+ * admitted `passed > total` and a negative `passed`. A consumer therefore had to
+ * know two policies to read one field. This is the single shared policy; both
+ * callers keep only their own input adapter.
+ *
+ * ## Absent-not-null
+ *
+ * Returns `null` — NEVER a zero triple — for any unmeasured or inconsistent
+ * input. `{passed: 0, failed: 0, total: 0}` would be indistinguishable from a
+ * real all-skipped run and would publish a phantom measurement. Callers spread
+ * the result so the field is OMITTED rather than zero-filled:
+ *
+ * ```js
+ * const counts = admitSuiteCounts(raw);
+ * await emitEvent(name, { ...(counts ? { counts } : {}) });
+ * ```
+ *
+ * ## ONE channel for "the gate did not run" — a NULL `raw` (#969 MED-2)
+ *
+ * This function used to take a second `opts.measured` channel: `false` was an
+ * unconditional refusal, meant to carry the caller's positional evidence that no
+ * test gate ran. It was dead. Both adapters ALREADY convert that evidence to a
+ * null `raw` before the policy sees it (`suiteCountsFromOutput` returns
+ * `admitSuiteCounts(null)` for a null/empty output; the CLI's
+ * `suiteCountsFromGateStdout` returns `null` from its own envelope checks and
+ * never passed the opt at all), so no production path could ever reach here with
+ * a non-null triple AND `measured: false` — only test rows exercised the flag.
+ *
+ * Keeping both was the real cost: "the gate did not run" was expressible two
+ * ways and checked in two places, so a future caller could pass a real triple
+ * with `measured: false`, or a STALE triple with `measured: true`, and the two
+ * channels would disagree with the unverifiable boolean silently winning. A
+ * null `raw` is the channel that survives because the policy must reject
+ * non-objects anyway — it is structural, not an extra parameter, and it is
+ * expressible by every caller including the one that never opted in.
+ *
+ * ## What stays with the CALLER (deliberately not absorbed)
+ *
+ * This function sees a candidate triple and nothing else. It performs no I/O and
+ * reads no files. The following are per-caller INPUT ADAPTERS and must not
+ * migrate here: JSON-envelope parsing; the `test`-object-vs-status-string
+ * variant discrimination (non-full-gate variants emit a bare status string);
+ * `test.status ∈ {pass, fail}`; the `parsed.stubbed?.test` short-circuit; the
+ * raw-text tail parse ({@link extractTestCounts}); and the positional evidence
+ * that the test gate ran at all — which each caller expresses by handing over
+ * `null` rather than a triple.
+ *
+ * `failed` is accepted when the caller parsed one and DERIVED as `total - passed`
+ * when it did not, so both the parsed-`failed` path and the derived-`failed` path
+ * land on one consistency check (`passed + failed === total`).
+ *
+ * @param {{passed?: unknown, failed?: unknown, total?: unknown}|null|undefined} raw
+ *   `null`/`undefined` is the caller's evidence that there is no measurement to
+ *   admit (gate skipped, stub command, fail-fast before the test step, or no
+ *   parseable count in the output).
+ * @returns {{passed: number, failed: number, total: number}|null}
+ */
+export function admitSuiteCounts(raw) {
+  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) return null;
+
+  const { passed, total } = raw;
+  if (!Number.isFinite(passed) || !Number.isFinite(total)) return null;
+
+  const failed = Number.isFinite(raw.failed) ? raw.failed : total - passed;
+
+  if (total <= 0) return null;
+  if (passed < 0 || failed < 0) return null;
+  // Redundant given the sum check below while `failed >= 0`, but kept explicit:
+  // it is the check the looser of the two former policies was missing.
+  if (passed > total) return null;
+  if (passed + failed !== total) return null;
+
+  return { passed, failed, total };
+}
+
 /**
  * Scan changed files (since `ref`) for debug artifacts: `console.log`, `debugger`, `TODO`, `FIXME`.
  *

package/scripts/lib/gitlab-ops/stale-mr-sweep.mjs

@@ -23,6 +23,7 @@ import { execFile as execFileCb } from 'node:child_process';
 import { promisify } from 'node:util';
 
 import { detectVcsForRepo, discoverVaultRepos } from '../gitlab-portfolio/vcs-detect.mjs';
+import { resolveRepoSpec } from '../vcs-repo-spec.mjs';
 
 const realExecFile = promisify(execFileCb);
 
@@ -94,22 +95,31 @@ export function filterStaleMRs(mrs, opts = {}) {
  *   2. `detectVcsForRepo({ repo })` if `opts.repo` is provided
  *   3. 'gitlab' (cross-project default per CLAUDE.md / AGENTS.md Session Config `vcs: gitlab`) —
  *      only reached when neither vcs nor repo is provided, i.e. the caller
- *      intends "the repo at `repoRoot`", and glab/gh both auto-detect the
- *      remote from the local git checkout when no --repo flag is given.
+ *      intends "the repo at `repoRoot`".
+ *
+ * `--repo` host-pinning (#872): a bare `glab`/`gh` spawn (no `--repo`) falls
+ * back to the ambient `GITLAB_HOST`/`GH_HOST` env var to pick a host, which
+ * can silently target the WRONG instance on a multi-instance host — `cwd:
+ * repoRoot` alone does not fix this (ambient env still wins over cwd). When
+ * `opts.repo` is not explicitly provided, this function auto-detects a
+ * `--repo` spec via `resolveRepoSpecFn` (default: the real `resolveRepoSpec`
+ * from `vcs-repo-spec.mjs`, which shells out to `git remote get-url`).
+ * Explicit `opts.repo` always wins over the auto-detected spec.
  *
  * Never throws: CLI failure (missing binary, non-zero exit, timeout) and
  * malformed JSON output both resolve to a graceful `{ ok: false, error, stale: [], total: 0 }`
  * result plus a diagnostic line on stderr — never an unhandled rejection.
  *
  * @param {object} [opts]
- * @param {string} [opts.repoRoot=process.cwd()] - cwd for the CLI invocation (used for local-checkout auto-detection by glab/gh)
- * @param {string} [opts.repo] - explicit "owner/repo" or GitLab path identifier; when set, passed via `--repo`
+ * @param {string} [opts.repoRoot=process.cwd()] - cwd for the CLI invocation (also passed to resolveRepoSpecFn for remote auto-detection)
+ * @param {string} [opts.repo] - explicit "owner/repo" or GitLab path identifier; when set, passed via `--repo` and skips auto-detection
  * @param {'gitlab'|'github'} [opts.vcs] - explicit VCS override (skips detectVcsForRepo)
  * @param {number} [opts.thresholdDays=14]
  * @param {'created'|'updated'} [opts.field='updated']
  * @param {Function} [opts.exec] - injectable execFile-like function `(cmd, args, options) => Promise<{stdout, stderr}>`; defaults to the real promisified execFile
  * @param {number} [opts.now=Date.now()]
  * @param {number} [opts.timeoutMs=8000]
+ * @param {(o: { repoRoot: string, vcs: 'gitlab'|'github' }) => string|undefined} [opts.resolveRepoSpecFn] - injectable `--repo` auto-detector; defaults to the real `resolveRepoSpec`
  * @returns {Promise<
  *   { ok: true, repo: string, vcs: 'gitlab'|'github', total: number, stale: Array<object> } |
  *   { ok: false, error: string, repo: string|null, vcs: 'gitlab'|'github'|null, total: 0, stale: [] }
@@ -125,6 +135,7 @@ export async function findStaleMRs(opts = {}) {
     exec = realExecFile,
     now = Date.now(),
     timeoutMs = DEFAULT_TIMEOUT_MS,
+    resolveRepoSpecFn = resolveRepoSpec,
   } = opts;
 
   const resolvedVcs = vcsOverride ?? (repo ? detectVcsForRepo({ repo }) : 'gitlab');
@@ -144,11 +155,15 @@ export async function findStaleMRs(opts = {}) {
     cmd = 'gh';
     args = ['pr', 'list', '--state', 'open', '--json', GH_PR_JSON_FIELDS];
   }
-  if (repo) {
-    args.push('--repo', repo);
+
+  // #872: explicit repo always wins; otherwise auto-detect a --repo spec
+  // from the local git remotes (host-pinning — see docblock above).
+  const effectiveRepo = repo ?? resolveRepoSpecFn({ repoRoot, vcs: resolvedVcs });
+  if (effectiveRepo) {
+    args.push('--repo', effectiveRepo);
   }
 
-  const repoLabel = repo ?? repoRoot;
+  const repoLabel = effectiveRepo ?? repoRoot;
 
   let stdout;
   try {
@@ -209,6 +224,7 @@ export async function findStaleMRs(opts = {}) {
  * @param {number} [opts.now=Date.now()]
  * @param {number} [opts.timeoutMs=8000]
  * @param {typeof discoverVaultRepos} [opts.discoverRepos] - injectable for tests
+ * @param {(o: { repoRoot: string, vcs: 'gitlab'|'github' }) => string|undefined} [opts.resolveRepoSpecFn] - passed through to each per-repo `findStaleMRs` call; unused in practice since discovered repos always carry an explicit `repo`
  * @returns {Promise<Array<{ slug: string } & Awaited<ReturnType<typeof findStaleMRs>>>>}
  */
 export async function findStaleMRsMultiRepo(opts = {}) {
@@ -220,6 +236,7 @@ export async function findStaleMRsMultiRepo(opts = {}) {
     now = Date.now(),
     timeoutMs = DEFAULT_TIMEOUT_MS,
     discoverRepos = discoverVaultRepos,
+    resolveRepoSpecFn = resolveRepoSpec,
   } = opts;
 
   const repos = await discoverRepos({ vaultDir });
@@ -227,7 +244,7 @@ export async function findStaleMRsMultiRepo(opts = {}) {
 
   const results = await Promise.all(
     repos.map((r) =>
-      findStaleMRs({ repo: r.repo, vcs: r.vcs, thresholdDays, field, exec, now, timeoutMs }),
+      findStaleMRs({ repo: r.repo, vcs: r.vcs, thresholdDays, field, exec, now, timeoutMs, resolveRepoSpecFn }),
     ),
   );
 
@@ -362,6 +379,7 @@ export async function main(argv, deps = {}) {
     repoRoot = process.cwd(),
     discoverRepos = discoverVaultRepos,
     homedir = () => process.env.HOME ?? '',
+    resolveRepoSpecFn = resolveRepoSpec,
   } = deps;
 
   const flags = parseArgs(argv);
@@ -386,6 +404,7 @@ export async function main(argv, deps = {}) {
       exec,
       now,
       discoverRepos,
+      resolveRepoSpecFn,
     });
 
     if (flags.json) {
@@ -410,6 +429,7 @@ export async function main(argv, deps = {}) {
     field: flags.field,
     exec,
     now,
+    resolveRepoSpecFn,
   });
 
   if (!result.ok) {

package/scripts/lib/gitlab-portfolio/aggregator.mjs

@@ -12,6 +12,8 @@
 
 import { spawn as _spawn } from 'node:child_process';
 
+import { normalizeLabel, normalizedLabelSet } from '../label-scope.mjs';
+
 /** Default timeout per repo CLI invocation (ms). */
 export const DEFAULT_TIMEOUT_MS = 15_000;
 
@@ -332,7 +334,11 @@ export function summarizeRepo(issues, opts) {
 
   const nowMs = now instanceof Date ? now.getTime() : Date.now();
   const staleThresholdMs = staleDays * 86_400_000;
-  const criticalSet = new Set(Array.isArray(criticalLabels) ? criticalLabels : []);
+  // Scope-tolerant matching: defaults use the canonical scoped spelling
+  // (`priority::critical`), but issues labelled before the migration still
+  // carry `priority:critical`. Normalising both sides keeps those counted —
+  // see scripts/lib/label-scope.mjs.
+  const criticalSet = normalizedLabelSet(criticalLabels);
 
   let criticalCount = 0;
   let staleCount = 0;
@@ -341,7 +347,7 @@ export function summarizeRepo(issues, opts) {
 
   for (const issue of issues) {
     // Critical
-    if (issue.labels.some((l) => criticalSet.has(l))) {
+    if (issue.labels.some((l) => criticalSet.has(normalizeLabel(l)))) {
       criticalCount++;
     }
 

package/scripts/lib/gitlab-portfolio/cli.mjs

@@ -289,7 +289,7 @@ EXIT CODES
 
   // ── Fetch issues in parallel ───────────────────────────────────────────────
   const staleDays = portfolioConfig['stale-days'] ?? 30;
-  const criticalLabels = portfolioConfig['critical-labels'] ?? ['priority:critical', 'priority:high'];
+  const criticalLabels = portfolioConfig['critical-labels'] ?? ['priority::critical', 'priority::high'];
   const mode = portfolioConfig.mode ?? 'warn';
 
   let resultsMap;

package/scripts/lib/handover-gate.mjs

@@ -104,8 +104,12 @@ function coerceOriginIssue(v) {
 }
 
 /**
- * Coerce a priority field: lowercase, trim, strip a leading `priority:` label,
- * validate against the closed enum. Anything invalid → null.
+ * Coerce a priority field: lowercase, trim, strip a leading `priority::` (the
+ * canonical scoped form) or legacy `priority:` label prefix, validate against
+ * the closed enum. Anything invalid → null.
+ *
+ * Both spellings are accepted on INPUT because the label-data migration to the
+ * scoped form trails the producer migration — see `scripts/lib/label-scope.mjs`.
  *
  * @param {unknown} v
  * @returns {'critical'|'high'|'medium'|'low'|null}
@@ -113,7 +117,7 @@ function coerceOriginIssue(v) {
 function coercePriority(v) {
   if (v === null || v === undefined) return null;
   let s = String(v).trim().toLowerCase();
-  if (s.startsWith('priority:')) s = s.slice('priority:'.length).trim();
+  s = s.replace(/^priority::?/, '').trim();
   return VALID_PRIORITIES.has(s) ? /** @type {any} */ (s) : null;
 }
 

package/scripts/lib/harness-audit/categories/category4.mjs

@@ -11,6 +11,8 @@ import { existsSync } from 'node:fs';
 import { join, relative, sep } from 'node:path';
 
 import { parseFrontmatter, safeRead, parseJsonl, pass, fail } from './helpers.mjs';
+import { isRealSession } from '../../session-schema/filters.mjs';
+import { findSessionConfigBlock } from '../../config/section-extractor.mjs';
 
 // Default session-lock TTL in hours — mirrors DEFAULT_TTL_HOURS in
 // scripts/lib/session-lock.mjs. Inlined to keep this category stdlib-only
@@ -93,9 +95,19 @@ export function runCategory4(root) {
           { latestCompletedAt: null, ageInDays: null },
           'sessions.jsonl is empty'));
       } else {
-        const lastLine = lines[lines.length - 1];
+        // Scan backward past any trailing `status: 'abandoned'` phantom stubs
+        // (#834, session-close-backfill) to the last REAL session — otherwise a
+        // recent phantom lets a dormant repo pass a check meant to certify
+        // recent REAL engagement.
         let lastObj = null;
-        try { lastObj = JSON.parse(lastLine); } catch { /* ignore */ }
+        for (let i = lines.length - 1; i >= 0; i -= 1) {
+          let parsed = null;
+          try { parsed = JSON.parse(lines[i]); } catch { /* ignore */ }
+          if (parsed && isRealSession(parsed)) {
+            lastObj = parsed;
+            break;
+          }
+        }
         const completedAt = lastObj ? lastObj.completed_at : null;
         if (!completedAt) {
           checks.push(fail('sessions-jsonl-recent', 3, relPath,
@@ -148,9 +160,14 @@ export function runCategory4(root) {
     const relPath = 'skills/vault-sync/validator.mjs';
     // Parse CLAUDE.md Session Config for vault-integration.enabled
     const claudeMd = safeRead(join(root, 'CLAUDE.md')) || safeRead(join(root, 'AGENTS.md')) || '';
-    // Extract ## Session Config block
-    const scMatch = /^## Session Config\s*\n([\s\S]*?)(?=^## |\s*$)/m.exec(claudeMd);
-    const scBlock = scMatch ? scMatch[1] : '';
+    // Extract ## Session Config block via the SSOT (#968). The previous local
+    // regex `/^## Session Config\s*\n([\s\S]*?)(?=^## |\s*$)/m` was not merely
+    // a looser heading test — its `\s*$` lookahead (with /m, `$` matches at
+    // every line end) truncated the body to the block's FIRST line. On this
+    // repo's own CLAUDE.md it captured 17 chars ("persistence: true") of 2877,
+    // so `vault-integration.enabled: true` was invisible and this check
+    // reported "not enabled — skip" at full 2/2 credit.
+    const scBlock = findSessionConfigBlock(claudeMd)?.body ?? '';
     const vaultEnabledMatch = /vault-integration\.enabled:\s*true/i.exec(scBlock) ||
       /vault-integration:\s*\n\s+enabled:\s*true/im.exec(scBlock);
     const vaultEnabled = Boolean(vaultEnabledMatch);