@polymorphism-tech/morph-spec 8.46.0 → 9.0.0

package/src/lib/worktree/docker-audit.js

@@ -74,8 +74,7 @@ function resolveGitCommonDir(cwd) {
  * treating those as different paths would make every stack look foreign.
  *
  * Exported as the ONE copy of that rule: `doctor.js` compares a declared test
- * node `cwd` with a discovered `package.json` folder through it (#87 F5), and
- * `test-scope.js` takes only the CASE of a canonical path through it (#87 N3).
+ * node `cwd` with a discovered `package.json` folder through it.
  */
 export const samePathCase = process.platform === 'win32' ? (s) => s.toLowerCase() : (s) => s;
 const norm = (p) => samePathCase(resolve(String(p)).replace(/\\/g, '/'));

package/src/lib/worktree/fleet-scanner.js

@@ -6,7 +6,7 @@
  * operator loses track of "what is each session doing, what is waiting on me".
  * This scanner answers that from the primary root's vantage point: one entry
  * per active feature, worktree or root-resident, with the operational facts
- * (phase, pending gates, task counts, port block, handoff freshness, last
+ * (phase, pending gates, slice counts, port block, handoff freshness, last
  * commit, dirtiness) resolved per entry.
  *
  * Read-only and fail-open per FIELD: a corrupt feature.json or a git hiccup
@@ -24,52 +24,39 @@ import {
   getFeature,
   derivePhaseForFeature,
   derivePhaseFrom,
+  fileSetArtifactProbe,
   getPendingGates,
   pendingGatesFrom,
 } from '../../../framework/hooks/shared/state-reader.js';
 import { listClaims } from '../../../framework/hooks/shared/claim-registry.js';
 import { buildPrIndex } from '../git/pr-index.js';
 import { pendingPrFeatures } from '../git/pending-prs.js';
+import { sliceProgress, sliceProgressFrom } from '../../../framework/hooks/shared/slice-progress.js';
 
-function countFrom(raw) {
-  const data = JSON.parse(raw);
-  if (!Array.isArray(data.tasks)) return null;
-  return { done: data.tasks.filter((t) => t.status === 'done').length, total: data.tasks.length };
-}
+const counts = (progress) => (progress ? { done: progress.done, total: progress.total } : null);
 
 /**
- * Task progress for one feature.
- *
- * DIVERGENCE from the bug report, which blamed "a cached state.json/feature.json
- * snapshot": this never read either — it always read `2-plan/tasks.json`
- * directly. The real mechanism is which COPY of that file is on disk. Since
- * v8.4 every feature is born on `morph/{f}` and its tasks.json is COMMITTED
- * there; the primary root's working tree only ever holds the copy of the
- * CHECKED-OUT branch. An operator sitting on the default therefore read the
- * pre-work copy — the reported `2/2` for a feature whose branch already had
- * T1..T3 all done.
+ * Slice progress for one feature, read from the copy that holds the work: a
+ * root-resident feature's plan checks and reports are committed on its own
+ * `morph/{f}` branch, while the root working tree only holds the checked-out
+ * branch's (pre-work) copy.
  *
  * @param {string} featureDir - the feature dir inside `path`
  * @param {{ root: string, feature: string, featureBranch: string|null }} ctx
  */
-function taskCounts(featureDir, { root, feature, featureBranch } = {}) {
+function sliceCounts(featureDir, { root, feature, featureBranch } = {}) {
   if (featureBranch && root && feature) {
-    try {
-      const raw = execFileSync(
-        'git',
-        ['show', `${featureBranch}:.morph/features/${feature}/2-plan/tasks.json`],
-        { cwd: root, stdio: 'pipe' },
-      ).toString();
-      const counted = countFrom(raw);
-      if (counted) return counted;
-    } catch { /* no such branch/blob — fall through to the working tree */ }
-  }
-
-  try {
-    return countFrom(readFileSync(join(featureDir, '2-plan', 'tasks.json'), 'utf8'));
-  } catch {
-    return null;
+    const show = (rel) => {
+      try {
+        return execFileSync('git', ['show', `${featureBranch}:.morph/features/${feature}/${rel}`], { cwd: root, stdio: 'pipe' }).toString();
+      } catch {
+        return null;
+      }
+    };
+    const onBranch = sliceProgressFrom(show('2-plan/checks.json'), (id) => show(`3-implement/reports/${id}.md`));
+    if (onBranch) return counts(onBranch);
   }
+  return counts(sliceProgress(featureDir));
 }
 
 function handoffInfo(featureDir) {
@@ -164,15 +151,15 @@ function buildRemote(feature, branch, heads, prs) {
 function buildEntry(feature, { location, path, branch, root, allocations, blockSize, heads, prs, claims }) {
   let workType = null;
   let status = 'unknown';
-  let phase = 'proposal';
+  let phase = 'plan';
   let pendingGates = [];
 
-  // Resolved once and shared with taskCounts — see branchToReadFrom.
+  // Resolved once and shared with sliceCounts — see branchToReadFrom.
   const featureBranch = branchToReadFrom(root, feature, location, branch);
 
   try {
     // B3b: phase and gates suffered the same branch-staleness B3 fixed for
-    // tasks. They read `.morph/features/{f}/` through the working tree, so a
+    // progress. They read `.morph/features/{f}/` through the working tree, so a
     // root parked on the default reported the PRE-WORK phase for a feature
     // whose branch was already at implement — and re-asked for a gate the
     // feature branch had already approved.
@@ -180,7 +167,7 @@ function buildEntry(feature, { location, path, branch, root, allocations, blockS
     if (view) {
       workType = view.fj?.workType || null;
       status = view.fj?.status || 'unknown';
-      phase = derivePhaseFrom(view.fj, (rel) => view.files.has(rel));
+      phase = derivePhaseFrom(view.fj, fileSetArtifactProbe(view.files));
       pendingGates = pendingGatesFrom(view.fj);
     } else {
       const fj = getFeature(feature, path);
@@ -202,7 +189,7 @@ function buildEntry(feature, { location, path, branch, root, allocations, blockS
     location,
     path,
     branch,
-    tasks: taskCounts(featureDir, { root, feature, featureBranch }),
+    slices: sliceCounts(featureDir, { root, feature, featureBranch }),
     env: alloc && Number.isInteger(alloc.base)
       ? { base: alloc.base, range: [alloc.base, alloc.base + blockSize - 1] }
       : null,
@@ -316,7 +303,7 @@ export function scanFleet(cwd = process.cwd()) {
         location: 'pr-pending',
         path: null,
         branch: p.branch,
-        tasks: null,
+        slices: null,
         env: null,
         handoff: { exists: false, generatedAt: null },
         lastCommit: null,

package/src/scripts/setup-infra.js

@@ -13,7 +13,7 @@
 import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { execSync } from 'child_process';
-import { readFileSync, readdirSync } from 'fs';
+import { readFileSync, readdirSync, existsSync } from 'fs';
 import {
   copyDirectory,
   copyFile,
@@ -32,6 +32,7 @@ import { installClaudeHooks, installGlobalStatusline } from '../utils/claude-set
 import { installSkills } from '../utils/skills-installer.js';
 import { installAgents, installDomainAgents } from '../utils/agents-installer.js';
 import { resolvePrimaryRoot } from '../commands/project/worktree.js';
+import { findOldFormatFeatures, oldFormatGuardLines } from '../lib/specs/old-format.js';
 import { reconcileLegacyTemplatesCopy } from '../lib/installers/templates-reconcile.js';
 import { realEffects } from '../lib/installers/effects.js';
 
@@ -89,7 +90,27 @@ export function installRulesForStack(rulesSrc, rulesDest, projectTags, fx = real
 }
 
 /**
- * Re-install only stack-aware assets (rules, skills, agents) using current config.json.
+ * Slash commands filtered by `stacks:` frontmatter. Clean-slate like the
+ * skills: removes only a framework command that the stack filtered out, never
+ * a command the user wrote into `.claude/commands/`.
+ */
+export function installCommandsForStack(commandsSrc, commandsDest, projectTags, fx = realEffects()) {
+  const sourceFiles = readdirSync(commandsSrc).filter(f => f.endsWith('.md'));
+  let installed = 0;
+  for (const file of sourceFiles) {
+    const dest = join(commandsDest, file);
+    if (shouldInstall(parseStacks(readFileSync(join(commandsSrc, file), 'utf-8')), projectTags)) {
+      fx.copyFile(join(commandsSrc, file), dest);
+      installed++;
+    } else if (!fx.dryRun && existsSync(dest)) {
+      fx.remove(dest);
+    }
+  }
+  return { installed };
+}
+
+/**
+ * Re-install only stack-aware assets (commands, rules, skills, agents) using current config.json.
  * Skips infrastructure steps (dirs, framework copy, hooks).
  *
  * @param {string} targetPath - Absolute path to the target project directory
@@ -109,8 +130,16 @@ async function installStackAwareAssets(targetPath, log) {
     } catch { /* ignore malformed config */ }
   }
 
-  log('Installing stack-filtered rules...');
   const claudeDest = join(targetPath, '.claude');
+  log('Installing stack-filtered commands...');
+  const commandsSrc = join(FRAMEWORK_DIR, 'commands');
+  const commandsDest = join(claudeDest, 'commands');
+  if (await pathExists(commandsSrc)) {
+    await ensureDir(commandsDest);
+    installCommandsForStack(commandsSrc, commandsDest, projectTags);
+  }
+
+  log('Installing stack-filtered rules...');
   const rulesSrc = join(FRAMEWORK_DIR, 'rules');
   const rulesDest = join(claudeDest, 'rules');
   if (await pathExists(rulesSrc)) {
@@ -213,6 +242,14 @@ export async function setupInfra(targetPath, {
     }
   }
 
+  // Same refusal as `update`, and neither `force` nor `reinstall` waives it:
+  // `init --force` and `setup-infra` overwrite `.morph/` without passing through it.
+  const oldFormat = findOldFormatFeatures(targetPath);
+  if (oldFormat.length) {
+    for (const line of oldFormatGuardLines(oldFormat, targetPath)) log(line);
+    return { refused: true, reason: 'old-format-features', features: oldFormat };
+  }
+
   // --- Reinstall mode: only re-install stack-aware assets ---
   if (reinstall) {
     log('setup-infra (reinstall): re-installing stack-aware assets...');
@@ -336,18 +373,8 @@ export async function setupInfra(targetPath, {
     await copyDirectory(hooksSrc, hooksDest);
   }
 
-  // --- 7b. Copy framework/rubrics → .morph/framework/rubrics ---
-  log('Step 7b: Copying rubrics...');
-  const rubricsSrc = join(FRAMEWORK_DIR, 'rubrics');
-  const rubricsDest = join(frameworkDestDir, 'rubrics');
-  if (await pathExists(rubricsSrc)) {
-    await copyDirectory(rubricsSrc, rubricsDest);
-  }
-
   // --- 7c. Copy framework/evals → .morph/framework/evals ---
-  // Rubricas .md (bandas 0-10) + trace-schema.md — referenciadas por
-  // morph-review/agents.json via .morph/framework/evals/.
-  log('Step 7c: Copying evals (rubrics .md + trace schema)...');
+  log('Step 7c: Copying evals (review checklist + trace schema)...');
   const evalsSrc = join(FRAMEWORK_DIR, 'evals');
   const evalsDest = join(frameworkDestDir, 'evals');
   if (await pathExists(evalsSrc)) {
@@ -396,16 +423,9 @@ export async function setupInfra(targetPath, {
     await copyDirectory(schemasSrc, schemasDest);
   }
 
-  // --- 9. Copy framework/commands → .claude/commands ---
-  log('Step 9: Setting up Claude Code integration...');
   const claudeDest = join(targetPath, '.claude');
-  const commandsSrc = join(FRAMEWORK_DIR, 'commands');
-  const commandsDest = join(claudeDest, 'commands');
-  if (await pathExists(commandsSrc)) {
-    await copyDirectory(commandsSrc, commandsDest);
-  }
 
-  // --- 10-13. Install stack-aware assets (rules, skills, agents) ---
+  // --- 9-13. Install stack-aware assets (commands, rules, skills, agents) ---
   log('Steps 10-13: Installing stack-aware assets...');
   const { agentCounts, domainCounts, projectTags } = await installStackAwareAssets(targetPath, log);
 

package/src/utils/agents-installer.js

@@ -15,7 +15,7 @@
  *
  * In v5 the harness has 8 personas (no tiers) across two axes — domain
  * (dotnet-senior, ef-modeler, maf-expert, nextjs-expert, ui-designer,
- * infra-engineer, evaluator) and stage (scout, read-only diagnosis before
+ * infra-engineer, verifier, reviewer, security) and stage (scout, read-only diagnosis before
  * implementation). Each persona is a subagent the Specialist (Claude in
  * implementer role) can dispatch. The 3 roles (Orchestrator/Specialist/
  * Evaluator) are assumed by Claude itself per MORPH.md, not as separate agents.
@@ -294,7 +294,7 @@ export function loadKnownMcpIds(frameworkDir) {
  * with NO known stack tags (greenfield / install before config.json exists)
  * EVERY persona is generated — a project that dispatches `morph-{id}` must
  * find the subagent registered, and an install that only lands
- * morph-evaluator forces every domain dispatch into the general-purpose
+ * morph-verifier forces every domain dispatch into the general-purpose
  * fallback. Stack filtering only applies when the project's stack is KNOWN
  * (tags non-empty): the fallback stays reserved for stacks the project
  * genuinely does not have. Note this deliberately differs from rules/skills
@@ -431,10 +431,8 @@ function buildFrontmatter(agent, description, knownMcpIds, maxTurns) {
     // Canonical 1:1 naming: frontmatter name === filename === subagent_type.
     `name: morph-${agent.id}`,
     `description: ${description}`,
-    // model is dimensioned per stage/criticality in agents.json (v5.2.0):
-    // evaluator (quality multiplier) → opus, domain implementers → sonnet,
-    // scout → sonnet (measured: same cost as haiku, fewer rejected maps). Falls back to `inherit` only for
-    // personas that omit the field.
+    // The verifier is sonnet here; the dispatch routes it to opus when the risk
+    // detector flags the diff. A persona without the field inherits the session model.
     `model: ${agent.model ?? 'inherit'}`,
     `tools: ${buildToolsLine(agent, knownMcpIds)}`,
     // Per persona in agents.json (ADR-004); absent → DEFAULT_MAX_TURNS. The
@@ -455,6 +453,63 @@ function buildDescription(agent) {
   return desc.length > 200 ? desc.slice(0, 197) + '...' : desc;
 }
 
+/**
+ * The fixed half of every implementer dispatch. The orchestrator paraphrases
+ * a prompt template in the field; the generated body is the only text a
+ * dispatch is guaranteed to carry, so the contract lives here and the
+ * dispatch carries only what changes per slice.
+ */
+const NEON_CAUTION = 'NEON: o MCP `neon` inspeciona schema e ensaia migração numa branch descartável ' +
+  '(prepare_database_migration → complete_database_migration); ele também APAGA branch e projeto — ' +
+  'nunca chame tool destrutiva sem confirmação humana explícita.';
+
+const STANDARDS_HINT = 'Digest de cada um: `morph-spec standards --find <id>`; só a seção que importa: ' +
+  '`morph-spec standards --show <id>#<âncora>` (`--show <id>` lista as âncoras).';
+
+export const DISPATCH_CONTRACT = [
+  '## Contrato de dispatch',
+  '',
+  'O dispatch traz só o que muda por fatia: id e título, `cobre` com o texto de cada cenário, `arquivos`, `standards`, ' +
+    'o caminho do relatório e, se houver, o worktree. O resto é este contrato.',
+  '',
+  '1. RELATÓRIO: GRAVE o arquivo de relatório que o dispatch nomeia (`.morph/features/{feature}/3-implement/reports/F{n}.md`) ' +
+    'ANTES de encerrar — é o retorno autoritativo, não a sua mensagem final. `SendMessage` não é substituto do relatório e não deve ser chamado.',
+  '2. ESTADO: NÃO toque em `plan.md`, `checks.json`, `feature.json`, `state.json` nem no board de sessão — todo estado é gravado exclusivamente pelo orquestrador.',
+  '3. TESTE: a prova é do orquestrador (`morph-spec verify {feature}`, depois do seu retorno), não sua. Escreva os testes pelo orçamento: ' +
+    'um por pós-condição, um de regressão por bug, variantes numa tabela (`[Theory]`/`it.each`). NÃO rode teste a cada marco nem faça ciclo red→green: ' +
+    'escreva código e testes, compile, e rode SÓ o filtro dos seus testes UMA vez, em primeiro plano, antes do relatório; se falhar, corrija e rode só os que falharam. ' +
+    'Grave a saída em arquivo (`… > .morph/logs/test-last.log 2>&1`, sem nada depois) e leia o arquivo — um pipe troca o exit do teste pelo do último comando. ' +
+    'Em batch paralelo SEM isolamento, só compile. Com `isolation: "worktree"`, o mesmo vale no seu worktree, e o último ato é o commit na branch dele.',
+  '4. ESCOPO: uma fatia, ~4 arquivos (nunca mais de 8). Escopo maior falha e volta — fatie antes, não depois.',
+  '5. SOBREVIVÊNCIA: o limite de turnos corta sem aviso: commite `wip(F{n})` a cada marco (um arquivo ou uma fatia coerente escrita), não só ao fim — ' +
+    'e só os seus arquivos (`git add <paths>`, nunca `-A` nem diretório). Sem commit, a retomada recomeça do zero.',
+  '6. PROCESSOS: NUNCA `taskkill /IM node.exe` (derruba os MCPs de todas as sessões). Encerre dev server pelo PID que você mesmo subiu. ' +
+    'Build e suíte pesados rodam por `morph-spec heavy run -- <comando>`, em primeiro plano. Exit 3 é fila cheia depois da espera da própria fila: ' +
+    'não repita nem espere em laço — diga no relatório o que não rodou.',
+  '7. REUSO: antes de criar tipo, componente, hook ou serviço NOVO, verifique se já existe: `morph-spec graph explain <nome>` e ' +
+    '`graph affected <conceito> --uses-only`; sem grafo (`no-graph`), caia para `grep -rn "<nome>"` e siga — a ausência de grafo nunca bloqueia. ' +
+    'Se criar mesmo assim, diga por que em uma linha no relatório.',
+  '8. MUTAÇÃO: nunca altere, reverta, mova ou apague código de produção para ver um teste falhar (`sed`, `mv`, `git show HEAD:… >`, `git stash`, ' +
+    '`git checkout --`). A prova de que o teste morde é do verificador (Gate 3).',
+  '9. ESCRITA: código e teste do projeto só por Write/Edit, nunca pelo Bash — heredoc, redirecionamento, `sed -i` ou script python/node que grava (`cat > X.cs <<EOF`, `sed -i … X.cs`): ' +
+    'os guards de escrita só enxergam Write/Edit.',
+  '',
+  'Formato do relatório (o `report-check` lê estas marcas):',
+  '',
+  '```',
+  '# F1 — <título>',
+  'O que foi feito, em 2-3 frases: o comportamento entregue e onde ele mora, sem repetir a lista de arquivos.',
+  '**Arquivos:** `src/a.cs`, `src/a.test.cs`',
+  '**Checks:**',
+  '- C1 — provado: `a.test.cs` › nome do teste (ou `arquivo:linha`)',
+  '- C2 — não provado: por quê',
+  '```',
+  '',
+  '`**Arquivos:**` lista TODO arquivo criado ou modificado, inclusive artefato auxiliar fora do plano (factory, seed, config gerada): ' +
+    'arquivo em produção sem dono é falha de protocolo que o Gate 3 aponta. Todo cenário que a fatia `cobre` aparece em `**Checks:**`. ' +
+    'Problemas e como foram resolvidos vão em prosa depois.',
+];
+
 function buildBody(agent, maxTurns) {
   const lines = [
     `# ${agent.title ?? agent.id}`,
@@ -463,12 +518,20 @@ function buildBody(agent, maxTurns) {
     '',
   ];
 
-  if (agent.domains?.length) {
+  // The 5.3.0 shape (no effort, no surfaces, implementer) renders byte-for-byte as before.
+  const legacyShape = !agent.effort && !agent.surfaces && isImplementer(agent);
+
+  if (legacyShape && agent.domains?.length) {
     lines.push('## Domains', ...agent.domains.map(d => `- ${d}`), '');
   }
 
+  if (!legacyShape && agent.mcp?.includes('neon')) {
+    lines.push(NEON_CAUTION, '');
+  }
+
   if (agent.standards?.length) {
     lines.push('## Standards to consult on demand');
+    if (!legacyShape) lines.push(STANDARDS_HINT);
     for (const s of agent.standards) lines.push(`- ${s}`);
     lines.push('');
   }
@@ -487,13 +550,29 @@ function buildBody(agent, maxTurns) {
     }
   }
 
+  if (agent.effort && isImplementer(agent)) {
+    lines.push(...DISPATCH_CONTRACT, '');
+  } else if (isImplementer(agent)) {
+    lines.push(
+      '## How you operate',
+      '',
+      'You are a domain persona dispatched per task. Read the spec/tasks/standards passed to you, do the work, and report each doneCriteria with its evidence. Refer to MORPH.md section 6 for the dispatch contract.',
+      '',
+    );
+  } else {
+    // A read-only persona has no slice to implement nor scenario to report.
+    lines.push(
+      '## Como você opera',
+      '',
+      'Você é read-only: nunca escreva, edite nem reverta código, testes, o plano ou `feature.json` (nada de `git checkout --`). ' +
+        'O entregável é o arquivo de relatório que o dispatch nomeia; sem arquivo nomeado, é a sua mensagem final (no scout, o mapa).',
+      '',
+    );
+  }
+
   lines.push(
-    '## How you operate',
-    '',
-    'You are a domain persona dispatched per task. Read the spec/tasks/standards passed to you, do the work, and report each doneCriteria with its evidence. Refer to MORPH.md section 6 for the dispatch contract.',
-    '',
     // `PARCIAL` on line 1 is what report-check reads; "no verdict" keeps an
-    // evaluator partial from carrying a Verdict the gate would read as final.
+    // review partial from carrying a Verdict the gate would read as final.
     '## Turn budget',
     '',
     // Pasted into EVERY dispatch of every persona — kept to the minimum that
@@ -517,7 +596,7 @@ function buildBody(agent, maxTurns) {
         'Use Read/Grep/Glob, never grep/sed/cat/find via Bash. Check a library API in the `context7` MCP before guessing ' +
         '(load a deferred `mcp__` tool with ToolSearch). Write the tests the budget asks for, then run only your own ' +
         'filter ONCE before the report — no red→green cycles, no `morph-spec verify` (the orchestrator proves it). ' +
-        'Never alter, revert or move production code to watch a test fail: mutation proof belongs to the Gate 3 evaluator.',
+        'Never alter, revert or move production code to watch a test fail: mutation proof belongs to the Gate 3 verifier.',
     );
   }
 

package/src/utils/claude-settings-manager.js

@@ -24,41 +24,6 @@ export { installAgents } from './agents-installer.js';
 // Extended settings management
 // ============================================================================
 
-/**
- * Install permission rules into .claude/settings.local.json
- * @param {string} targetPath - Project root directory
- * @param {Array<string>} permissions - Permission patterns to add
- * @returns {Promise<Object>} Summary of changes
- */
-export async function installPermissions(targetPath, permissions) {
-  const settings = await loadSettings(targetPath);
-
-  settings.permissions = settings.permissions || [];
-
-  const added = [];
-  for (const perm of permissions) {
-    if (!settings.permissions.includes(perm)) {
-      settings.permissions.push(perm);
-      added.push(perm);
-    }
-  }
-
-  // Track in _morph_managed
-  settings[MORPH_MANAGED_KEY] = settings[MORPH_MANAGED_KEY] || {};
-  settings[MORPH_MANAGED_KEY].permissions_added =
-    settings[MORPH_MANAGED_KEY].permissions_added || [];
-  for (const perm of added) {
-    if (!settings[MORPH_MANAGED_KEY].permissions_added.includes(perm)) {
-      settings[MORPH_MANAGED_KEY].permissions_added.push(perm);
-    }
-  }
-  settings[MORPH_MANAGED_KEY].generated_at = new Date().toISOString();
-
-  await saveSettings(targetPath, settings);
-
-  return { added, total: settings.permissions.length };
-}
-
 /**
  * Install environment variables into .claude/settings.local.json
  * @param {string} targetPath - Project root directory

package/src/utils/file-copier.js

@@ -156,7 +156,6 @@ export const MORPH_GITIGNORE_ENTRIES = [
     '.morph/memory/',
     '.morph/plans/',
     '.morph/analytics/',
-    '.morph/traces/',
     // Per-instance activity/session logs (activity-logger.js). Each worktree
     // writes its own — committing this guarantees a merge conflict between
     // feature branches.
@@ -199,10 +198,12 @@ export async function updateGitignore(projectPath, fx = realEffects()) {
     content = await readFile(gitignorePath);
     hasMorphSection = content.includes('# MORPH-SPEC');
   }
+  const original = content;
+  const eol = content.includes('\r\n') ? '\r\n' : '\n';
 
   // If MORPH section already exists, check if rules are up to date
   if (hasMorphSection) {
-    const lines = content.split('\n');
+    const lines = content.split(/\r?\n/);
     const morphStartIndex = lines.findIndex(line => line.trim() === '# MORPH-SPEC');
 
     // Find the end of MORPH section (next empty line or section header)
@@ -225,17 +226,44 @@ export async function updateGitignore(projectPath, fx = realEffects()) {
     if (missingRules.length > 0) {
       // Update the section with all rules
       lines.splice(morphStartIndex, morphEndIndex - morphStartIndex, ...morphRules.slice(1, -1));
-      content = lines.join('\n');
+      content = lines.join(eol);
     }
   } else {
     // Add MORPH section
     if (content && !content.endsWith('\n')) {
-      content += '\n';
+      content += eol;
     }
-    content += morphRules.join('\n');
+    content += morphRules.join(eol);
   }
 
-  fx.writeFile(gitignorePath, content);
+  if (content !== original) fx.writeFile(gitignorePath, content);
+}
+
+const DOTNET_BUILD_DIRS = ['bin', 'obj'];
+
+const ignoredDir = (line) => line.trim()
+  .replace(/^\/|^\*\*\//, '')
+  .replace(/\/(\*\*)?$/, '')
+  .replace(/^\[(\w)(\w)\]/, (_, a, b) => (a.toLowerCase() === b.toLowerCase() ? a : `[${a}${b}]`))
+  .toLowerCase();
+
+/**
+ * Appends `bin/` and `obj/` to the project `.gitignore` when no line already
+ * ignores them. Never rewrites an existing line.
+ *
+ * @returns {string[]} the entries added
+ */
+export function ensureDotnetBuildIgnores(projectPath) {
+  const gitignorePath = join(projectPath, '.gitignore');
+  const content = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf8') : '';
+  const present = new Set(content.split(/\r?\n/).filter((l) => !l.trim().startsWith('#')).map(ignoredDir));
+  const missing = DOTNET_BUILD_DIRS.filter((dir) => !present.has(dir)).map((dir) => `${dir}/`);
+  if (!missing.length) return [];
+  const eol = content.includes('\r\n') ? '\r\n' : '\n';
+  const lead = content && !content.endsWith('\n') ? eol : '';
+  const block = [...(content ? [''] : []), '# .NET build output', ...missing, ''].join(eol);
+  fs.writeFileSync(gitignorePath, content + lead + block);
+  return missing;
 }
 
 /**

package/src/utils/hooks-installer.js

@@ -55,8 +55,11 @@ import { realEffects } from '../lib/installers/effects.js';
  *
  * 3.12.0 adds heavy-gate to the Bash PreToolUse chain and heavy-release to the
  * PostToolUse and PostToolUseFailure chains: the opt-in `heavy.gateBash`.
+ *
+ * 3.13.0 adds warn-bash-source-write to the Bash PreToolUse chain: a warning,
+ * never a block, when a command writes project source through a redirect.
  */
-const HOOKS_VERSION = '3.12.0';
+const HOOKS_VERSION = '3.13.0';
 
 /** Marker for old dispatch.js (v1) */
 const OLD_DISPATCH_COMMAND = 'node framework/hooks/agent-teams/dispatch.js';
@@ -93,21 +96,24 @@ const MORPH_DENY = [
  *
  * Pre-authorizes operations the agent legitimately performs during the
  * morph-spec flow, so the user does not get permission prompts on every
- * proposal.md / spec.md / tasks.json write.
+ * plan.md / slice report write.
  *
  * `Edit(path)` ONLY, for the same reason as MORPH_DENY: the `Edit` rule already
  * covers Write, and a `Write(path)` rule is inert noise.
  */
 const MORPH_ALLOW = [
-  // Feature artifacts — the agent's working directory during proposal/plan/implement/review
+  // Feature artifacts — the agent's working directory during plan/uiux/implement/review
   'Edit(.morph/features/**)',
   // state.json — fallback path when state-sync hook can't cover a case
   'Edit(.morph/state.json)',
-  // Long-lived architectural context — agent may reconcile during brainstorming
+  // Long-lived architectural context — agent may reconcile during planning
   'Edit(.morph/context/**)',
   // Folder creation under .morph
   'Bash(mkdir:.morph/**)',
   'Bash(ls:.morph/**)',
+  // Gate 3 mutation round: restores bytes itself and has --restore; an auto-mode deny pauses the gate
+  'Bash(morph-spec mutate:*)',
+  'Bash(npx morph-spec mutate:*)',
 ];
 
 // Backwards-compat alias used by older tests
@@ -168,6 +174,8 @@ const MORPH_HOOKS = [
   // on someone having read MORPH.md. block-raw-worktree-add is its way-IN
   // counterpart (a raw `git worktree add` builds a tree with no junctions, no
   // ports, no identity) — static, so it costs nothing after the first two.
+  // warn-bash-source-write only adds context (source written by redirect skips
+  // the Write/Edit guards); after the guards, so a blocked command is not warned.
   // heavy-gate comes after every guard — it takes a slot, and a command a guard
   // blocks must not hold one — and before the rewriter.
   // worktree-env-inject is LAST: it rewrites launcher commands (updatedInput)
@@ -179,7 +187,7 @@ const MORPH_HOOKS = [
     hooks: [{
       type: 'command',
       command: 'node framework/hooks/claude-code/core/chain.js',
-      args: ['pre-bash-denylist', 'block-destructive-worktree-removal', 'block-raw-worktree-add', 'heavy-gate', 'worktree-env-inject']
+      args: ['pre-bash-denylist', 'block-destructive-worktree-removal', 'block-raw-worktree-add', 'warn-bash-source-write', 'heavy-gate', 'worktree-env-inject']
     }]
   },
 
@@ -214,15 +222,14 @@ const MORPH_HOOKS = [
     }]
   },
 
-  // === PostToolUse: Write|Edit — tasks.json schema guard, trace auto-generation,
-  // comment-guard LAST: it blocks, and a block ends the chain. ===
+  // === PostToolUse: Write|Edit — comment-guard, solo: it blocks the edit that
+  // adds a forbidden comment. ===
   {
     event: 'PostToolUse',
     matcher: 'Write|Edit',
     hooks: [{
       type: 'command',
-      command: 'node framework/hooks/claude-code/core/chain.js',
-      args: ['tasks-json-guard', 'trace-autogen', 'comment-guard']
+      command: 'node framework/hooks/claude-code/core/comment-guard.js'
     }]
   },
 

package/src/utils/skills-installer.js

@@ -3,8 +3,7 @@
  *
  * Copies framework skills to .claude/skills/ during morph-spec init.
  * Installs only the `core/` skill set — the canonical NLH skills referenced by
- * MORPH.md (morph-brainstorming, morph-stack-scan, morph-plan, morph-implement,
- * morph-review, morph-standards). The 3-tier system was collapsed
+ * MORPH.md (morph-plan, morph-uiux, morph-apply, morph-review, morph-standards…). The 3-tier system was collapsed
  * into a single source of truth in framework/skills/core/.
  *
  * Source skills are directory-based: framework/skills/core/{skill-name}/SKILL.md