@polymorphism-tech/morph-spec 8.47.0 → 9.1.0

package/src/lib/generators/handoff-generator.js

@@ -1,73 +1,33 @@
-/**
- * handoff-generator.js — compressed session-handoff document (fleet).
- *
- * A fleet runs one Claude Code instance per feature worktree. What travels
- * between sessions must be a HANDOFF, not an export: a compact document that
- * points at the feature's own files instead of copying their contents, so a
- * fresh instance starts focused instead of inheriting a wall of stale context.
- *
- * Deterministic by construction — everything here is derived from feature.json,
- * tasks.json, decisions.md and the worktree env manifest. The document is
- * therefore REGENERABLE (never hand-edited, never merged): `morph-spec handoff`
- * rebuilds it, and setup/create/advance/approve regenerate it at the moments a
- * new session is most likely to pick the feature up.
- *
- * Every section is fail-open: a missing tasks.json or a corrupt decisions.md
- * degrades that section, never the document.
- */
+// Derived only from committed sources, so it is regenerated, never hand-edited or merged.
+// Every section is fail-open.
 
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { ensureCommonExclude } from '../../../framework/hooks/shared/git-exclude.js';
 import { derivePhaseForFeature, getPendingGates } from '../../../framework/hooks/shared/state-reader.js';
+import { sliceProgress, readySlices } from '../../../framework/hooks/shared/slice-progress.js';
 
-const PHASE_DIRS = {
-  proposal: '0-proposal',
-  uiux: '1-design',
-  plan: '2-plan',
-  implement: '3-implement',
-  review: '4-review',
-};
-
-/** Ordered pointer candidates — only existing paths make it into the doc. */
 const POINTER_CANDIDATES = [
-  ['0-proposal/proposal.md', 'proposta: problema, escopo e riscos'],
-  // Behaviour before solution — the same order morph-plan writes them in.
-  ['2-plan/usecases', 'use cases: comportamento e pós-condições testáveis (pasta)'],
-  ['2-plan/spec.md', 'especificação técnica'],
-  ['2-plan/tasks.json', 'DAG de tasks (status vivo)'],
-  ['decisions.md', 'decisões registradas'],
-  ['3-implement/recap.md', 'recap da implementação'],
-  ['4-review/review-report.md', 'relatório do Gate 3'],
+  ['2-plan/plan.md', 'plano: problema, cenários com prova, decisões e fatias'],
+  ['2-plan/checks.json', 'cenários e fatias extraídos pelo plan-check'],
+  ['1-design/design-system.md', 'design system da feature'],
+  ['3-implement/reports', 'relatórios das fatias (**Arquivos:**/**Standards:**): o registro da implementação'],
+  ['4-review/verifier.md', 'verificador do Gate 3: cada cenário provado'],
+  ['4-review/reviewer.md', 'revisor do Gate 3: escopo, arquitetura, regressão'],
+  ['4-review/security.md', 'segurança do Gate 3 (só com caminho sensível)'],
 ];
 
 function readJson(path) {
   return JSON.parse(readFileSync(path, 'utf8').replace(/^/, ''));
 }
 
