@ericrisco/rsc 2.0.5 → 2.0.6

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.0.5",
+  "version": "2.0.6",
   "counts": {
     "skills": 273,
     "agents": 33,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "description": "A guided harness builder that turns your goal into a minimal, verified AI-agent setup using strict best practices.",
   "type": "module",
   "bin": {

package/scripts/doctor.js

@@ -17,6 +17,16 @@ import { resolveCommands, commandPath, targetHasCommands } from '../targets/comm
 import { inspectMemoryWiring } from '../targets/memory.js';
 import { metricsSummary } from '../targets/session-memory-core.mjs';
 import { agentPath } from '../targets/agents.js';
+import { projectOptOuts } from '../targets/opt-outs.js';
+
+// Gates the committed manifest says the team disarmed, still armed here. Read through the same
+// partition the installer uses, so a machine-only switch somebody's older rsc wrote into the
+// manifest (`harness`, `context7`) is not reported as something to converge on.
+function optOutsNotApplied(root) {
+  let manifest = null;
+  try { manifest = readProjectManifest(root); } catch { return []; }
+  return projectOptOuts(manifest?.optOuts).filter((n) => !existsSync(join(root, '.rsc', `.no-${n}`)));
+}
 
 // The sello's health, surfaced where the user already looks (spec: non-blocking
 // findings live in the project and are SUMMARIZED here, never nagged about).
@@ -223,6 +233,11 @@ export function doctor({ target, home, cwd }) {
     gitmojiGuard: state.policy?.gitmojiGuard === false
       ? 'deferred'
       : existsSync(join(root, '.rsc', '.no-gitmoji')) ? 'opted-out' : 'armed',
+    // The reverse of the same honesty, one level up: a gate the TEAM disarmed in the committed
+    // manifest and that is still armed on this machine. Nothing is applied from here — a pull
+    // never rewrites somebody's machine — so the only thing owed is saying it out loud, and
+    // saying it every run, because a notice offered once per session is a notice missed.
+    optOutsNotApplied: optOutsNotApplied(root),
     // Counted, never interpreted — by spec, the gap log's reader is the user.
     automationGaps: countGaps(root),
     memory,

package/scripts/install-apply.js

@@ -8,8 +8,9 @@ import { targetPaths, writeSkill, wireHook, unwireHook, baseDir, TARGET_IDS } fr
 import { shadowTarget } from '../targets/agents-md-shadow.js';
 import {
   targetHasAgents, reconcileAgents, agentPath, agentNames,
-  resolveAgentNames, agentByName, allAgentNames, readDeveloperTier,
+  resolveAgentNames, agentByName, allAgentNames, readDeveloperTier, writeDeveloperTier,
 } from '../targets/agents.js';
+import { projectOptOuts } from '../targets/opt-outs.js';
 import { readState, writeState } from './lib/state.js';
 import { withDefaultSkillFloor } from './lib/default-skill-floor.js';
 import { readManifest, writeManifest } from './lib/manifest-file.js';
@@ -128,17 +129,56 @@ export function managedPathsForInstall({ skillIds, agentIds = [], target, home,
 // which is machine-local and therefore lost on every clone: a team that disarmed the
 // gitmoji guard found it armed again on the next checkout, with nobody having decided
 // that. They are decisions, so they belong in the committed declaration.
+//
+// Two distinctions this function exists to keep, both of which used to be collapsed:
+//
+//   ABSENT is not EMPTY. In a clone `.rsc/` does not exist, and reading "no markers here" as
+//   "the team re-armed everything" would have sync quietly delete the decision it came to
+//   rebuild. Unreadable returns null — "I know nothing" — and the caller keeps what was
+//   declared. A readable directory with no markers returns [], which IS a statement: somebody
+//   deleted the last marker, and deleting it is how a gate gets re-armed.
+//
+//   Not every switch is the team's to make. `.no-harness` and friends are decisions of one
+//   machine (see targets/opt-outs.js), and committing them would impose one laptop's answer on
+//   every future clone. They stay local, and never reach the declaration.
 function localDecisions(cwd) {
   const dir = join(cwd, '.rsc');
-  let optOuts = [];
+  let optOuts = null;
   try {
-    optOuts = readdirSync(dir).filter((f) => f.startsWith('.no-')).map((f) => f.slice(4)).sort();
-  } catch { /* no .rsc yet */ }
+    optOuts = projectOptOuts(readdirSync(dir).filter((f) => f.startsWith('.no-')).map((f) => f.slice(4)));
+  } catch { /* no .rsc yet → null, meaning "unknown", never "none" */ }
   let tier = null;
   try { tier = JSON.parse(readFileSync(join(dir, 'developer.json'), 'utf8')).tier ?? null; } catch { /* unset */ }
   return { optOuts, tier };
 }
 
+// The other half of the same promise: what the declaration says is rebuilt as the real local
+// state a hook can see. Hooks are materialized standalone under `.rsc/` and decide with one
+// `existsSync` — they cannot read the manifest, and making them read it would let a `git pull`
+// change how somebody's session behaves in silence, which `project-manifest` ruled out on
+// purpose. So the manifest is applied HERE, inside the install the person chose to run.
+//
+// Only ever on a machine where `.rsc/` did not exist: there, "no marker" carries no information
+// and the declaration is all there is. Where `.rsc/` is already built, the local state is the
+// authority — otherwise the next sync would silently undo a re-arm, and the gate coming back
+// would look like a bug in the guard rather than a decision nobody made.
+export function hydrateLocalDecisions(cwd, manifest) {
+  const applied = { optOuts: [], tier: null };
+  if (!manifest) return applied;
+  const dir = join(cwd, '.rsc');
+  for (const name of projectOptOuts(manifest.optOuts)) {
+    const file = join(dir, `.no-${name}`);
+    if (existsSync(file)) continue;
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(file, `Declared in .rsc.json by this project; rebuilt here by rsc ${CLI_VERSION}.\n`);
+    applied.optOuts.push(name);
+  }
+  if (manifest.tier && !existsSync(join(dir, 'developer.json'))) {
+    applied.tier = writeDeveloperTier(cwd, manifest.tier);
+  }
+  return applied;
+}
+
 // Record the decision, merging so a second assistant never erases the first: installing
 // into codex on a machine that already had claude is adding, not replacing. Union, sorted
 // where order carries no meaning, so the file stays diffable and a merge conflict stays
@@ -158,17 +198,25 @@ export function recordInManifest({ cwd, target, skillIds, agentIds = [], catalog
     ownSkills: prev.ownSkills || [],
     catalogVersion,
     tier: tier ?? prev.tier ?? null,
-    optOuts: optOuts.length ? optOuts : (prev.optOuts || []),
+    optOuts: optOuts ?? projectOptOuts(prev.optOuts),
     memory: prev.memory,
     onboarding: onboarding ?? prev.onboarding,
   });
 }
 
 export async function applyInstall({ skillIds = [], agentIds = [], target, home, cwd = process.cwd(), operation = 'install', dryRun = false, policy, onboarding }) {
+  // Read BEFORE anything can create it — the backup writes under `.rsc/`, and one line later the
+  // answer would always be "yes, it exists". This single boolean is what separates a clone (the
+  // declaration is the only thing that knows what the team decided) from a built machine (the
+  // local markers are the authority, and a pull must not overwrite them).
+  const fromScratch = !existsSync(join(cwd, '.rsc'));
   const paths = targetPaths(target, home, cwd);
   const plan = planInstall({ skillIds, target, home, cwd, hooks: policy?.alwaysOn !== false });
   const managedPaths = managedPathsForInstall({ skillIds, agentIds, target, home, cwd, policy });
   if (dryRun) return { dryRun: true, skills: skillIds, agents: agentIds, paths: managedPaths };
+  // Rebuild the declared decisions first, so everything below (the agent tier especially) reads
+  // the state the team declared rather than the default it would otherwise assume.
+  if (fromScratch) hydrateLocalDecisions(cwd, readManifest(cwd));
   const state = readState(paths.stateFile);
   const backup = createBackup({ cwd, operation, target, paths: managedPaths, cliVersion: CLI_VERSION });
   // Decide base refresh per skill (see baseVersionsFile): a base is re-materialized when

package/targets/clone-bootstrap.mjs

@@ -33,6 +33,19 @@ import { pathToFileURL, fileURLToPath } from 'node:url';
 const PACKAGE = '@ericrisco/rsc';
 const SEMVER = /^\d+\.\d+\.\d+(?:-[0-9a-z.-]+)?$/i;
 
+/**
+ * The `.no-*` switches that are the TEAM's decision, and therefore the only ones a manifest may
+ * speak about. Canonical copy: `targets/opt-outs.js`, which carries the reasoning.
+ *
+ * Duplicated on purpose and not by oversight. This file is COMMITTED into user repos and runs with
+ * the package possibly not installed, so it cannot import anything — the same constraint that makes
+ * `sello.mjs` a materialized sibling. A test holds the two copies equal, because duplication that
+ * nothing checks is just drift with a head start.
+ */
+export const PROJECT_OPT_OUTS = [
+  'audit', 'claudemd-check', 'danger-guard', 'feature-gate', 'gitmoji', 'ship-guard', 'worktree-cleanup',
+];
+
 /**
  * Validated at the parse boundary AND again here, on purpose.
  *
@@ -93,6 +106,11 @@ export function readManifest(root) {
     // thing to say, and it is what an unusable value becomes.
     catalogVersion: SEMVER.test(String(parsed.catalogVersion ?? '')) ? parsed.catalogVersion : null,
     targets: Array.isArray(parsed.targets) ? parsed.targets : [],
+    // Same allowlist, same reason, and it bites harder here: these names are pasted into the
+    // notice a model reads. A switch is a plain lowercase name or it is not a switch — and only
+    // the ones the team is allowed to decide for everybody get through at all.
+    optOuts: ids(parsed.optOuts).filter((n) => PROJECT_OPT_OUTS.includes(n)).sort(),
+    tier: ['balanced', 'heavy'].includes(parsed.tier) ? parsed.tier : null,
   };
 }
 
@@ -108,7 +126,9 @@ export function readManifest(root) {
  * assuming otherwise. When it cannot be told apart, it is left alone.
  */
 export function evaluateHarness(root, manifest) {
-  if (manifest.state !== 'declared') return { verdict: 'unknown', missing: [], ownMissing: [] };
+  if (manifest.state !== 'declared') {
+    return { verdict: 'unknown', missing: [], ownMissing: [], optOutsMissing: [], tierDiffers: null };
+  }
   // Catalog skills: `.rsc/skills/<id>` is where their content lands, and it is the same on all
   // seventeen assistants — the per-target directories are links into it.
   const fromCatalog = (id) => existsSync(join(root, '.rsc', 'skills', id));
@@ -126,8 +146,23 @@ export function evaluateHarness(root, manifest) {
   const fromTeam = (name) => OWN_DIRS.some((dir) => existsSync(join(root, ...dir, name)));
   const missing = manifest.skills.filter((id) => !fromCatalog(id));
   const ownMissing = manifest.own.filter((name) => !fromTeam(name));
-  if (!missing.length && !ownMissing.length) return { verdict: 'current', missing: [], ownMissing: [] };
-  return { verdict: 'behind', missing, ownMissing };
+  // A gate the team disarmed that is still armed here. Declared-and-missing only, exactly as for
+  // skills above: a marker this machine has and the manifest does not could be a decision somebody
+  // is still making, and this file does not tell people what to think about their own work.
+  const optOutsMissing = manifest.optOuts.filter((n) => !existsSync(join(root, '.rsc', `.no-${n}`)));
+  const tierDiffers = manifest.tier && manifest.tier !== localTier(root) ? manifest.tier : null;
+  if (!missing.length && !ownMissing.length && !optOutsMissing.length && !tierDiffers) {
+    return { verdict: 'current', missing: [], ownMissing: [], optOutsMissing: [], tierDiffers: null };
+  }
+  return { verdict: 'behind', missing, ownMissing, optOutsMissing, tierDiffers };
+}
+
+/** The tier this machine actually runs at — `balanced` is the documented default, not a guess. */
+function localTier(root) {
+  try {
+    return JSON.parse(readFileSync(join(root, '.rsc', 'developer.json'), 'utf8')).tier === 'heavy'
+      ? 'heavy' : 'balanced';
+  } catch { return 'balanced'; }
 }
 
 /**
@@ -149,6 +184,15 @@ export function composeDivergence(manifest, evaluation) {
   if (evaluation.missing.length) {
     text += `MISSING, declared in .rsc.json: ${evaluation.missing.join(', ')}.\n`;
   }
+  // Named as the convention they are, never as the file that implements them: "the team disarmed
+  // the commit-message check" is something a person can agree or disagree with; ".no-gitmoji is
+  // absent" is a fact about a directory they have never opened.
+  if (evaluation.optOutsMissing?.length) {
+    text += `DISARMED BY THE TEAM, still armed here: ${evaluation.optOutsMissing.join(', ')}.\n`;
+  }
+  if (evaluation.tierDiffers) {
+    text += `DECLARED developer tier: ${evaluation.tierDiffers} — this machine runs the default.\n`;
+  }
   // Before the command, never after: anything sitting under the action reads as part of what the
   // action installs, and these are the one thing rsc will not install. Their version is the commit.
   if (evaluation.ownMissing.length) {

package/targets/opt-outs.js

@@ -0,0 +1,40 @@
+// Which `.no-*` switches are the TEAM's decision and which are THIS MACHINE's.
+//
+// `project-manifest` moved disarmed gates into the committed declaration because they are
+// decisions and decisions should not evaporate on `git clone`. What it did not settle is that
+// not every switch is the same kind of decision, and one of them is actively dangerous to share:
+//
+//   `.no-harness` means "do not offer to build the harness ON THIS MACHINE" — the bootstrap says
+//   exactly that when it offers it. Let it travel and one person declining, once, would silence
+//   the offer in every future clone: a whole team losing the harness because somebody's laptop
+//   said no. The same reasoning covers an MCP connection (consent is individual), a check that
+//   compares two scopes of one machine, and a nudge that can only fire in a project with no
+//   `.git/` — which a clone, by construction, is not.
+//
+// A table and not a chain of ifs, so a test can iterate it and `clone-bootstrap.mjs` — which is
+// committed, standalone and cannot import from the package — can be held against it instead of
+// drifting away from it in silence.
+
+/** Decisions of the project: they belong in `.rsc.json` and are rebuilt in a clone. */
+export const PROJECT_OPT_OUTS = [
+  'audit',            // cadence of this project's skill audit
+  'claudemd-check',   // the root CLAUDE.md context budget
+  'danger-guard',     // foot-gun denial, keyed to the committed user profile
+  'feature-gate',     // per-turn re-injection of the SDD gate
+  'gitmoji',          // the commit-message convention
+  'ship-guard',       // branch/trunk discipline
+  'worktree-cleanup', // the reaper's notice (it only ever names, never acts)
+];
+
+/** Decisions of one machine: never written to the manifest, never applied from it. */
+export const MACHINE_OPT_OUTS = [
+  'context7',   // an MCP connection is machine wiring, and its consent is individual
+  'git',        // only fires with no .git/, which a clone cannot be
+  'harness',    // "not offered again ON THIS MACHINE" — the bootstrap's own words
+  'scope-check',// compares the project and home scopes OF THIS MACHINE
+];
+
+export const isProjectOptOut = (name) => PROJECT_OPT_OUTS.includes(name);
+
+/** The project-level subset of a manifest's `optOuts`, unknown names dropped. */
+export const projectOptOuts = (list) => [...new Set((list || []).filter(isProjectOptOut))].sort();