fix: discard condicional de templateOwnedPaths — harness vira fonte única

O discard incondicional apagava os 4 skills profissionais da cópia do
harness em modo full mesmo quando o template não os trazia — projetos
gerados saíam SEM os skills no .cursor (templates nunca tiveram .cursor/)
e com symlinks .agents quebrados; no .claude recebiam a cópia PT defasada
do template em vez da EN atual do harness.

Agora o caminho só é descartado quando o template instalado realmente o
trouxe (helper puro ownedPathsToDiscard + 6 testes herméticos). Efeitos:
o buraco do .cursor fecha; live1 (sem nenhum dos 4) herda tudo do
harness; live2 vence apenas em security (variante multi-tenant, também
em .cursor/skills). DOCS §8 e README atualizados para a semântica nova.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: elberrd

DOCS.md

@@ -351,13 +351,16 @@ design-system, security, backend-profissional) and `ai-docs/` (PRD, maps,
 task roadmap) for Claude Code and Cursor.
 
 Skills shared with the templates (`HARNESS.templateOwnedPaths` — the four
-professional ones, in `.claude/skills` and `.cursor/skills`): in `full` mode
-the harness copy is DISCARDED before the merge — the template already ships
-them and is the canonical source of the generated project (live2's
-`security`, for example, is the multi-tenant variant). In `harness` mode
-(no template) they come from the harness (copies of the generic variant,
-live1's) — whoever installs only the harness also gets the full professional
-standard. The `asaas` skill belongs to an addon and lives only in the templates.
+professional ones, in `.claude/skills` and `.cursor/skills`): the harness is
+the SINGLE SOURCE of this material. In `full` mode the harness copy of a path
+is discarded only when the installed template actually shipped that path
+(the merge runs after the template install, so the destination already
+reflects it) — a template that brings its own variant wins in that path
+(live2 ships only `security`, its multi-tenant variant), and a template
+without the skill inherits the harness version (live1 no longer ships any of
+the four; templates without `.cursor/` still get the four skills in Cursor
+from the harness). In `harness` mode (no template) everything comes from the
+harness. The `asaas` skill belongs to an addon and lives only in the templates.
 
 In `full` mode it runs last (the git repo already exists, created during the
 template install); in `harness` mode the folder may have no git — the step

README.md

@@ -564,10 +564,11 @@ summary) — every template-specific step is skipped.
     adapts to whatever is already there instead of clobbering it: existing
     files are never overwritten, the harness `README.md` lands as
     `HARNESS.md`, and its `AGENTS.md` is appended to the project's `AGENTS.md`
