@damiangilgonzalez/harness 1.3.13 → 1.3.15

package/README.md

@@ -8,7 +8,7 @@
 
 [![npm](https://img.shields.io/npm/v/@damiangilgonzalez/harness?color=63d68a&labelColor=12161c&label=npm)](https://www.npmjs.com/package/@damiangilgonzalez/harness)
 [![downloads](https://img.shields.io/npm/dm/@damiangilgonzalez/harness?color=63d68a&labelColor=12161c&label=downloads)](https://www.npmjs.com/package/@damiangilgonzalez/harness)
-[![skills](https://img.shields.io/badge/skills-291-63d68a?labelColor=12161c)](#the-catalog)
+[![skills](https://img.shields.io/badge/skills-294-63d68a?labelColor=12161c)](#the-catalog)
 [![license](https://img.shields.io/badge/license-MIT-63d68a?labelColor=12161c)](LICENSE)
 [![stars](https://img.shields.io/github/stars/ericrisco/rsc-harness?color=63d68a&labelColor=12161c)](https://github.com/ericrisco/rsc-harness/stargazers)
 
@@ -73,6 +73,9 @@ accompaniment, project kind and goal **before it writes anything**, reads only t
 root, and shows every selected or deferred skill, agent and hook with its reason. Relay those
 questions to the user; never invent or default their answers. The first pass writes nothing and
 prints a SHA-256 plan id. Only rerun with `--accept-plan <id>` after the user accepts that exact plan.
+If the project already has a skill of its own with a catalog name, the plan lists it under
+**Your own skills this plan replaces** — tell the user before accepting; renaming their folder and
+regenerating the plan keeps theirs.
 
 For a non-interactive agent, collect the answers and preview the same plan explicitly:
 
@@ -202,7 +205,7 @@ $ rsc onboard
  ██████╗ ███████╗ ██████╗     ← animated gradient wordmark
  ██╔══██╗██╔════╝██╔════╝
  ██████╔╝███████╗██║
-  291 skills · one CLI · zero bloat
+  294 skills · one CLI · zero bloat
 
 How technical should the conversation be?
 How much accompaniment do you want?
@@ -241,13 +244,13 @@ rsc add youtube-api remotion-video   # …grow a channel, edit with Remotion
 rsc add fastapi --target claude,codex   # install into several assistants at once
 rsc install --profile minimal        # the base: orient + suggest + bro + unslop + show-me + eli5 + harness + init + teach
 rsc install --profile core           # floor + the full SDD workflow
-rsc install --profile full           # everything (all 291 skills)
+rsc install --profile full           # everything (all 294 skills)
 rsc install --profile full --without go
 rsc consult "I want to launch a SaaS"  # recommend only, no install
 rsc registry refresh                 # write .rsc/skill-registry.{json,md}
 rsc list                             # installed skills, agents and commands
 rsc capabilities                    # installed/available surfaces + memory mode
-rsc doctor                           # health, missing backing, hooks and local memory
+rsc doctor                           # health, missing backing, hooks and local memory; exits 1 when unhealthy
 rsc memory status                    # full / assisted / unsupported / degraded
 rsc memory save --session handoff    # force a deterministic local checkpoint
 rsc memory resume                    # print this branch/worktree continuation
@@ -405,7 +408,7 @@ just asks in plain language.
 
 ## The catalog
 
-291 skills, grouped by what you're trying to do. Click any skill to read its
+294 skills, grouped by what you're trying to do. Click any skill to read its
 `SKILL.md`. It fires on its own when a task matches.
 
 ### 🧭 Core & control plane
@@ -584,7 +587,8 @@ inside `grill-with-docs`.
 
 | Skill | What it does |
 |---|---|
-| [implement](skills/implement/) | Builds one ticket from `to-tickets`. Ordinary work runs `superpowers:executing-plans` instead. |
+| [implement-spec](skills/implement-spec/) | Builds a whole spec from its `to-tickets` graph: parallel subagents in worktrees, one integration branch, `code-review` at the end. |
+| [implement](skills/implement/) | Builds one loose ticket from `to-tickets`. Ordinary work runs `superpowers:executing-plans` instead. |
 
 #### 3 · Interface
 
@@ -618,14 +622,15 @@ When the work touches a screen. Sixteen overlapping skills; pick the one that ma
 
 | The work | Order |
 |---|---|
-| Did not touch a screen | `code-review` |
-| Touched a screen | `revision-de-cambios` → `revision-interfaz` → `code-review` |
+| Did not touch a screen | `code-review` → `pr` |
+| Touched a screen | `revision-de-cambios` → `revision-interfaz` → `code-review` → `pr` |
 
 | Skill | What it does |
 |---|---|
 | [code-review](skills/code-review/) | Two axes in parallel: the repo's standards and the spec. |
 | [revision-de-cambios](skills/revision-de-cambios/) | Reviews the change, reads the removed lines and classifies each finding. Only if it touched a screen. |
 | [revision-interfaz](skills/revision-interfaz/) | Runs the six `mejor-*` skills as one report with a verdict. Only if it touched a screen. |
+| [pr](skills/pr/) | Writes the PR body: a visual summary, before/after evidence, and the merge danger (one-way or two-way door, blast radius). |
 | [handoff](skills/handoff/) | Compacts the session into a handoff document. Optional. |
 
 #### 9 · Other
@@ -635,6 +640,7 @@ When the work touches a screen. Sixteen overlapping skills; pick the one that ma
 | [teach](skills/teach/) | Teaching across sessions. |
 | [muscle-memory](skills/muscle-memory/) | A Python kata gym. |
 | [wait-what](skills/wait-what/) | Handbrake: stop and restate. |
+| [retro](skills/retro/) | Retrospective on a session: what to change in the agent's environment. You approve every change. |
 | [writing-for-agents](skills/writing-for-agents/) | How to write documents an agent consumes. |
 
 ---
@@ -682,7 +688,7 @@ The richer surfaces are intentionally narrower than skill support:
 | Windsurf, Cline, Roo | unsupported | yes | unsupported |
 | Antigravity, Zed, Continue, Amp, Jules, Aider | unsupported | unsupported | unsupported |
 
-`manifest.json` is the generated public inventory: 33 agents (4 base + 29
+`manifest.json` is the generated public inventory: 34 agents (5 base + 29
 selective specialists) and 43 command entries (10 fixed + 33 stack aliases).
 Unsupported means rsc writes nothing for that surface; it does not emulate a
 provider feature with an unverified file.

package/manifest.json

@@ -1,8 +1,8 @@
 {
-  "version": "1.3.13",
+  "version": "1.3.15",
   "counts": {
-    "skills": 291,
-    "agents": 33,
+    "skills": 294,
+    "agents": 34,
     "commands": 43,
     "fixedCommands": 10
   },
@@ -1395,7 +1395,7 @@
     },
     {
       "id": "domain-modeling",
-      "description": "Build and refine the project's domain model. Use when the user wants to pin down domain terminology or a ubiquitous language, record an architectural decision, or when another skill needs to keep the domain model up to date.",
+      "description": "Build and sharpen the project's domain model. Use when discussing codebase terminology, writing or editing a GLOSSARY.md, or recording or editing an ADR.",
       "tags": [
         "domain-modeling",
         "glossary",
@@ -2467,6 +2467,23 @@
         "full"
       ]
     },
+    {
+      "id": "implement-spec",
+      "description": "Implement the result of /to-spec and /to-tickets in code, orchestrating parallel implementer subagents over the ticket graph.",
+      "tags": [
+        "implementation",
+        "spec",
+        "tickets",
+        "subagents",
+        "orchestration"
+      ],
+      "recommends": [],
+      "profiles": [
+        "core",
+        "ui",
+        "full"
+      ]
+    },
     {
       "id": "ingeniero-diseno-web",
       "description": "Build or redesign polished visual artifacts that render in a browser with HTML/CSS/JavaScript/React — pages, dashboards, prototypes, presentations, animations, UI mockups, and data visualizations. Use for visual front-end creation, design-system exploration, design critique, or explicit browser-based acceptance/QA. Not for back-end, CLI, non-visual code, or converting sources into long-form articles.",
@@ -3786,6 +3803,22 @@
         "full"
       ]
     },
+    {
+      "id": "pr",
+      "description": "Use when writing a PR body: a visual summary, before/after evidence, and the merge danger (one-way or two-way door, blast radius).",
+      "tags": [
+        "pull-request",
+        "review",
+        "evidence",
+        "risk"
+      ],
+      "recommends": [],
+      "profiles": [
+        "core",
+        "ui",
+        "full"
+      ]
+    },
     {
       "id": "presentations",
       "description": "Use when building, theming, or exporting a presentation deck — pitch, sales, keynote, board/QBR, leave-behind one-pager — from slide structure to a token-based theme to PDF or editable PPTX (Marp, Slidev, python-pptx). NOT the words (that is `marketing`), NOT the visual tokens (that is `design`), NOT the investor story arc (that is `pitch-deck`).",
@@ -4288,6 +4321,21 @@
       ],
       "profiles": []
     },
+    {
+      "id": "retro",
+      "description": "Conduct a retrospective on a coding session: find what in the agent's environment (navigation, checks, standards, steering files, tooling) should change so future runs go better.",
+      "tags": [
+        "retrospective",
+        "session-review",
+        "agent-environment"
+      ],
+      "recommends": [],
+      "profiles": [
+        "core",
+        "ui",
+        "full"
+      ]
+    },
     {
       "id": "review-management",
       "description": "Use when a public review needs an on-voice reply, when you need to earn more reviews legally, or when an aggregate rating is slipping across Google Business Profile, Trustpilot, the App Store or Google Play — including deciding reply versus flag, getting an unfair one-star removed rather than merely answered, and wiring programmatic replies. NOT a private support ticket against an SLA (that is `customer-support`), NOT churn, NPS or save plays (that is `retention`).",
@@ -5988,6 +6036,14 @@
         "fastapi"
       ]
     },
+    {
+      "id": "finding-verifier",
+      "description": "Adversarial verifier of review findings: takes ONE consolidated finding and tries to prove it false against the code. Default stance: the finding is false; only a reproduced or traced failure is CONFIRMED. Fresh context, edits nothing.",
+      "role": "refuter",
+      "tier": "balanced",
+      "tools": null,
+      "skills": []
+    },
     {
       "id": "flutter-build-resolver",
       "description": "Flutter build resolver: reproduces a failing build and applies the minimum verified repair. NOT widget review or package modernization.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@damiangilgonzalez/harness",
-  "version": "1.3.13",
+  "version": "1.3.15",
   "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

@@ -65,6 +65,10 @@ function selloStatus(root) {
 //
 // Hookless targets get an empty list by construction: their always-on surface is a
 // markdown block with no script behind it, so there is nothing that can go missing.
+// A quoted span counts as a path only if it starts like one and holds no shell operator: a whole
+// `sh -c '…'` snippet is not a path, and reading it as one reports a present script missing.
+const SCRIPT_RE =
+  /"((?:[A-Za-z]:)?[\\/~][^"&;|]*[\\/]\.rsc[\\/][^"\s]+?\.mjs)"|'((?:[A-Za-z]:)?[\\/~][^'&;|]*[\\/]\.rsc[\\/][^'\s]+?\.mjs)'|([^"'\s]*[\\/]\.rsc[\\/][^"'\s]+\.mjs)/g;
 export function missingHookScripts({ target, home = homedir(), cwd = process.cwd() } = {}) {
   if (HOOKLESS_TARGETS.has(target)) return [];
   const file = targetPaths(target, home, cwd).hookTarget;
@@ -84,8 +88,10 @@ export function missingHookScripts({ target, home = homedir(), cwd = process.cwd
   const expand = (c) => c.split('${CLAUDE_PROJECT_DIR}').join(cwd);
   for (const raw of commands) {
     const cmd = expand(raw);
-    for (const m of cmd.matchAll(/["']?([^"'\s]*[\\/]\.rsc[\\/][^"'\s]+\.mjs)["']?/g)) {
-      const script = m[1];
+    // Quoted forms first: a project path may hold a space, and stopping at whitespace kept only
+    // the tail (`entreno/.rsc/x.mjs`), which then resolved against the cwd and read as missing (#283).
+    for (const m of cmd.matchAll(SCRIPT_RE)) {
+      const script = m[1] ?? m[2] ?? m[3];
       if (!existsSync(script)) seen.add(script);
     }
   }
@@ -202,7 +208,7 @@ export function doctor({ target, home, cwd }) {
   const missingAgents = (state.agents || []).filter((id) => {
     const path = agentPath(target, root, id);
     return path && !existsSync(path);
-  }).map((id) => ({ id, action: 'Run `npx @damiangilgonzalez/harness sync` to restore this managed agent.' }));
+  }).map((id) => ({ id, path: agentPath(target, root, id), action: 'Run `npx @damiangilgonzalez/harness sync` to restore this managed agent.' }));
   const report = {
     target,
     installed: Object.keys(state.skills),
@@ -252,9 +258,12 @@ export function doctor({ target, home, cwd }) {
     commandOrphans,
     commandCollisions: state.commandCollisions || [],
   };
+  // #277 — the three "missing" lists share one shape, { id, path, action }, so whoever builds on top
+  // of doctor reads them the same way; and `healthy` is what the exit code says.
   for (const [id, e] of Object.entries(state.skills)) {
-    for (const f of e.files) if (!existsSync(f)) report.missing.push(`${id}:${f}`);
+    for (const f of e.files) if (!existsSync(f)) report.missing.push({ id, path: f, action: 'Run `npx @ericrisco/rsc sync` to restore this managed skill.' });
   }
+  report.healthy = report.hookWired && !report.missing.length && !missingAgents.length && !missingCommands.length;
   return report;
 }
 

package/scripts/install-apply.js

@@ -12,7 +12,7 @@ import {
 } 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 { withCodeFlowFloor, withDefaultSkillFloor } from './lib/default-skill-floor.js';
 import { readManifest, writeManifest } from './lib/manifest-file.js';
 import { createBackup } from './lib/backups.js';
 import {
@@ -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,
@@ -396,12 +400,24 @@ export function ignoreLocalState(cwd = process.cwd(), target) {
   }
 
   const add = wanted.filter((w) => !present.has(norm(w)));
-  if (!add.length) return null;
+  // Every append used to open a new block with its own header, so a project synced across a dozen
+  // versions carried a dozen copies of it. Adjacent rsc blocks are one block: fold them (only our
+  // header lines and the blank seams between our blocks go; every entry stays, in order).
+  const folded = foldIgnoreBlocks(text);
+  if (!add.length) {
+    if (folded === text) return null;
+    try { writeFileSync(gi, folded); return gi; } catch { return null; }
+  }
 
-  // Append only. Never rewrite, never reorder: the rest of that file is theirs.
-  const prefix = text === '' ? '' : (text.endsWith('\n') ? '' : '\n');
+  // Never reorder, never touch a line of theirs. When the file already ends with our block, the new
+  // entries join it; otherwise they open one.
+  const base = folded === '' || folded.endsWith('\n') ? folded : `${folded}\n`;
+  const next = endsWithIgnoreBlock(base)
+    ? `${base}${add.join('\n')}\n`
+    : `${base}${base === '' ? '' : '\n'}${RSC_IGNORE_HEADER}\n${add.join('\n')}\n`;
   try {
-    appendFileSync(gi, `${prefix}\n# rsc local state (hooks, seals, logs) and managed skill links — machine-local\n${add.join('\n')}\n`);
+    if (folded === text && next.startsWith(text)) appendFileSync(gi, next.slice(text.length));
+    else writeFileSync(gi, next);
     if (target) {
       const statePath = targetPaths(target, undefined, cwd).stateFile;
       const state = readState(statePath);
@@ -418,6 +434,14 @@ export function collisions({ cwd = process.cwd(), target, home, skillIds = [] })
   return skillIds.filter((id) => !managed.has(id) && existsSync(paths.skillDir(id)));
 }
 
+// The same test as `collisions`, across every target of a plan, as the paths the user would recognise.
+// `onboard` puts these in the plan itself, so the id the user accepts is an id that names them.
+export function ownSkillPaths({ cwd = process.cwd(), targets = [], skillIds = [], home }) {
+  const found = targets.flatMap((target) => collisions({ cwd, target, home, skillIds })
+    .map((id) => relative(cwd, targetPaths(target, home, cwd).skillDir(id)).split(sep).join('/')));
+  return [...new Set(found)].sort();
+}
+
 export function listInstalled({ target, home, cwd = process.cwd() }) {
   const paths = targetPaths(target, home, cwd);
   return Object.keys(readState(paths.stateFile).skills);
@@ -602,7 +626,10 @@ export async function syncInstalled({ target, home, cwd = process.cwd(), dryRun
   // mandatory never reaches an existing harness: `add` and `install` apply the floor, sync did
   // not, and sync is the only one an upgrade runs. Applied only to a harness that already declares
   // something: a directory declaring nothing is not a harness missing its floor.
-  const declared = declaredRaw.length ? withDefaultSkillFloor(declaredRaw) : declaredRaw;
+  // Lo mismo con el flujo del gate: si el gate está conectado, sus skills llegan con el update.
+  const declared = declaredRaw.length
+    ? withCodeFlowFloor(withDefaultSkillFloor(declaredRaw), manifest?.onboarding?.plan?.policy)
+    : declaredRaw;
   const declaredAgents = state.explicitAgents?.length ? state.explicitAgents : (manifest?.agents || []);
   if (!declared.length && !declaredAgents.length) return dryRun ? { dryRun: true, synced: [], syncedAgents: [], paths: [] } : { synced: [], syncedAgents: [], backup: null };
   if (dryRun) {
@@ -632,6 +659,43 @@ export async function syncInstalled({ target, home, cwd = process.cwd(), dryRun
 // own knowledge — kept unless `withDocs` is set. Returns the paths touched.
 // Note: backups live under `.rsc/backups/`, which this removes — so purge does not
 // snapshot (a pre-purge backup would delete itself). It is the deliberate escape hatch.
+const RSC_IGNORE_HEADER = '# rsc local state (hooks, seals, logs) and managed skill links — machine-local';
+
+// Merge consecutive rsc blocks into the first: drop a repeated header and the blank seam before it
+// when the block above was ours too. A block of the user's in between ends ours, so nothing of
+// theirs is ever moved or absorbed.
+export function foldIgnoreBlocks(text) {
+  const out = [];
+  let ours = false;
+  let afterBlank = false;
+  for (const line of text.split('\n')) {
+    if (line === RSC_IGNORE_HEADER) {
+      if (ours && afterBlank) {
+        while (out.length && out[out.length - 1].trim() === '') out.pop();
+        afterBlank = false;
+        continue;
+      }
+      ours = true;
+    } else if (line.trim() === '') {
+      afterBlank = true;
+      out.push(line);
+      continue;
+    } else if (afterBlank) {
+      ours = false;
+    }
+    afterBlank = false;
+    out.push(line);
+  }
+  return out.join('\n');
+}
+
+function endsWithIgnoreBlock(text) {
+  const lines = text.replace(/\n+$/, '').split('\n');
+  let i = lines.length - 1;
+  while (i > 0 && lines[i - 1].trim() !== '') i -= 1;
+  return lines[i] === RSC_IGNORE_HEADER;
+}
+
 export async function purge({ home, cwd = process.cwd(), withDocs = false, dryRun = false } = {}) {
   const removed = [];
   const drop = (p, recursive = false) => {

package/scripts/lib/backups.js

@@ -40,6 +40,19 @@ export function createBackup({ cwd = process.cwd(), operation, target, paths, cl
   return manifest;
 }
 
+// Where the newest snapshot kept a path, relative to the project — what to tell someone whose own work
+// was just replaced, so recovering it is a copy they can find rather than a restore they never heard of.
+// A transaction snapshot is the fallback: it is the install's rollback, not the user's copy.
+export function whereKept({ cwd = process.cwd(), relPath }) {
+  const backups = listBackups({ cwd });
+  const ordered = [...backups.filter((b) => !/transaction/.test(b.operation)), ...backups.filter((b) => /transaction/.test(b.operation))];
+  for (const b of ordered) {
+    const kept = join(backupsDir(cwd), b.id, 'files', relPath);
+    if (existsSync(kept)) return relative(cwd, kept).split(sep).join('/');
+  }
+  return null;
+}
+
 export function listBackups({ cwd = process.cwd() } = {}) {
   const dir = backupsDir(cwd);
   if (!existsSync(dir)) return [];

package/scripts/lib/default-skill-floor.js

@@ -9,3 +9,17 @@ export const DEFAULT_SKILL_FLOOR = Object.freeze(['orient', 'suggest', 'bro']);
 export function withDefaultSkillFloor(skillIds = []) {
   return [...new Set([...DEFAULT_SKILL_FLOOR, ...skillIds])];
 }
+
+// Las skills del flujo que nombra el gate de código (targets/hook-once.mjs), más `retro`.
+// Un proyecto con el gate conectado tiene que tenerlas todas: si el gate cambia y nombra una
+// skill nueva (`implement-spec`, `pr`), el update la trae en vez de dejar el gate apuntando a
+// algo que no está. Un proyecto sin gate (`codeHooks: false`) no recibe ninguna.
+export const CODE_FLOW_FLOOR = Object.freeze([
+  'grill-with-docs', 'wayfinder', 'to-spec', 'write-adr', 'to-tickets',
+  'implement-spec', 'implement', 'code-review', 'pr', 'retro',
+]);
+
+export function withCodeFlowFloor(skillIds = [], policy) {
+  if (policy?.codeHooks === false) return skillIds;
+  return [...new Set([...skillIds, ...CODE_FLOW_FLOOR])];
+}

package/scripts/lib/domains.js

@@ -27,7 +27,7 @@ export const DOMAINS = [
   { title: 'Motion & interface craft', ids: ['motion-craft', 'ui-engineering', 'variant-explorer'] },
   { title: 'Design & content craft', ids: ['design-loop', 'design', 'design-dna', 'presentations', 'course-storytelling', 'course-builder', 'technical-writing', 'translation-l10n'] },
   { title: 'Knowledge & meta', ids: ['knowledge-ops', 'codebase-onboarding', 'research-ops', 'continuous-learning', 'skill-scout', 'context-budget', 'roast-me', 'show-me', 'eli5', 'fable-operator'] },
-  { title: 'Personal catalog — workflow (Spanish)', ids: ['grill-me', 'grill-with-docs', 'grilling', 'wayfinder', 'to-spec', 'to-tickets', 'to-questionnaire', 'implement', 'revision-de-cambios', 'code-review', 'research', 'prototype', 'domain-modeling', 'handoff', 'write-adr', 'wait-what', 'writing-for-agents', 'claude-project-setup', 'muscle-memory', 'teach'] },
+  { title: 'Personal catalog — workflow (Spanish)', ids: ['grill-me', 'grill-with-docs', 'grilling', 'wayfinder', 'to-spec', 'to-tickets', 'to-questionnaire', 'implement', 'implement-spec', 'pr', 'retro', 'revision-de-cambios', 'code-review', 'research', 'prototype', 'domain-modeling', 'handoff', 'write-adr', 'wait-what', 'writing-for-agents', 'claude-project-setup', 'muscle-memory', 'teach'] },
   { title: 'Personal catalog — interface design (Spanish)', ids: ['flujo-interfaz', 'animar', 'diseno-apple', 'diseno-landing', 'ingeniero-diseno-web', 'leyes-de-percepcion', 'leyes-de-retencion', 'mejor-accesibilidad', 'mejor-colores', 'mejor-layout', 'mejor-redaccion', 'mejor-tipografia', 'mejor-ui', 'sitios-calidad-premio', 'tastemaker', 'video-a-superprompt', 'vocabulario-animacion', 'revision-interfaz'] },
 ];
 

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, '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, '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

@@ -199,6 +199,13 @@ export function buildOnboardingPlan(record, evidence) {
   const hooks = needsWorkflow;
   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';
   const decisions = skills.map((id) => detectedSkills.includes(id)
     ? selected(id, 'skill', `Detected ${id} evidence inside the selected project root.`, 'workspace-evidence')
     : selected(id, 'skill', needsWorkflow
@@ -248,6 +255,7 @@ export function buildOnboardingPlan(record, evidence) {
     alwaysOn: true,
     codeHooks: needsWorkflow,
     gitmojiGuard,
+    dangerGuard,
     memory: true,
     context7: false,
     plugins: needsWorkflow ? ['superpowers@claude-plugins-official'] : [],

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 });