@ericrisco/rsc 2.0.15 → 2.0.17

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.0.15",
+  "version": "2.0.17",
   "counts": {
     "skills": 273,
     "agents": 33,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "2.0.15",
+  "version": "2.0.17",
   "description": "A guided harness builder that turns your goal into a minimal, verified AI-agent setup using strict best practices.",
   "type": "module",
   "bin": {
@@ -89,6 +89,14 @@
     {
       "fixedIn": "2.0.15",
       "symptom": "The 'consider compacting' notice never appears in sessions that edit files through the terminal instead of the Edit tool"
+    },
+    {
+      "fixedIn": "2.0.16",
+      "symptom": "Non-technical or mixed users in a non-software project had no guard against irreversible commands; repair wired guards the plan had declined"
+    },
+    {
+      "fixedIn": "2.0.17",
+      "symptom": "Re-accepting an onboarding plan erased what init had learned about you, reset your explanation level, or dropped an assistant you added later"
     }
   ]
 }

package/scripts/install-apply.js

@@ -78,9 +78,12 @@ export function generatedHookFiles({ target, cwd, policy }) {
     join(cwd, '.rsc', 'hook-once.mjs'),
     join(cwd, '.rsc', 'worktree-reaper.mjs'),
   ];
-  if (policy?.codeHooks === false) return [...lifecycle, join(cwd, '.rsc', 'suggest-always-on.md')];
-  return [...lifecycle,
-    join(cwd, '.rsc', 'ship-guard.mjs'), join(cwd, '.rsc', 'danger-guard.mjs'),
+  // The danger guard is declared on its own terms (#273): present unless the plan says otherwise,
+  // whether or not the code guards are.
+  const danger = policy?.dangerGuard === false ? [] : [join(cwd, '.rsc', 'danger-guard.mjs')];
+  if (policy?.codeHooks === false) return [...lifecycle, ...danger, join(cwd, '.rsc', 'suggest-always-on.md')];
+  return [...lifecycle, ...danger,
+    join(cwd, '.rsc', 'ship-guard.mjs'),
     join(cwd, '.rsc', 'gitmoji-guard.mjs'), join(cwd, '.rsc', 'userprompt-gate.mjs'),
     join(cwd, '.rsc', 'sello.mjs')];
 }