-    between `<!-- harness-start/end -->` markers. Skills the templates also
-    ship (the professional set) are dropped from the harness copy in full
-    mode — the template's version is canonical; harness-only installs get
-    them from the harness. Makes
+    between `<!-- harness-start/end -->` markers. The harness is the single
+    source of the professional skill set; when the installed template ships
+    its own variant of one of those paths (e.g. live2's multi-tenant
+    `security`), the harness copy of that path is dropped and the template's
+    wins — every path the template did not ship comes from the harness. Makes
     its own commit (initializing a git repo first if the folder has none) and
     pushes when a remote was created in step 19.
 22. **Stack manifest + docs** — writes `ai-docs/stack.md` (the manifest the

src/config.js

@@ -85,14 +85,14 @@ export const HARNESS = {
   readmeAs: 'HARNESS.md',
   markerStart: '<!-- harness-start -->',
   markerEnd: '<!-- harness-end -->',
-  // Skills that exist in the harness AND in the templates (live1/live2). In
-  // full mode the template already ships them — the harness merge drops its
-  // own copy to avoid assembling a mixed version (the per-file cp could add
-  // files that only exist in the harness version). In harness-only mode they
-  // are installed normally — that's what guarantees the skills for people who
-  // do NOT use a template.
-  // (In the harness the copies come from live1, the generic variant; the
-  // asaas skill belongs to an addon and lives only in the templates.)
+  // Paths a template MAY own. The harness is the single source of the agent
+  // material; a harness copy is only discarded (full mode) when the installed
+  // template actually shipped that exact path — the template's variant wins
+  // THERE, and the harness merge won't assemble a mixed version (the per-file
+  // cp could add files that only exist in the harness variant). Every path
+  // the template did not ship — and everything in harness-only mode — comes
+  // from the harness.
+  // (The asaas skill belongs to an addon and lives only in the templates.)
   templateOwnedPaths: ['frontend-profissional', 'design-system', 'security', 'backend-profissional'].flatMap(
     (skill) => [`.claude/skills/${skill}`, `.cursor/skills/${skill}`],
   ),

src/steps/harness.js

@@ -24,9 +24,11 @@ import * as ui from '../lib/ui.js';
  *   - the harness README.md lands as HARNESS.md — the project README wins;
  *   - the harness AGENTS.md is APPENDED to the project's AGENTS.md between
  *     harness markers (idempotent: markers present ⇒ nothing to do);
- *   - skills that also exist in the templates (HARNESS.templateOwnedPaths,
- *     e.g. frontend-profissional) are discarded in full mode — the template
- *     is the canonical source; in harness-only mode they are installed.
+ *   - skills a template MAY also ship (HARNESS.templateOwnedPaths, e.g.
+ *     frontend-profissional) are discarded in full mode ONLY when the
+ *     installed template actually brought that path — the template's variant
+ *     wins there; every path the template did not ship (and everything in
+ *     harness-only mode) comes from the harness, the single source.
  *
  * In 'full' mode it runs last (after GitHub/Vercel) and makes its own
  * best-effort commit. In 'harness' mode the folder may not have a git repo
@@ -86,11 +88,15 @@ export async function setupHarness(ctx) {
       harnessAgents = await readFile(join(tmpClone, 'AGENTS.md'), 'utf8');
       await rm(join(tmpClone, 'AGENTS.md'), { force: true });
     }
-    // Skills shared with the templates (e.g. frontend-profissional):
-    // in full mode the TEMPLATE's copy is the canonical one and is already
-    // installed — we discard the harness copy so the merge doesn't mix versions.
+    // Skills a template MAY also ship (e.g. frontend-profissional): in full
+    // mode the merge runs AFTER installTemplate, so the destination already
+    // reflects the template — for each shared path that the template actually
+    // brought, discard the harness copy so the merge doesn't mix versions.
+    // Paths the template did NOT ship stay in the clone: the harness is the
+    // single source for them (e.g. templates without .cursor/ still get the
+    // four professional skills in Cursor).
     if (!harnessOnly) {
-      for (const rel of HARNESS.templateOwnedPaths ?? []) {
+      for (const rel of ownedPathsToDiscard(HARNESS.templateOwnedPaths, dir)) {
         await rm(join(tmpClone, rel), { recursive: true, force: true });
       }
     }
@@ -163,6 +169,20 @@ export async function setupHarness(ctx) {
   );
 }
 
+/**
+ * Which of the template-ownable paths should be dropped from the harness clone
+ * before the merge: exactly those the installed template actually shipped
+ * (i.e. that already exist in the destination). Pure decision — the fs check
+ * is injectable for tests.
+ * @param {string[] | undefined} templateOwnedPaths relative paths a template MAY own
+ * @param {string} destDir project directory (already reflects the template)
+ * @param {(path: string) => boolean} [exists] defaults to fs.existsSync
+ * @returns {string[]} relative paths to discard from the harness copy
+ */
+export function ownedPathsToDiscard(templateOwnedPaths, destDir, exists = existsSync) {
+  return (templateOwnedPaths ?? []).filter((rel) => exists(join(destDir, rel)));
+}
+
 /**
  * Append the harness agent instructions to the project's AGENTS.md between
  * markers. Idempotent: if the start marker is already there, do nothing.

test/harness-merge.test.js

@@ -0,0 +1,65 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { ownedPathsToDiscard } from '../src/steps/harness.js';
+import { HARNESS } from '../src/config.js';
+
+const SKILLS = ['frontend-profissional', 'design-system', 'security', 'backend-profissional'];
+
+function tmpProject() {
+  return mkdtempSync(join(tmpdir(), 'harness-merge-'));
+}
+
+test('template without .cursor/: no .cursor/skills/* path is discarded', () => {
+  const dest = tmpProject();
+  // Template shipped only the Claude side of the four skills.
+  for (const skill of SKILLS) {
+    mkdirSync(join(dest, '.claude', 'skills', skill), { recursive: true });
+  }
+  const discard = ownedPathsToDiscard(HARNESS.templateOwnedPaths, dest);
+  assert.deepEqual(
+    discard.sort(),
+    SKILLS.map((s) => `.claude/skills/${s}`).sort(),
+  );
+  assert.ok(!discard.some((rel) => rel.startsWith('.cursor/')), 'harness must still cover Cursor');
+});
+
+test('template with only .claude/skills/security: only that path is discarded', () => {
+  const dest = tmpProject();
+  mkdirSync(join(dest, '.claude', 'skills', 'security'), { recursive: true });
+  assert.deepEqual(ownedPathsToDiscard(HARNESS.templateOwnedPaths, dest), ['.claude/skills/security']);
+});
+
+test('template with all shared paths: the 8 are discarded', () => {
+  const dest = tmpProject();
+  for (const rel of HARNESS.templateOwnedPaths) {
+    mkdirSync(join(dest, rel), { recursive: true });
+  }
+  const discard = ownedPathsToDiscard(HARNESS.templateOwnedPaths, dest);
+  assert.equal(discard.length, 8);
+  assert.deepEqual(discard.sort(), [...HARNESS.templateOwnedPaths].sort());
+});
+
+test('nonexistent destDir: nothing is discarded', () => {
+  const dest = join(tmpProject(), 'does-not-exist');
+  assert.deepEqual(ownedPathsToDiscard(HARNESS.templateOwnedPaths, dest), []);
+});
+
+test('empty/undefined templateOwnedPaths: nothing is discarded', () => {
+  const dest = tmpProject();
+  assert.deepEqual(ownedPathsToDiscard(undefined, dest), []);
+  assert.deepEqual(ownedPathsToDiscard([], dest), []);
+});
+
+test('injectable exists: decision is pure and follows the predicate', () => {
+  const seen = [];
+  const exists = (p) => {
+    seen.push(p);
+    return p.endsWith(join('.cursor', 'skills', 'design-system'));
+  };
+  const discard = ownedPathsToDiscard(HARNESS.templateOwnedPaths, '/virtual/project', exists);
+  assert.deepEqual(discard, ['.cursor/skills/design-system']);
+  assert.equal(seen.length, HARNESS.templateOwnedPaths.length);
+});