@ericrisco/rsc 1.2.2 → 1.2.3

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.2.2",
+  "version": "1.2.3",
   "counts": {
     "skills": 272,
     "agents": 33,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "Eric Risco's agent-skills catalog as a granular, self-recommending CLI installer.",
   "type": "module",
   "bin": {

package/scripts/spec-gate.js

@@ -4,8 +4,8 @@
 // Not wired into `prepublishOnly`, and that is deliberate: specs live under 02-DOCS, which is never
 // tracked (principle 9), so a publish gate depending on them would fail in any clean clone. This is
 // the phase's own instrument, and the author's.
-import { readFileSync, readdirSync } from 'node:fs';
-import { join, dirname, basename } from 'node:path';
+import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
+import { join, dirname, basename, resolve, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execFileSync } from 'node:child_process';
 import { specCompleteness, statusClaims, checkClaims } from './lib/spec-gate.js';
@@ -25,11 +25,19 @@ function defaultTargets() {
 
 // The repository, asked instead of assumed. Returns null when there is nothing to ask — a
 // report-only instrument that crashes where it cannot look is worse than one that says so.
+function spawnSyncGit(cwd, args) {
+  try { return execFileSync('git', args, { cwd, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim(); } catch { return ''; }
+}
+
 function gitProbe(root) {
   const git = (args) => execFileSync('git', args, { cwd: root, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
   let main;
+  let top;
   try {
     git(['rev-parse', '--git-dir']);
+    // The repository, not the directory we happened to be handed: `children()` looks for sibling
+    // repos under this one, and asking a specs/ subdirectory for its children finds nothing.
+    top = git(['rev-parse', '--show-toplevel']) || root;
     // Prefer the remote tip — a stale local `main` reports merged work as missing. But CI checks out
     // detached with no `origin/main` and no local `main`, and falling through to "no repository to
     // ask" there means the check silently stops checking exactly where it runs unattended. HEAD is
@@ -44,12 +52,118 @@ function gitProbe(root) {
   return {
     hasCommit: (sha) => { try { git(['cat-file', '-e', `${sha}^{commit}`]); return true; } catch { return false; } },
     isAncestor: (sha) => { try { git(['merge-base', '--is-ancestor', sha, main]); return true; } catch { return false; } },
-    // The squash-merge subject carries `(#N)`; --fixed-strings so the parens are not a regex.
-    hasPr: (n) => { try { return git(['log', main, '--grep', `(#${n})`, '--fixed-strings', '-1', '--format=%H']) !== ''; } catch { return false; } },
+    // Two ways a pull request lands, and only one of them was recognised. The squash subject carries
+    // `(#N)`; a plain merge writes `Merge pull request #N from …` and matched nothing, so half the
+    // ways of landing were invisible even when the right repository was being asked.
+    // Two literal searches rather than one regex: `--fixed-strings` is what keeps the parens from
+    // being read as a group, and swapping it for an alternation would put that back.
+    hasPr: (n) => {
+      for (const needle of [`(#${n})`, `Merge pull request #${n} `]) {
+        try {
+          if (git(['log', main, '--grep', needle, '--fixed-strings', '-1', '--format=%H']) !== '') return true;
+        } catch { /* try the other form */ }
+      }
+      return false;
+    },
     hasTag: (v) => { try { return git(['tag', '-l', `v${v}`]) !== ''; } catch { return false; } },
+    root: top,
   };
 }
 
+const commonDir = (dir) => {
+  const r = spawnSyncGit(dir, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+  return r || dir;
+};
+const sameRepo = (a, b) => commonDir(a) === commonDir(b);
+
+const isRepo = (dir) => { try { return statSync(join(dir, '.git')).isDirectory() || statSync(join(dir, '.git')).isFile(); } catch { return false; } };
+
+/**
+ * Which repository is this spec's `status:` talking about?
+ *
+ * It used to be "the one holding the file", which is right only when docs and code live together.
+ * Where they deliberately do not — this workspace's own CLAUDE.md requires the children's working
+ * docs to live in the container — every true claim came back false, and a gate that flags everything
+ * distinguishes nothing.
+ *
+ * The subject is pinned ONCE per spec and every claim is then judged against it. Letting each claim
+ * find whichever repository happens to confirm it would read better and destroy the function: an
+ * unconfirmed claim would simply find no confirmer, and nothing would ever be reported stale again.
+ */
+function resolveSubject(specPath, claims) {
+  const answers = (root) => {
+    const p = gitProbe(root);
+    if (!p) return null;
+    return claims.some((c) => (c.kind === 'sha' && p.hasCommit(c.value))
+      || (c.kind === 'version' && p.hasTag(c.value))
+      || (c.kind === 'pr' && p.hasPr(c.value))) ? p : null;
+  };
+
+  // The declaration is AUTHORITATIVE. Softening it to "wins when it can answer" fixed a wrong config
+  // and opened something worse: with sibling repos, a claim that is false where the spec belongs and
+  // true next door is handed to the neighbour, confirmed, and printed nowhere. A silent false negative
+  // is worse than the noisy false positive it replaced, and choosing the judge by who agrees with the
+  // claim is not a way to find out whether the claim is true. A wrong `project.root` is a wrong datum;
+  // fix the datum.
+  const declared = declaredRoot(specPath);
+  if (declared && isRepo(declared)) return { probe: gitProbe(declared), from: 'config' };
+
+  const here = gitProbe(dirname(specPath));
+  const home = here && here.root;
+
+  if (home) {
+    const kids = children(home).map((dir) => ({ dir, probe: answers(dir) })).filter((k) => k.probe);
+    // Two histories cannot both be the subject. Saying so is an answer; picking the first one that
+    // sorted alphabetically is a coin toss wearing a verdict's clothes.
+    if (kids.length > 1) {
+      return { probe: null, note: `several repositories here could answer it (${kids.map((k) => basename(k.dir)).join(', ')}) — say which one in project.root` };
+    }
+    if (kids.length === 1) return { probe: kids[0].probe, from: 'derived' };
+    // Nobody answered. Fall through to the floor rather than guessing: with no declaration and no
+    // recogniser, the spec's own repository is the only honest default.
+  }
+  // The floor is the old behaviour: a spec that lives beside its own code must keep the detection it
+  // already had, or fixing the split layout would downgrade every caught lie to "could not check".
+  const floor = declared && isRepo(declared) ? gitProbe(declared) : here;
+  return { probe: floor, from: declared ? 'config' : 'spec repo' };
+}
+
+/** `project.root` from the nearest SDD config, resolved against the directory that holds 02-DOCS. */
+function declaredRoot(specPath) {
+  let dir = resolve(dirname(specPath));
+  for (let i = 0; i < 24; i += 1) {
+    const cfg = join(dir, '02-DOCS', 'wiki', 'sdd', 'config.yaml');
+    if (existsSync(cfg)) {
+      try {
+        const block = /^project:[ \t]*\r?\n((?:[ \t]+.*\r?\n?)*)/m.exec(readFileSync(cfg, 'utf8'));
+        const m = block && /^[ \t]+root:[ \t]*(.+?)[ \t]*$/m.exec(block[1]);
+        // Relative to the directory that owns 02-DOCS, not to the config file and not to the cwd:
+        // the only reading where `.` keeps meaning what it means today and the answer does not change
+        // with where the gate was invoked from.
+        if (m) return resolve(dir, m[1].replace(/^['"]|['"]$/g, ''));
+      } catch { /* unreadable config → derive instead */ }
+      return null;
+    }
+    const up = dirname(dir);
+    if (up === dir) break;
+    dir = up;
+  }
+  return null;
+}
+
+/** Git repositories directly inside `root` — far enough to find a child, near enough to still be this project. */
+function children(root) {
+  try {
+    return readdirSync(root, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules')
+      .map((e) => join(root, e.name))
+      .filter(isRepo)
+      // A linked worktree has a `.git` file and the same history, so without this a repo and its own
+      // worktree look like two candidates that both answer — an ambiguity invented out of one repo.
+      .filter((dir, i, all) => all.findIndex((d) => sameRepo(d, dir)) === i);
+  } catch { return []; }
+}
+
 const statusOf = (text) => (/^status:[ \t]*(.*)$/m.exec(text) || [, ''])[1];
 
 function main() {
@@ -66,11 +180,17 @@ function main() {
   // the project the spec belongs to — checking them against wherever this script happens to live
   // gives the right answer only by coincidence, and the wrong one the moment the gate is pointed at
   // another checkout.
-  const probes = new Map();
-  const probeFor = (path) => {
+  const subjects = new Map();
+  const announced = new Set();
+  const subjectFor = (path, claims) => {
     const dir = dirname(path);
-    if (!probes.has(dir)) probes.set(dir, gitProbe(dir));
-    return probes.get(dir);
+    // Keyed by directory alone. It used to include the claims, which meant a fresh resolution per
+    // spec — the opposite of what its own comment claimed, and measured at 0.8s → 10.3s over a
+    // 36-spec corpus, because every miss re-walks the children and re-runs git. A corpus shares a
+    // subject; that is the whole premise.
+    const key = dir;
+    if (!subjects.has(key)) subjects.set(key, resolveSubject(path, claims));
+    return subjects.get(key);
   };
   let anyProbe = false;
   for (const path of targets) {
@@ -92,12 +212,24 @@ function main() {
     }
     // A status that still matches the repository prints nothing: the report grows only where there
     // is something to act on (P5).
-    const probe = probeFor(path);
+    const claims = statusClaims(statusOf(text));
+    const subject = claims.length ? subjectFor(path, claims) : { probe: null };
+    // A subject nobody declared was inferred from the claims themselves, which is a guess. Say it
+    // once per run: silent inference is how a coincidence passes for a verdict.
+    if (subject.from === 'derived' && subject.probe && !announced.has(subject.probe.root)) {
+      announced.add(subject.probe.root);
+      console.log(`      note: subject derived (not declared) — asking ${subject.probe.root}; set project.root to settle it`);
+    }
+    const probe = subject.probe;
     anyProbe = anyProbe || Boolean(probe);
-    for (const v of checkClaims(statusClaims(statusOf(text)), probe)) {
+    for (const v of checkClaims(claims, probe)) {
       if (v.verdict === 'holds') continue;
       if (v.verdict === 'stale') drifted += 1;
-      console.log(`      status ${v.verdict.toUpperCase()}: ${v.raw} — ${v.reason}`);
+      // Every non-green line names where it looked, so the reader can go and check by hand (P6).
+      const rel = probe ? relative(process.cwd(), probe.root) : '';
+      const where = probe ? ` [asked ${!rel || rel.startsWith('..') ? probe.root : rel}]` : '';
+      const reason = !probe && subject.note ? subject.note : v.reason;
+      console.log(`      status ${v.verdict.toUpperCase()}: ${v.raw} — ${reason}${where}`);
     }
   }
 

package/targets/session-memory-adapter.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { existsSync, readFileSync } from 'node:fs';
-import { resolve, join } from 'node:path';
+import { resolve, join, dirname } from 'node:path';
 import { capture, resume } from './session-memory-core.mjs';
 
 const LOCAL_TARGETS = new Set(['claude', 'codex', 'cursor', 'gemini', 'opencode']);
@@ -15,6 +15,20 @@ function projectSettings(cwd) {
   }
 }
 
+// The project is the nearest ancestor holding `.rsc.json` — the file that IS the harness's decision.
+// The hook payload's `cwd` is only where the tool call happened to run; inside a container of child
+// repos that is routinely a subdirectory with no harness of its own, and anchoring there scatters
+// one session's journal across children. With no harness anywhere above, the cwd stays the project.
+function nearestHarness(dir) {
+  let current = dir;
+  for (;;) {
+    if (existsSync(join(current, '.rsc.json'))) return current;
+    const parent = dirname(current);
+    if (parent === current) return dir;
+    current = parent;
+  }
+}
+
 function sessionId(native, target) {
   return native?.session_id || native?.sessionId || native?.sessionID || native?.conversation_id
     || native?.thread_id || `${target}-${process.ppid}`;
@@ -63,7 +77,7 @@ export function handleLifecycle({ target, event, native = {}, cwd, settings } =
   try {
     if (!LOCAL_TARGETS.has(target)) throw new Error(`unsupported memory target: ${target}`);
     if (isRemote(target, native)) return { output: {}, capture: null, remote: true, degraded: false };
-    const project = resolve(cwd || native.cwd || process.env.RSC_PROJECT_CWD || process.cwd());
+    const project = nearestHarness(resolve(cwd || native.cwd || process.env.RSC_PROJECT_CWD || process.cwd()));
     if (!existsSync(project)) throw new Error('project directory unavailable');
     const config = settings || projectSettings(project);
     if (config.enabled === false) return { output: {}, capture: null, remote: false, degraded: false };