@@ -279,6 +282,7 @@ export async function applyInstall({ skillIds = [], agentIds = [], target, home,
     baseAgents: policy.baseAgents !== false,
     alwaysOn: policy.alwaysOn !== false,
     codeHooks: policy.codeHooks !== false,
+    dangerGuard: policy.dangerGuard !== false,
     gitmojiGuard: policy.gitmojiGuard !== false,
     memory: policy.memory !== false,
     context7: policy.context7 === true,

package/scripts/lib/onboarding-apply.js

@@ -83,18 +83,69 @@ function recoveryCommand(plan, planId) {
 }
 
 export function renderOnboardingDocuments(plan, planId) {
-  const profile = `---\ntechnical_level: ${plan.record.technicalLevel}\naccompaniment: ${plan.record.accompaniment}\nproject_kind: ${plan.record.projectKind}\n---\n\n# User profile\n\nGoal: ${plan.record.goal}\n`;
+  // `accompaniment_level`, never `accompaniment` (#276). It sits beside `technical_level` in the same
+  // block, and it is the name the nine skill files that read the dial — orient first among them —
+  // have always used. This was the only writer of the short form, which left the dial chosen at
+  // onboarding invisible to the compass.
+  const profile = `---\ntechnical_level: ${plan.record.technicalLevel}\naccompaniment_level: ${plan.record.accompaniment}\nproject_kind: ${plan.record.projectKind}\n---\n\n# User profile\n\nGoal: ${plan.record.goal}\n`;
   const rows = plan.decisions.map((d) => `| ${d.kind} | ${d.id} | ${d.state} | ${d.reason} | ${d.reevaluateWhen.join('; ') || '—'} |`).join('\n');
   const installation = `# Accepted harness plan\n\nPlan id: \`${planId}\`\n\n| Kind | Component | Decision | Reason | Reevaluate when |\n| --- | --- | --- | --- | --- |\n${rows}\n`;
   const decisions = `# Harness decisions\n\n- Accepted plan \`${planId}\`.\n- Project kind: ${plan.record.projectKind}.\n- SDD: ${plan.decisions.find((d) => d.id === 'sdd')?.state || 'selected through profile'}.\n`;
   return { profile, installation, decisions };
 }
 
-export function writeOnboardingDocuments(cwd, plan, planId) {
+const PROFILE_DIALS = [['technical_level', 'technicalLevel'], ['accompaniment_level', 'accompaniment']];
+
+/**
+ * The profile is the USER's file; accepting a plan seeds it, it does not own it (#278).
+ *
+ * `init` records there what it learns — the domain, the tools, what must not be touched — and `orient`
+ * rewrites the dial when someone asks for more or less explanation. Regenerating the file on every
+ * accept erased both, and re-accepting is routine: after an update, after a reassess.
+ *
+ * So: everything the plan does not own is kept byte for byte. `project_kind` and the goal are facts of
+ * the plan and are updated. The two dials are the subtle part — the plan carries them, but after first
+ * contact the user adjusts them — so an existing value stands when the plan did not CHANGE it relative
+ * to the previous receipt, and an explicit new value (a receipt that said L3, a plan that says L2) is
+ * applied. A profile written before the rename carries `accompaniment:`; it is migrated, never
+ * duplicated.
+ */
+export function mergeProfile(existing, plan, previousRecord) {
+  const fresh = renderOnboardingDocuments(plan, '').profile;
+  if (!existing || !existing.trim()) return fresh;
+  const text = existing.replace(/\r\n/g, '\n');
+  const block = /^---\n([\s\S]*?)\n---\n?/.exec(text);
+  let front = block ? block[1].split('\n') : [];
+  let body = block ? text.slice(block[0].length) : text;
+  const has = (key) => front.some((line) => line.startsWith(`${key}:`));
+  front = has('accompaniment_level')
+    ? front.filter((line) => !/^accompaniment:\s/.test(line))
+    : front.map((line) => line.replace(/^accompaniment:(\s)/, 'accompaniment_level:$1'));
+  const get = (key) => front.find((line) => line.startsWith(`${key}:`))?.slice(key.length + 1).trim() || null;
+  const set = (key, value) => {
+    const at = front.findIndex((line) => line.startsWith(`${key}:`));
+    if (at >= 0) front[at] = `${key}: ${value}`;
+    else front.push(`${key}: ${value}`);
+  };
+  for (const [key, field] of PROFILE_DIALS) {
+    const planned = plan.record[field];
+    const keptByUser = get(key) && previousRecord && previousRecord[field] === planned;
+    if (!keptByUser) set(key, planned);
+  }
+  set('project_kind', plan.record.projectKind);
+  const goal = `Goal: ${plan.record.goal}`;
+  if (/^Goal: .*$/m.test(body)) body = body.replace(/^Goal: .*$/m, () => goal);
+  else if (/^# User profile[ \t]*$/m.test(body)) body = body.replace(/^# User profile[ \t]*$/m, () => `# User profile\n\n${goal}`);
+  else body = `${body.replace(/\s*$/, '')}\n\n${goal}\n`;
+  return `---\n${front.join('\n')}\n---\n${body.startsWith('\n') ? '' : '\n'}${body}`;
+}
+
+export function writeOnboardingDocuments(cwd, plan, planId, previousRecord = null) {
   const dir = join(cwd, '02-DOCS', 'wiki', 'harness');
   mkdirSync(dir, { recursive: true });
   const docs = renderOnboardingDocuments(plan, planId);
-  writeFileSync(join(dir, 'user-profile.md'), docs.profile);
+  const profilePath = join(dir, 'user-profile.md');
+  writeFileSync(profilePath, mergeProfile(existsSync(profilePath) ? readFileSync(profilePath, 'utf8') : '', plan, previousRecord));
   writeFileSync(join(dir, 'installation-plan.md'), docs.installation);
   const decisionsPath = join(dir, 'decisions.md');
   if (!existsSync(decisionsPath)) writeFileSync(decisionsPath, docs.decisions);
@@ -134,12 +185,15 @@ export function verifyOnboarding(cwd, plan, planId) {
   }
   const docsDir = join(cwd, '02-DOCS', 'wiki', 'harness');
   const profile = existsSync(join(docsDir, 'user-profile.md')) ? readFileSync(join(docsDir, 'user-profile.md'), 'utf8') : '';
-  for (const line of [
-    `technical_level: ${plan.record.technicalLevel}`,
-    `accompaniment: ${plan.record.accompaniment}`,
-    `project_kind: ${plan.record.projectKind}`,
-    `Goal: ${plan.record.goal}`,
-  ]) if (!profile.split('\n').includes(line)) differences.push(`profile content differs: ${line.split(':')[0]}`);
+  // The plan's facts must be exactly there. The dials must be there under their one name with a valid
+  // value — not necessarily the plan's, because a dial the user adjusted and the plan did not change
+  // is theirs (see mergeProfile).
+  for (const line of [`project_kind: ${plan.record.projectKind}`, `Goal: ${plan.record.goal}`]) {
+    if (!profile.split('\n').includes(line)) differences.push(`profile content differs: ${line.split(':')[0]}`);
+  }
+  if (!/^technical_level: (non-technical|mixed|technical)$/m.test(profile)) differences.push('profile content differs: technical_level');
+  if (!/^accompaniment_level: L[0-3]$/m.test(profile)) differences.push('profile content differs: accompaniment_level');
+  if (/^accompaniment: /m.test(profile)) differences.push('profile carries the retired accompaniment key');
   const installation = existsSync(join(docsDir, 'installation-plan.md')) ? readFileSync(join(docsDir, 'installation-plan.md'), 'utf8') : '';
   if (!installation.includes(`Plan id: \`${planId}\``)) differences.push('installation plan identity differs');
   for (const decision of plan.decisions || []) {
@@ -148,7 +202,8 @@ export function verifyOnboarding(cwd, plan, planId) {
   }
   const decisions = existsSync(join(docsDir, 'decisions.md')) ? readFileSync(join(docsDir, 'decisions.md'), 'utf8') : '';
   if (!decisions.includes(`Accepted plan \`${planId}\``)) differences.push('decision ledger omits accepted plan');
-  if (!sameSet(manifest?.targets || [], plan.policy.targets)) differences.push('manifest targets differ from accepted policy');
+  // Every planned assistant is declared; an extra one added outside the plan may be too (#278).
+  if (!plan.policy.targets.every((t) => (manifest?.targets || []).includes(t))) differences.push('manifest targets differ from accepted policy');
   if (!sameSet(manifest?.skills || [], plan.policy.skills)) differences.push('manifest skills differ from accepted policy');
   if (!sameSet(manifest?.agents || [], plan.policy.agents || [])) differences.push('manifest agents differ from accepted policy');
   return differences;
@@ -200,7 +255,7 @@ export async function applyAcceptedOnboarding({ cwd = process.cwd(), plan, planI
       });
     }
     pruneSharedBases({ cwd, skillIds: plan.policy.skills });
-    writeOnboardingDocuments(cwd, plan, planId);
+    writeOnboardingDocuments(cwd, plan, planId, previousPlan?.record || null);
     receipt.provenance.paths = Object.fromEntries((plan.governedPaths || []).map((path) => [
       path,
       existed[path] ? (previousReceipt ? 'conserved' : 'preexisting') : 'installed',
@@ -209,7 +264,13 @@ export async function applyAcceptedOnboarding({ cwd = process.cwd(), plan, planI
     const manifest = readManifest(cwd);
     writeManifest(cwd, {
       ...manifest,
-      targets: [...plan.policy.targets],
+      // Union, with the distinction the removal loop above already makes (#278). An assistant that was
+      // in the previous PLAN and is not in this one was removed on purpose. One added OUTSIDE the plan
+      // — `sync --target codex` — is still installed, and dropping it from the declaration meant a
+      // clone would never build it again.
+      targets: [...plan.policy.targets, ...(previousManifest?.targets || []).filter((t) => !plan.policy.targets.includes(t)
+        && !(previousPlan?.policy?.targets || []).includes(t)
+        && existsSync(targetPaths(t, undefined, cwd).stateFile))],
       skills: [...plan.policy.skills],
       agents: [...(plan.policy.agents || [])],
       onboarding: receipt,

package/scripts/lib/onboarding.js

@@ -230,6 +230,13 @@ export function buildOnboardingPlan(record, evidence) {
   const hooks = practisesSdd;
   const agents = baseAgents ? resolveAgentNames(skills, []).sort() : [];
   const gitmojiGuard = hooks && normalized.targets.includes('claude');
+  // The danger guard is NOT code machinery, and tying it to `hooks` was the mistake behind #273. The
+  // three guards above need a code project with git — a branch to protect, a commit to lint. This one
+  // stops recursive deletes, history-rewriting pushes and friends, which are exactly as irreversible
+  // in an invoicing workspace, and `init` promises it by technical level: non-technical and mixed get
+  // it, whatever the project is. The guard also decides at runtime from the profile, so the plan only
+  // chooses whether it is present, never whether it bites.
+  const dangerGuard = normalized.technicalLevel !== 'technical';
   // `sdd` is installed everywhere now, but its DECISION is about practice, not presence — so where
   // the chain is not practised the explicit `deferred` entry below must be the only one, or the
   // generic "installed → selected" mapping would shadow it and `reassess` would see nothing to watch.
@@ -276,6 +283,7 @@ export function buildOnboardingPlan(record, evidence) {
     alwaysOn: true,
     codeHooks: practisesSdd,
     gitmojiGuard,
+    dangerGuard,
     memory: true,
     context7: false,
   };

package/scripts/lib/repair.js

@@ -131,22 +131,26 @@ export async function repair({ cwd = process.cwd(), target, home = homedir(), dr
 
   const paths = targetPaths(target, home, cwd);
   const ids = [...new Set([...Object.keys(readState(paths.stateFile).skills || {}), ...(readManifest(cwd)?.skills || [])])];
+  // The accepted plan governs a repair exactly as it governs a sync. Without it, `wireHook` saw `{}`,
+  // read `codeHooks !== false` as true and wired every guard the plan had declined — and the next
+  // `sync`, which does pass the policy, took them away again (#274). Restoring is not deciding.
+  const policy = readManifest(cwd)?.onboarding?.plan?.policy;
   const backup = createBackup({
     cwd, operation: 'repair', target,
-    paths: managedPathsForInstall({ skillIds: ids, target, home, cwd }),
+    paths: managedPathsForInstall({ skillIds: ids, target, home, cwd, policy }),
   });
 
   for (const f of todo) {
     if (f.id === 'nested-layout') rmSync(join(paths.root, 'rsc'), { recursive: true, force: true });
-    if (f.id === 'duplicate-hooks') { unwireHook(target, paths); await applyInstall({ skillIds: ids, target, home, cwd, operation: 'repair' }); }
-    if (f.id === 'dangling-links') await applyInstall({ skillIds: ids, target, home, cwd, operation: 'repair' });
+    if (f.id === 'duplicate-hooks') { unwireHook(target, paths); await applyInstall({ skillIds: ids, target, home, cwd, operation: 'repair', policy }); }
+    if (f.id === 'dangling-links') await applyInstall({ skillIds: ids, target, home, cwd, operation: 'repair', policy });
     if (f.id === 'no-manifest') recordInManifest({ cwd, target, skillIds: ids });
     if (f.id === 'wrong-target') {
       // Install where the project actually points, THEN take the old wiring down — in that
       // order, so a failure halfway leaves a working harness rather than none. Taking the
       // block out of the old file gives it back byte-identical: in #249 that file was the
       // project's hand-written constitution, and it had already been written into once.
-      await applyInstall({ skillIds: ids, target: f.to, home, cwd, operation: 'repair' });
+      await applyInstall({ skillIds: ids, target: f.to, home, cwd, operation: 'repair', policy });
       unwireHook(target, paths);
       removeManagedSkills(paths);
       recordInManifest({ cwd, target: f.to, skillIds: ids, dropTarget: target });

package/skills/init/references/accompaniment-and-profile.md

@@ -41,7 +41,7 @@ Defaults when the user gives no preference: `non-technical → L3`, `mixed → L
 
 ## How every skill adapts
 
-Both values combine. `accompaniment_level` controls **how much** is said and **how many questions** are asked; `technical_level` controls **the vocabulary**.
+Both values combine. `accompaniment_level` controls **how much** is said and **how many questions** are asked; `technical_level` controls **the vocabulary**. A profile written by an older `onboard` may carry `accompaniment:` instead — it is the same dial; read it, and write `accompaniment_level` the next time you touch the profile.
 
 | Level | Output verbosity | Questions before acting | On a decision |
 | --- | --- | --- | --- |

package/skills/orient/SKILL.md

@@ -38,7 +38,7 @@ Knowledge map or the repo before writing 📍 — an invented state is worse tha
 ## Calibrate to the dial
 
 Read `02-DOCS/wiki/harness/user-profile.md` before writing the block. Two fields combine:
-`accompaniment_level` sets the depth, `technical_level` sets the vocabulary.
+`accompaniment_level` sets the depth, `technical_level` sets the vocabulary. A profile written by an older `onboard` may carry `accompaniment:` instead — it is the same dial; read it, and write `accompaniment_level` the next time you touch the profile.
 
 | accompaniment_level | How the block behaves |
 |---------------------|-----------------------|

package/skills/orient/references/orientation-contract.md

@@ -19,7 +19,7 @@ could leave the user unsure closes with the brújula block.
 
 ## Calibration (the dial)
 
-Read `02-DOCS/wiki/harness/user-profile.md`. Two fields combine: `accompaniment_level` (L0 | L1 | L2 | L3) sets how deep the block goes; `technical_level` (non-technical | mixed | technical) sets the vocabulary.
+Read `02-DOCS/wiki/harness/user-profile.md`. Two fields combine: `accompaniment_level` (L0 | L1 | L2 | L3) sets how deep the block goes; `technical_level` (non-technical | mixed | technical) sets the vocabulary. A profile written by an older `onboard` may carry `accompaniment:` instead — it is the same dial; read it, and write `accompaniment_level` the next time you touch the profile.
 
 - **L0 — cavernícola:** only `✅` + `➡️`, one option, yes/no question.
 - **L1 — breve:** the four lines; one line of why.

package/targets/claude.js

@@ -179,18 +179,6 @@ export function wireHook(paths, sourceMd, policy = {}) {
   );
   settings.hooks.PreToolUse.push({ matcher: 'Bash', hooks: [{ type: 'command', command: sgCmd }] });
 
-  // Danger guard: a PreToolUse(Bash) hook that DENIES irreversible foot-gun commands
-  // (rm -rf, git push --force, DROP/TRUNCATE, DELETE/UPDATE without WHERE, dd to /dev,
-  // curl|bash, …) when the user-profile says the user is NON-technical (default-safe
-  // when no profile exists yet; never guards a fully `technical` user). Materialized +
-  // node-run (Windows-safe), idempotent, fail-open, opt-out via .rsc/.no-danger-guard.
-  const dgDest = join(paths.projectRoot, '.rsc', 'danger-guard.mjs');
-  copyFileSync(join(HERE, 'danger-guard.mjs'), dgDest);
-  const dgCmd = viaBootstrap('guard', at('.rsc', 'danger-guard.mjs'), `"${P}"`);
-  settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(
-    (e) => !hookWiringOf(e).includes('.rsc/danger-guard.'),
-  );
-  settings.hooks.PreToolUse.push({ matcher: 'Bash', hooks: [{ type: 'command', command: dgCmd }] });
 
   // Gitmoji guard: a PreToolUse(Bash) hook that DENIES a `git commit` whose message
   // carries no gitmoji (gitmoji.dev) in front of the Conventional Commits header. The
@@ -223,23 +211,45 @@ export function wireHook(paths, sourceMd, policy = {}) {
     (e) => !hookWiringOf(e).includes('.rsc/userprompt-gate.'),
   );
   settings.hooks.UserPromptSubmit.push({ hooks: [{ type: 'command', command: fgCmd }] });
-  written.push(sgDest, dgDest, gmDest, fgDest, join(paths.projectRoot, '.rsc', 'sello.mjs'));
+  written.push(sgDest, gmDest, fgDest, join(paths.projectRoot, '.rsc', 'sello.mjs'));
   } else {
     for (const event of ['PreToolUse', 'UserPromptSubmit']) {
       if (!settings.hooks[event]) continue;
       settings.hooks[event] = settings.hooks[event].filter((entry) => {
         const body = hookWiringOf(entry);
-        return !body.includes('.rsc/ship-guard.') && !body.includes('.rsc/danger-guard.') &&
+        return !body.includes('.rsc/ship-guard.') &&
           !body.includes('.rsc/gitmoji-guard.') && !body.includes('.rsc/userprompt-gate.');
       });
       if (!settings.hooks[event].length) delete settings.hooks[event];
     }
-    for (const name of ['ship-guard.mjs', 'danger-guard.mjs', 'gitmoji-guard.mjs', 'userprompt-gate.mjs', 'sello.mjs']) {
+    for (const name of ['ship-guard.mjs', 'gitmoji-guard.mjs', 'userprompt-gate.mjs', 'sello.mjs']) {
       rmSync(join(paths.projectRoot, '.rsc', name), { force: true });
     }
     written.push(operationsSuggest);
   }
 
+  // Danger guard: its own decision, not part of the code-hook block above (#273). `init` promises it
+  // to non-technical and mixed users whatever the project is, and a plan that predates the field is
+  // read as "yes": a non-technical operations install gets the guard it was missing on its next sync,
+  // and a technical user gets a guard that stands down at runtime.
+  settings.hooks.PreToolUse ||= [];
+  settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter((e) => !hookWiringOf(e).includes('.rsc/danger-guard.'));
+  if (policy.dangerGuard !== false) {
+    // Danger guard: a PreToolUse(Bash) hook that DENIES irreversible foot-gun commands
+    // (rm -rf, git push --force, DROP/TRUNCATE, DELETE/UPDATE without WHERE, dd to /dev,
+    // curl|bash, …) when the user-profile says the user is NON-technical (default-safe
+    // when no profile exists yet; never guards a fully `technical` user). Materialized +
+    // node-run (Windows-safe), idempotent, fail-open, opt-out via .rsc/.no-danger-guard.
+    const dgDest = join(paths.projectRoot, '.rsc', 'danger-guard.mjs');
+    copyFileSync(join(HERE, 'danger-guard.mjs'), dgDest);
+    const dgCmd = viaBootstrap('guard', at('.rsc', 'danger-guard.mjs'), `"${P}"`);
+    settings.hooks.PreToolUse.push({ matcher: 'Bash', hooks: [{ type: 'command', command: dgCmd }] });
+    written.push(dgDest);
+  } else {
+    rmSync(join(paths.projectRoot, '.rsc', 'danger-guard.mjs'), { force: true });
+  }
+  if (!settings.hooks.PreToolUse.length) delete settings.hooks.PreToolUse;
+
   mkdirSync(dirname(file), { recursive: true });
   writeFileSync(file, JSON.stringify(settings, null, 2) + '\n');