-function taskSummary(featureDir) {
-  try {
-    const tasksPath = join(featureDir, '2-plan', 'tasks.json');
-    if (!existsSync(tasksPath)) return null;
-    const data = readJson(tasksPath);
-    if (!Array.isArray(data.tasks)) return null;
-    const done = data.tasks.filter((t) => t.status === 'done').length;
-    const doneIds = new Set(data.tasks.filter((t) => t.status === 'done').map((t) => t.id));
-    const ready = data.tasks.filter(
-      (t) => t.status === 'pending' && Array.isArray(t.dependencies) && t.dependencies.every((d) => doneIds.has(d)),
-    );
-    return { done, total: data.tasks.length, ready };
-  } catch {
-    return null;
-  }
-}
-
 function decisionTitles(featureDir, limit = 5) {
   try {
-    const path = join(featureDir, 'decisions.md');
+    const path = join(featureDir, '2-plan', 'checks.json');
     if (!existsSync(path)) return [];
-    const titles = [...readFileSync(path, 'utf8').matchAll(/^##\s+(.+)$/gm)].map((m) => m[1].trim());
-    return titles.slice(-limit);
+    const adrs = readJson(path).adrs;
+    if (!Array.isArray(adrs)) return [];
+    return adrs.map((a) => `${a.id} — ${a.title}`).slice(-limit);
   } catch {
     return [];
   }
@@ -86,53 +46,34 @@ function readWorktreeEnv(cwd) {
   }
 }
 
-function nextAction(feature, phase, tasks, featureName) {
+function nextAction(feature, phase, slices, featureName) {
   const gates = feature.approvals || feature.approvalGates || {};
   const approved = (g) => gates[g]?.approved === true;
 
   switch (phase) {
-    case 'proposal':
-      // An approved Gate 1 with no plan artifact yet means "plan work is open":
-      // the derived phase only flips when 2-plan/spec.md lands (derivePhase is
-      // artifact-first). Pointing back at the proposal here would be wrong.
-      return approved('proposal')
-        ? `Gate 1 aprovado — produza \`2-plan/spec.md\` + \`tasks.json\` (a fase avança com o primeiro artefato; Gate 2 em seguida).`
-        : `Complete \`0-proposal/proposal.md\` e aprove o Gate 1 (\`morph-spec advance ${featureName}\`). Skill: /morph-proposal ${featureName}.`;
+    case 'plan':
+      return `Escreva \`2-plan/plan.md\`, rode \`morph-spec plan-check ${featureName}\` até zero erro e aprove o gate do plano (\`morph-spec advance ${featureName}\`). Skill: /morph-plan ${featureName}.`;
     case 'uiux':
       return approved('uiux')
-        ? `Gate de uiux aprovado — produza \`2-plan/spec.md\` + \`tasks.json\` (Gate 2 em seguida).`
+        ? `Gate de uiux aprovado — implemente as fatias do plano via /morph-apply ${featureName}.`
         : `Complete \`1-design/design-system.md\` e aprove o gate de uiux (\`morph-spec advance ${featureName}\`).`;
-    case 'plan':
-      return `Produza \`2-plan/spec.md\` + \`tasks.json\` e aprove o Gate 2 (\`morph-spec advance ${featureName}\`).`;
     case 'implement': {
-      const ready = tasks?.ready?.map((t) => `${t.id} "${t.title}"`).join(', ');
+      const ready = readySlices(slices).map((s) => `${s.id} "${s.title}"`).join(', ');
       return ready
-        ? `Execute as tasks ready — ${ready} — via /morph-apply ${featureName} (task fecha com verify verde e critérios provados).`
-        : `Todas as tasks concluídas ou bloqueadas — rode \`morph-spec advance ${featureName}\` para escancarar a review, ou destrave dependências. Skill: /morph-apply ${featureName}.`;
+        ? `Implemente as fatias prontas — ${ready} — via /morph-apply ${featureName} (cada fatia grava 3-implement/reports/{id}.md).`
+        : `Todas as fatias têm relatório final — rode \`morph-spec verify ${featureName}\` e siga para a review. Skill: /morph-apply ${featureName}.`;
     }
     case 'review':
       return approved('review')
         ? `Gate 3 aprovado — feche: \`morph-spec finish ${featureName} --pr\` (abre PR) ou \`--merge\` (merge local na default). Arquiva + integra num passo.`
-        : `Produza \`4-review/review-report.md\` (avaliador independente) e aprove o Gate 3; depois \`morph-spec finish ${featureName} --pr|--merge\`.`;
+        : `Rode /morph-review ${featureName} (verificador ∥ revisor, segurança se exigida) e aprove o Gate 3; depois \`morph-spec finish ${featureName} --pr|--merge\`.`;
     default:
       return `Rode \`morph-spec status ${featureName}\` para orientar o próximo passo.`;
   }
 }
 
-/**
- * Build the handoff document for a feature, resolved against `cwd` (primary
- * root or worktree — wherever the feature's `.morph/features/{f}` lives).
- *
- * @param {string} featureName
- * @param {string} [cwd]
- * @param {{ worktree?: {path:string, branch:string}|null }} [opts] - override
- *   the `worktree` bookkeeping instead of reading `feature.worktree`. Needed
- *   because that field is ROOT-OWNED and stripped from every branch-local
- *   copy at birth (create.js) — a handoff built FROM the worktree's own copy
- *   would otherwise always say "no worktree registered", even while sitting
- *   inside one. Pass `undefined` (the default) to fall back to `feature.worktree`.
- * @returns {{ markdown: string, meta: { generatedAt: string, phase: string, tasksDone: number, tasksTotal: number } } | null}
- */
+// `opts.worktree` overrides `feature.worktree`: that field is root-owned and stripped from branch-local
+// copies, so a handoff built inside a worktree would otherwise say "no worktree registered".
 export function buildHandoff(featureName, cwd = process.cwd(), opts = {}) {
   const featureDir = join(cwd, '.morph', 'features', featureName);
   if (!existsSync(join(featureDir, 'feature.json'))) return null;
@@ -144,15 +85,15 @@ export function buildHandoff(featureName, cwd = process.cwd(), opts = {}) {
     return null;
   }
 
-  let phase = 'proposal';
+  let phase = 'plan';
   let pendingGates = [];
   try {
-    phase = derivePhaseForFeature(featureName, cwd) || 'proposal';
+    phase = derivePhaseForFeature(featureName, cwd) || 'plan';
     pendingGates = getPendingGates(featureName, cwd) || [];
-  } catch { /* fail-open — proposal defaults keep the doc useful */ }
+  } catch {}
 
   const generatedAt = new Date().toISOString();
-  const tasks = taskSummary(featureDir);
+  const slices = sliceProgress(featureDir);
   const env = readWorktreeEnv(cwd);
   const decisions = decisionTitles(featureDir);
   const worktree = opts.worktree !== undefined ? opts.worktree : (feature.worktree || null);
@@ -187,9 +128,9 @@ export function buildHandoff(featureName, cwd = process.cwd(), opts = {}) {
     '## Estado',
     '',
     `- Gates: ${gateLine}`,
-    tasks
-      ? `- Tasks: ${tasks.done}/${tasks.total} done · ready agora: ${tasks.ready.length ? tasks.ready.map((t) => `**${t.id}** "${t.title}"`).join(', ') : 'nenhuma'}`
-      : '- Tasks: sem tasks.json ainda (fase de planejamento não concluída)',
+    slices
+      ? `- Fatias: ${slices.done}/${slices.total} feitas${slices.partial ? ` · ${slices.partial} parcial(is)` : ''} · prontas agora: ${readySlices(slices).map((s) => `**${s.id}** "${s.title}"`).join(', ') || 'nenhuma'}`
+      : '- Fatias: sem checks.json ainda (rode plan-check)',
     pendingGates.length ? `- Gates pendentes: ${pendingGates.join(', ')}` : null,
     '',
     '## Leia nesta ordem (ponteiros — nada copiado)',
@@ -200,7 +141,7 @@ export function buildHandoff(featureName, cwd = process.cwd(), opts = {}) {
     '',
     '## Próxima ação',
     '',
-    nextAction(feature, phase, tasks, featureName),
+    nextAction(feature, phase, slices, featureName),
     '',
     '## Retomar',
     '',
@@ -214,8 +155,8 @@ export function buildHandoff(featureName, cwd = process.cwd(), opts = {}) {
     meta: {
       generatedAt,
       phase,
-      tasksDone: tasks?.done ?? 0,
-      tasksTotal: tasks?.total ?? 0,
+      slicesDone: slices?.done ?? 0,
+      slicesTotal: slices?.total ?? 0,
     },
   };
 }
@@ -224,29 +165,13 @@ export function buildHandoff(featureName, cwd = process.cwd(), opts = {}) {
 const HANDOFF_EXCLUDE_MARKER = '# morph-spec: derived handoff docs (managed — see handoff-generator)';
 const HANDOFF_EXCLUDE_PATTERN = '/.morph/**/handoff.md';
 
-/**
- * The handoff is DERIVED from committed sources, so it is never committed
- * itself — regenerate > synchronize, the same principle as the materialized
- * state.json. Left visible, every `worktree setup`/`advance` would drop an
- * untracked file into the very `git status` the finish gates read. The
- * common-dir `.git/info/exclude` hides it in every worktree of the repo
- * (including the primary root); `**` also covers a feature folder after
- * `archive` moves it. Idempotent and fail-open — a handoff that shows up as
- * untracked is noise, never data loss.
- */
+// Never committed: left visible it lands in the `git status` the finish gates read. The common-dir
+// exclude hides it in every worktree; `**` also covers a feature folder after `archive` moves it.
 function ensureHandoffExcluded(cwd) {
   ensureCommonExclude(cwd, [HANDOFF_EXCLUDE_PATTERN], HANDOFF_EXCLUDE_MARKER);
 }
 
-/**
- * Write `.morph/features/{f}/handoff.md`. Returns the written path, or null
- * when the feature does not exist (nothing is created).
- *
- * @param {string} featureName
- * @param {string} [cwd]
- * @param {{ worktree?: {path:string, branch:string}|null }} [opts] - see buildHandoff
- * @returns {string|null}
- */
+/** The written path, or null when the feature does not exist (nothing is created). */
 export function writeHandoff(featureName, cwd = process.cwd(), opts = {}) {
   const result = buildHandoff(featureName, cwd, opts);
   if (!result) return null;

package/src/lib/generators/scaffold-generator.js

@@ -1,22 +1,8 @@
-/**
- * Scaffold Generator - Generates VSA feature slice (.NET) and feature page (Next.js) files.
- *
- * Uses existing Handlebars templates from framework/templates/ to generate
- * complete feature structures with one command.
- *
- * @module scaffold-generator
- */
-
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs';
 import { join, dirname, basename } from 'path';
 import { renderTemplate } from '../../core/templates/template-renderer.js';
 import { resolveFrameworkTemplatePath } from '../../core/templates/template-registry.js';
 
-/**
- * Convert kebab-case to PascalCase.
- * @param {string} str
- * @returns {string}
- */
 function toPascalCase(str) {
   return str
     .split('-')
@@ -24,11 +10,6 @@ function toPascalCase(str) {
     .join('');
 }
 
-/**
- * Convert kebab-case to camelCase.
- * @param {string} str
- * @returns {string}
- */
 function toCamelCase(str) {
   return str
     .split('-')
@@ -36,16 +17,8 @@ function toCamelCase(str) {
     .join('');
 }
 
-/**
- * Normalize a namespace to kebab-case so Handlebars {{pascalCase}} reconstructs it correctly.
- * Handles: PascalCase ("MyBookStore" → "my-book-store"), dot-separated ("My.App" → "my-app"),
- * and already kebab-case pass-through.
- * @param {string} ns
- * @returns {string}
- */
+/** Kebab-case so Handlebars {{pascalCase}} reconstructs it: "MyBookStore" → "my-book-store", "My.App" → "my-app". */
 export function normalizeNamespaceToKebab(ns) {
-  // Split on dots first (My.BookStore → ["My", "BookStore"])
-  // Then split PascalCase on uppercase boundaries (BookStore → Book-Store)
   return ns
     .split('.')
     .map(segment =>
@@ -57,15 +30,8 @@ export function normalizeNamespaceToKebab(ns) {
     .join('-');
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// .NET VSA Scaffold
-// ─────────────────────────────────────────────────────────────────────────────
-
-// Each entry pairs a REGISTRY.json template `id` with the generator-specific
-// output shaping (class-name suffix, target directory). REGISTRY owns the
-// template path; the generator owns where the rendered file lands.
+// REGISTRY.json owns the template path; the generator owns where the rendered file lands.
 
-/** .NET slice-level files (endpoint/handler/request/response/validator). */
 const DOTNET_SLICE_TEMPLATES = [
   { templateId: 'dotnet-feature-endpoint', suffix: 'Endpoint' },
   { templateId: 'dotnet-feature-handler', suffix: 'Handler' },
@@ -74,23 +40,11 @@ const DOTNET_SLICE_TEMPLATES = [
   { templateId: 'dotnet-feature-validator', suffix: 'Validator' },
 ];
 
-/** .NET feature-level files (entity, errors). */
 const DOTNET_FEATURE_TEMPLATES = [
   { templateId: 'dotnet-feature-entity', suffix: '', dir: 'entities' },
   { templateId: 'dotnet-feature-errors', suffix: 'Errors', dir: 'feature' },
 ];
 
-/**
- * Scaffold a .NET VSA feature slice.
- *
- * @param {Object} options
- * @param {string} options.feature - Entity/feature name in kebab-case (e.g., "book")
- * @param {string} options.sliceName - Slice name in kebab-case (e.g., "create-book")
- * @param {string} options.namespace - Root namespace (e.g., "MyApp")
- * @param {string} [options.outputDir] - Base output directory (default: cwd)
- * @param {boolean} [options.dryRun] - Preview without writing
- * @returns {{ files: Array<{path: string, content: string, skipped: boolean}> }}
- */
 export function scaffoldDotnetSlice(options) {
   const { feature, sliceName, namespace, outputDir = process.cwd(), dryRun = false } = options;
 
@@ -107,7 +61,6 @@ export function scaffoldDotnetSlice(options) {
 
   const files = [];
 
-  // 1. Render slice-level templates
   for (const tmpl of DOTNET_SLICE_TEMPLATES) {
     const templatePath = resolveFrameworkTemplatePath(tmpl.templateId);
     const outputPath = join(
@@ -128,7 +81,6 @@ export function scaffoldDotnetSlice(options) {
     files.push({ path: outputPath, content, skipped: false });
   }
 
-  // 2. Render feature-level templates (skip if already exist)
   for (const tmpl of DOTNET_FEATURE_TEMPLATES) {
     const templatePath = resolveFrameworkTemplatePath(tmpl.templateId);
     let outputPath;
@@ -157,12 +109,6 @@ export function scaffoldDotnetSlice(options) {
   return { files };
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Next.js Scaffold
-// ─────────────────────────────────────────────────────────────────────────────
-
-// Each entry pairs a REGISTRY.json template `id` with where the rendered file
-// lands. REGISTRY owns the template path; the generator owns the output path.
 const NEXTJS_TEMPLATES = [
   {
     templateId: 'nextjs-page',
@@ -182,15 +128,6 @@ const NEXTJS_TEMPLATES = [
   },
 ];
 
-/**
- * Scaffold a Next.js feature page with components and hooks.
- *
- * @param {Object} options
- * @param {string} options.featureName - Feature name in kebab-case (e.g., "book")
- * @param {string} [options.outputDir] - Base output directory (default: cwd)
- * @param {boolean} [options.dryRun] - Preview without writing
- * @returns {{ files: Array<{path: string, content: string, skipped: boolean}> }}
- */
 export function scaffoldNextjsFeature(options) {
   const { featureName, outputDir = process.cwd(), dryRun = false } = options;
 
@@ -226,33 +163,15 @@ export function scaffoldNextjsFeature(options) {
   return { files };
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Namespace Detection
-// ─────────────────────────────────────────────────────────────────────────────
-
-/**
- * Detect the .NET root namespace from .csproj or config.json.
- *
- * Search order:
- * 1. *.csproj in dir (extract <RootNamespace>)
- * 2. *.csproj in dir (use filename without extension)
- * 3. *.csproj one level deep
- * 4. .morph/config.json → project.name
- *
- * @param {string} dir - Directory to search in
- * @returns {string|null} Detected namespace or null
- */
+/** <RootNamespace> or the name of a .csproj here or one level deep, else config.json `project.name`. */
 export function detectNamespace(dir) {
-  // 1. Search for .csproj in current dir
   const csprojInDir = findCsproj(dir);
   if (csprojInDir) {
     const ns = extractNamespaceFromCsproj(csprojInDir);
     if (ns) return ns;
-    // Fallback: use filename
     return basename(csprojInDir, '.csproj');
   }
 
-  // 2. Search one level deep
   try {
     const entries = readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
@@ -265,29 +184,19 @@ export function detectNamespace(dir) {
         }
       }
     }
-  } catch {
-    // ignore read errors
-  }
+  } catch {}
 
-  // 3. Fall back to config.json
   const configPath = join(dir, '.morph', 'config.json');
   if (existsSync(configPath)) {
     try {
       const config = JSON.parse(readFileSync(configPath, 'utf-8'));
       if (config.project?.name) return config.project.name;
-    } catch {
-      // ignore parse errors
-    }
+    } catch {}
   }
 
   return null;
 }
 
-/**
- * Find the first .csproj file in a directory.
- * @param {string} dir
- * @returns {string|null}
- */
 function findCsproj(dir) {
   try {
     const entries = readdirSync(dir);
@@ -298,11 +207,6 @@ function findCsproj(dir) {
   }
 }
 
-/**
- * Extract <RootNamespace> from a .csproj file.
- * @param {string} csprojPath
- * @returns {string|null}
- */
 function extractNamespaceFromCsproj(csprojPath) {
   try {
     const content = readFileSync(csprojPath, 'utf-8');

package/src/lib/generators/settings-generator.js

@@ -1,10 +1,4 @@
-/**
- * Settings Generator
- *
- * Generates .claude/settings.local.json for projects based on detected
- * stack, MCPs, and morph-spec configuration. Uses _morph_managed marker
- * to track managed entries for safe reset.
- */
+// `_morph_managed` marks the managed entries, so a reset never touches the user's.
 
 import { join } from 'path';
 import { existsSync } from 'fs';
@@ -12,44 +6,22 @@ import { readFile, writeFile, mkdir } from 'fs/promises';
 
 const MORPH_MANAGED_KEY = '_morph_managed';
 
-/**
- * Generate and merge settings for a project
- * @param {string} targetPath - Project root directory
- * @param {Object} detectedConfig - Output from detectClaudeConfig()
- * @param {Object} morphConfig - morph-spec config (from .morph/config/config.json)
- * @returns {Promise<Object>} Generated settings summary
- */
 export async function generateSettings(targetPath, detectedConfig, morphConfig = {}) {
   const claudeDir = join(targetPath, '.claude');
   const settingsPath = join(claudeDir, 'settings.local.json');
 
-  // Read existing settings
-  const existing = await readSettingsSafe(settingsPath);
-
-  // Build stack-based permissions
-  const stack = morphConfig?.project?.architecture || 'unknown';
-  const permissions = buildPermissions(stack, detectedConfig);
-
-  // Build generated settings
+  const existing = withoutLegacyPermissions(await readSettingsSafe(settingsPath));
   const generated = {};
 
-  if (permissions.length > 0) {
-    generated.permissions = permissions;
-  }
-
-  // Track what we manage
   const managed = {
-    permissions_added: permissions,
     mcps_detected: detectedConfig.mcpServers.map(s => s.name),
-    plugins_detected: detectedConfig.plugins.map(p => p.name),
+    plugins_detected: detectedConfig.plugins.map(p => (typeof p === 'string' ? p : p?.name)),
     generated_at: new Date().toISOString()
   };
 
-  // Merge without overwriting user config
   const merged = mergeSettings(existing, generated);
   merged[MORPH_MANAGED_KEY] = managed;
 
-  // Ensure directory exists
   if (!existsSync(claudeDir)) {
     await mkdir(claudeDir, { recursive: true });
   }
@@ -58,50 +30,11 @@ export async function generateSettings(targetPath, detectedConfig, morphConfig =
 
   return {
     settingsPath,
-    permissionsAdded: permissions.length,
     managed
   };
 }
 
-/**
- * Build permission rules based on detected stack
- * @param {string} stack - Detected project stack
- * @param {Object} detectedConfig - Detected Claude config
- * @returns {Array<string>} Permission patterns
- */
-export function buildPermissions(stack, detectedConfig = {}) {
-  const permissions = [];
-
-  // Stack-based permissions
-  const stackPermissions = {
-    nodejs: ['Bash(node:*)', 'Bash(npm:*)', 'Bash(npx:*)'],
-    typescript: ['Bash(node:*)', 'Bash(npm:*)', 'Bash(npx:*)', 'Bash(tsc:*)'],
-    nextjs: ['Bash(node:*)', 'Bash(npm:*)', 'Bash(npx:*)'],
-    react: ['Bash(node:*)', 'Bash(npm:*)', 'Bash(npx:*)'],
-    vue: ['Bash(node:*)', 'Bash(npm:*)', 'Bash(npx:*)'],
-    dotnet: ['Bash(dotnet:*)', 'Bash(nuget:*)'],
-    python: ['Bash(python:*)', 'Bash(pip:*)', 'Bash(pytest:*)'],
-    go: ['Bash(go:*)']
-  };
-
-  if (stackPermissions[stack]) {
-    permissions.push(...stackPermissions[stack]);
-  }
-
-  // morph-spec CLI always needs node/npx
-  if (!permissions.includes('Bash(npx:*)')) {
-    permissions.push('Bash(npx:*)');
-  }
-
-  return permissions;
-}
-
-/**
- * Deep merge settings without overwriting user entries
- * @param {Object} existing - Current settings.local.json
- * @param {Object} generated - Generated settings to merge
- * @returns {Object} Merged settings
- */
+/** Never overwrites user entries: arrays are unioned, objects merged, only new keys added. */
 export function mergeSettings(existing, generated) {
   const result = { ...existing };
 
@@ -109,17 +42,14 @@ export function mergeSettings(existing, generated) {
     if (key === MORPH_MANAGED_KEY) continue;
 
     if (Array.isArray(value) && Array.isArray(result[key])) {
-      // Merge arrays without duplicates
       const set = new Set(result[key]);
       for (const item of value) {
         set.add(item);
       }
       result[key] = [...set];
     } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-      // Recursively merge objects
       result[key] = mergeSettings(result[key] || {}, value);
     } else if (!(key in result)) {
-      // Only add new keys, never overwrite existing
       result[key] = value;
     }
   }
@@ -127,51 +57,6 @@ export function mergeSettings(existing, generated) {
   return result;
 }
 
-/**
- * Remove only morph-spec managed entries from settings
- * @param {string} settingsPath - Path to settings.local.json
- * @returns {Promise<Object>} Summary of what was removed
- */
-export async function resetMorphSettings(settingsPath) {
-  if (!existsSync(settingsPath)) {
-    return { removed: false, reason: 'file not found' };
-  }
-
-  const settings = await readSettingsSafe(settingsPath);
-  const managed = settings[MORPH_MANAGED_KEY];
-
-  if (!managed) {
-    return { removed: false, reason: 'no _morph_managed section found' };
-  }
-
-  // Remove managed permissions
-  if (managed.permissions_added && Array.isArray(settings.permissions)) {
-    settings.permissions = settings.permissions.filter(
-      p => !managed.permissions_added.includes(p)
-    );
-    if (settings.permissions.length === 0) {
-      delete settings.permissions;
-    }
-  }
-
-  // Remove the managed marker itself
-  delete settings[MORPH_MANAGED_KEY];
-
-  // Write back
-  await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
-
-  return {
-    removed: true,
-    permissionsRemoved: managed.permissions_added || [],
-    previouslyGenerated: managed.generated_at
-  };
-}
-
-/**
- * Save integrations.json with detected config
- * @param {string} targetPath - Project root directory
- * @param {Object} detectedConfig - Output from detectClaudeConfig()
- */
 export async function saveIntegrations(targetPath, detectedConfig) {
   const integrationsPath = join(targetPath, '.morph', 'config', 'integrations.json');
   const integrationsDir = join(targetPath, '.morph', 'config');
@@ -194,9 +79,13 @@ export async function saveIntegrations(targetPath, detectedConfig) {
   return integrationsPath;
 }
 
-// ============================================================================
-// Helpers
-// ============================================================================
+// Claude Code reads only `permissions: { allow, deny }`. Old generators wrote wildcard rules as a bare
+// array that never applied; converting it to { allow } would silently enable them.
+function withoutLegacyPermissions(settings) {
+  if (!Array.isArray(settings.permissions)) return settings;
+  const { permissions, ...rest } = settings;
+  return rest;
+}
 
 async function readSettingsSafe(settingsPath) {
   try {