@polymorphism-tech/morph-spec 9.4.0 → 9.6.0

package/framework/templates/frontend/nextjs/feature-form.tsx.hbs

@@ -1,56 +1,54 @@
-// features/{{kebabCase featureName}}/components/create-{{kebabCase featureName}}-form.tsx
-'use client';
-
-import { useForm } from 'react-hook-form';
-import { zodResolver } from '@hookform/resolvers/zod';
-import { Form, FormControl, FormField, FormItem, FormLabel, FormMessage } from '@/components/ui/form';
-import { Input } from '@/components/ui/input';
-import { Button } from '@/components/ui/button';
-import { useCreate{{pascalCase featureName}} } from '@/features/{{kebabCase featureName}}/hooks/use-create-{{kebabCase featureName}}';
-import { create{{pascalCase featureName}}Schema, type Create{{pascalCase featureName}}Input } from '@/features/{{kebabCase featureName}}/types/{{kebabCase featureName}}.schemas';
-
-interface Create{{pascalCase featureName}}FormProps {
-  onSuccess?: () => void;
-}
-
-export function Create{{pascalCase featureName}}Form({ onSuccess }: Create{{pascalCase featureName}}FormProps) {
-  const form = useForm<Create{{pascalCase featureName}}Input>({
-    resolver: zodResolver(create{{pascalCase featureName}}Schema),
-    defaultValues: { name: '' },
-  });
-
-  const { mutate: create{{pascalCase featureName}}, isPending } = useCreate{{pascalCase featureName}}();
-
-  function onSubmit(values: Create{{pascalCase featureName}}Input) {
-    create{{pascalCase featureName}}(values, {
-      onSuccess: () => { form.reset(); onSuccess?.(); },
-      onError: (error) => { form.setError('root', { message: error.message }); },
-    });
-  }
-
-  return (
-    <Form {...form}>
-      <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-4">
-        <FormField
-          control={form.control}
-          name="name"
-          render={({ field }) => (
-            <FormItem>
-              <FormLabel>Name</FormLabel>
-              <FormControl>
-                <Input placeholder="Enter name" {...field} />
-              </FormControl>
-              <FormMessage />
-            </FormItem>
-          )}
-        />
-        {form.formState.errors.root && (
-          <p className="text-sm text-destructive">{form.formState.errors.root.message}</p>
-        )}
-        <Button type="submit" disabled={isPending}>
-          {isPending ? 'Creating...' : 'Create {{pascalCase featureName}}'}
-        </Button>
-      </form>
-    </Form>
-  );
-}
+// features/{{kebabCase featureName}}/components/create-{{kebabCase featureName}}-form.tsx
+'use client';
+
+import { Controller, useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { Field, FieldError, FieldGroup, FieldLabel } from '@/components/ui/field';
+import { Input } from '@/components/ui/input';
+import { Button } from '@/components/ui/button';
+import { useCreate{{pascalCase featureName}} } from '@/features/{{kebabCase featureName}}/hooks/use-create-{{kebabCase featureName}}';
+import { create{{pascalCase featureName}}Schema, type Create{{pascalCase featureName}}Input } from '@/features/{{kebabCase featureName}}/types/{{kebabCase featureName}}.schemas';
+
+interface Create{{pascalCase featureName}}FormProps {
+  onSuccess?: () => void;
+}
+
+export function Create{{pascalCase featureName}}Form({ onSuccess }: Create{{pascalCase featureName}}FormProps) {
+  const form = useForm<Create{{pascalCase featureName}}Input>({
+    resolver: zodResolver(create{{pascalCase featureName}}Schema),
+    defaultValues: { name: '' },
+  });
+
+  const { mutate: create{{pascalCase featureName}}, isPending } = useCreate{{pascalCase featureName}}();
+
+  function onSubmit(values: Create{{pascalCase featureName}}Input) {
+    create{{pascalCase featureName}}(values, {
+      onSuccess: () => { form.reset(); onSuccess?.(); },
+      onError: (error) => { form.setError('root', { message: error.message }); },
+    });
+  }
+
+  return (
+    <form onSubmit={form.handleSubmit(onSubmit)}>
+      <FieldGroup>
+        <Controller
+          name="name"
+          control={form.control}
+          render={({ field, fieldState }) => (
+            <Field data-invalid={fieldState.invalid}>
+              <FieldLabel htmlFor={field.name}>Name</FieldLabel>
+              <Input {...field} id={field.name} aria-invalid={fieldState.invalid} placeholder="Enter name" />
+              {fieldState.invalid && <FieldError errors={[fieldState.error]} />}
+            </Field>
+          )}
+        />
+        {form.formState.errors.root && (
+          <p className="text-sm text-destructive">{form.formState.errors.root.message}</p>
+        )}
+        <Button type="submit" disabled={isPending}>
+          {isPending ? 'Creating...' : 'Create {{pascalCase featureName}}'}
+        </Button>
+      </FieldGroup>
+    </form>
+  );
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "9.4.0",
+  "version": "9.6.0",
   "description": "MORPH-SPEC: NLH (Natural Language Harness) for spec-driven development with Claude Code",
   "keywords": [
     "claude-code",
@@ -56,7 +56,8 @@
     "docs:serve": "npx http-server docs/api -p 8080 -o",
     "release": "node scripts/release.js",
     "prepublishOnly": "node scripts/prepublish-check.js",
-    "postinstall": "node src/scripts/global-install.js"
+    "postinstall": "node src/scripts/global-install.js",
+    "publish:web": "node scripts/publish-web.mjs"
   },
   "dependencies": {
     "chalk": "^5.3.0",

package/src/commands/e2e/e2e.js

@@ -28,6 +28,7 @@ import { buildComposeEnv } from '../../lib/e2e/compose-env.js';
 import { findWorktreeForFeature, resolvePrimaryRoot } from '../project/worktree.js';
 import { createHeavyGate, HeavyBusyError } from '../../lib/heavy/gate.js';
 import { afterHeavyRun } from '../../lib/heavy/cleanup.js';
+import { memoryBusyHint } from '../../lib/heavy/live-stacks.js';
 import { readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js';
 
 const EXIT_USAGE = 2;
@@ -126,6 +127,8 @@ export async function e2eUpCommand(featureName, options = {}) {
       console.log(JSON.stringify({ status: 'busy', feature: featureName, busy: { reason: err.reason, waitedMs: err.waitedMs } }, null, 2));
     }
     console.error(chalk.yellow(`\n⏳ e2e up não rodou: ${err.message}. Não é vermelho — a fila já esperou o prazo dela: não repita em laço — siga sem esta rodada e avise o usuário (\`morph-spec heavy status\`).\n`));
+    const hint = memoryBusyHint(err, ctx.cwd);
+    if (hint) console.error(chalk.yellow(`${hint}\n`));
     process.exit(EXIT_BUSY);
   } finally {
     gate.release();

package/src/commands/project/env.js

@@ -35,7 +35,7 @@ function gitCommonDir(cwd) {
 const shq = (v) => `'${String(v).replace(/'/g, "'\\''")}'`;
 
 /** The env map for a key, or `{ error }`. */
-export function resolveWorktreeEnv(featureArg, cwd = process.cwd()) {
+export function resolveWorktreeEnv(featureArg, cwd = process.cwd(), { withCredentials = true } = {}) {
   const key = featureArg || envKeyFromBranch(currentBranch(cwd));
   if (!key) {
     return { error: 'no-feature', message: 'Nenhuma feature: passe o nome ou rode de uma branch morph/{f} / morph-task/{n}.' };
@@ -45,7 +45,7 @@ export function resolveWorktreeEnv(featureArg, cwd = process.cwd()) {
     return { error: 'not-a-git-repo', message: 'Fora de um repositório git não há bloco de portas.' };
   }
   const root = resolvePrimaryRoot(cwd);
-  const env = buildComposeEnv({ cwd: root, config: readConfig(root), featureName: key, gitCommonDir: common });
+  const env = buildComposeEnv({ cwd: root, config: readConfig(root), featureName: key, gitCommonDir: common, withCredentials });
   return { key, env };
 }
 
@@ -57,7 +57,7 @@ export function render(env, format) {
 }
 
 export function envCommand(featureArg, options = {}) {
-  const result = resolveWorktreeEnv(featureArg || null, process.cwd());
+  const result = resolveWorktreeEnv(featureArg || null, process.cwd(), { withCredentials: Boolean(options.withSecrets) });
   if (result.error) {
     if (options.json) console.log(JSON.stringify({ error: result.error, message: result.message }));
     else console.error(chalk.red(`✗ ${result.message}`));

package/src/commands/project/heavy.js

@@ -5,6 +5,8 @@ import { readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js
 import { createHeavyGate, HeavyBusyError } from '../../lib/heavy/gate.js';
 import { describeHolder, heavyDir, heavyStatus } from '../../../framework/hooks/shared/heavy-slots.js';
 import { resolveSpawn } from '../../../framework/hooks/shared/spawn-command.js';
+import { heavyClass, heavyKind } from '../../../framework/hooks/shared/heavy-command.js';
+import { memoryBusyHint } from '../../lib/heavy/live-stacks.js';
 
 const EXIT_BUSY = 3;
 
@@ -15,6 +17,7 @@ export function heavyStatusCommand(options = {}) {
     enabled: config.enabled,
     slots: config.slots,
     minFreeMemGb: config.minFreeMemGb,
+    minFreeMemGbByKind: config.minFreeMemGbByKind,
     dir: status.dir,
     freeGb: Number(status.freeGb.toFixed(2)),
     holders: status.holders.map(({ pid, label, feature, node, cwd, since, leaseId }) => ({ pid, label, feature, node, cwd, since, ...(leaseId ? { leaseId } : {}) })),
@@ -29,8 +32,10 @@ export function heavyStatusCommand(options = {}) {
   logger.header('Slots de nós pesados (build, testes, e2e)');
   if (!config.enabled) console.log(chalk.yellow('  ⚠ semáforo desligado (heavy.enabled: false ou MORPH_HEAVY=off)'));
   console.log(chalk.gray(`  diretório: ${report.dir}`));
-  const memMark = report.freeGb < config.minFreeMemGb ? chalk.yellow('⚠') : chalk.green('✓');
-  console.log(`  ${memMark} RAM livre: ${report.freeGb.toFixed(1)} GB (mínimo ${config.minFreeMemGb} GB)`);
+  const floors = config.minFreeMemGbByKind;
+  const memMark = report.freeGb < Math.max(...Object.values(floors)) ? chalk.yellow('⚠') : chalk.green('✓');
+  const floorText = Object.entries(floors).map(([kind, gb]) => `${kind} ${gb}`).join(' · ');
+  console.log(`  ${memMark} RAM livre: ${report.freeGb.toFixed(1)} GB (mínimo em GB: ${floorText})`);
   console.log(`  slots em uso: ${status.holders.length}/${config.slots}`);
   for (const h of status.holders) console.log(chalk.gray(`    • ${describeHolder(h)}${h.cwd ? ` — ${h.cwd}` : ''}`));
   if (status.exclusive) console.log(chalk.yellow(`  ⚠ limpeza do servidor de build em curso (${describeHolder(status.exclusive)})`));
@@ -42,10 +47,12 @@ export function heavyRunCommand(command, options = {}) {
   const [file, ...args] = command;
   const gate = createHeavyGate({ projectPath: process.cwd(), label: options.label ?? 'run' });
   try {
-    gate.enter(file);
+    gate.enter(file, heavyClass(heavyKind(command.join(' '))));
   } catch (err) {
     if (!(err instanceof HeavyBusyError)) throw err;
     console.error(chalk.yellow(`\n⏳ ${file} não rodou: ${err.message}. Não é vermelho — a fila já esperou o prazo dela: não repita em laço — siga sem esta rodada e avise o usuário (\`morph-spec heavy status\` mostra quem segura os slots).\n`));
+    const hint = memoryBusyHint(err, process.cwd());
+    if (hint) console.error(chalk.yellow(`${hint}\n`));
     process.exit(EXIT_BUSY);
   }
 

package/src/commands/project/worktree.js

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, symlinkSync, readFileSync, writeFileSync, lstatS
 import { join, resolve, dirname, basename } from 'path';
 import chalk from 'chalk';
 import { detectDefaultBranch } from '../../lib/git/default-branch.js';
-import { triageIgnoredPaths } from '../../lib/worktree/ignored-triage.js';
+import { isTestArtifact, triageIgnoredPaths } from '../../lib/worktree/ignored-triage.js';
 import {
   finishBackupDir,
   writeFeatureScopeBackup,
@@ -710,6 +710,7 @@ export function primaryRootUnexplainedDirt(root, feature, opts = {}) {
     if (!record || record.length < 4) return false;
     const p = record.slice(3).replace(/\\/g, '/');
     if (opts.exemptOwnScope && p.startsWith(ownScope)) return false;
+    if (record.startsWith('?? ') && isTestArtifact(p)) return false;
     return !isLiveSiblingWorktreeRegistration(p, root, feature);
   });
   return { ok: true, dirt };

package/src/commands/state/finish.js

@@ -1,5 +1,5 @@
 import { execFileSync } from 'child_process';
-import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, readFileSync, rmSync, writeFileSync } from 'fs';
 import { join, resolve } from 'path';
 import {
   findWorktreeForFeature,
@@ -23,6 +23,7 @@ import { findReparsePoints } from '../../../framework/hooks/shared/reparse-scan.
 import { runArchive } from './archive.js';
 import { dropLeftoverIgnore, withoutLeftoverIgnore } from '../../../framework/hooks/shared/graph-freshness.js';
 import { newBackupStamp, enforceBackupRetention, inspectFinishBackups } from '../../lib/worktree/finish-backup.js';
+import { isTestArtifact } from '../../lib/worktree/ignored-triage.js';
 
 const PR_TYPE_BY_WORK_TYPE = { feature: 'feat', bug: 'fix', hotfix: 'fix', chore: 'chore' };
 
@@ -289,7 +290,9 @@ export async function finishCommand(feature, options = {}) {
     emit({ finished: false, error: 'status-failed', feature });
     process.exit(1);
   }
-  if (withoutLeftoverIgnore(cleanCwd, dirty.split(/\r?\n/).filter((l) => l.trim())).length) {
+  const dirtLines = withoutLeftoverIgnore(cleanCwd, dirty.split(/\r?\n/).filter((l) => l.trim()));
+  const testArtifacts = untrackedTestArtifacts(dirtLines);
+  if (dirtLines.length > testArtifacts.length) {
     emit({ finished: false, error: isWorktreeFlow ? 'worktree-dirty' : 'working-dir-dirty', hint: 'commit seu trabalho na branch antes do finish', feature });
     process.exit(1);
   }
@@ -338,7 +341,10 @@ export async function finishCommand(feature, options = {}) {
 
   // Every refusal is behind us: the leftover of a killed `graph refresh` goes now, never before.
   dropLeftoverIgnore(cleanCwd);
-  const arch = runArchive(feature, { cwd: featureCwd, force: options.force, git: true });
+  if (isWorktreeFlow) {
+    for (const p of testArtifacts) rmSync(join(cleanCwd, p), { recursive: true, force: true });
+  }
+  const arch =runArchive(feature, { cwd: featureCwd, force: options.force, git: true });
   if (!arch.ok) {
     emit({ finished: false, error: `archive-${arch.error}`, feature });
     process.exit(1);
@@ -794,6 +800,14 @@ function currentBranch(cwd) {
   }
 }
 
+/** Untracked Playwright/test output (`?? test-results/`): never work, so it neither blocks nor survives the teardown. */
+function untrackedTestArtifacts(lines) {
+  return lines
+    .filter((l) => l.startsWith('?? '))
+    .map((l) => l.slice(3).replace(/^"|"$/g, '').replace(/\/$/, ''))
+    .filter((p) => isTestArtifact(p));
+}
+
 function gitStatusPorcelain(cwd) {
   try {
     return execFileSync('git', ['status', '--porcelain'], { cwd, stdio: 'pipe' }).toString();

package/src/commands/validation/mutate.js

@@ -113,13 +113,13 @@ function subsetFor({ node, group, root }) {
 
 function e2eManualProtocol(feature, node) {
   const f = feature ?? '<feature>';
-  const round = `eval "$(morph-spec env ${f})" && morph-spec e2e up ${f} && morph-spec heavy run -- ${node.command}`;
+  const round = `eval "$(morph-spec env ${f} --with-secrets)" && morph-spec e2e up ${f} && morph-spec heavy run -- ${node.command}`;
   return 'mutate só recompila localmente, e a suíte que alcança esse código testa o container do compose: o mutante sairia sobrevivente em falso. ' +
     `Prove à mão pelo nó "${node.id}", cada passo numa linha só e encadeado por \`&&\` (nunca \`;\`: um passo que falha não pode deixar a suíte rodar sobre o código original; ` +
     'e o env da feature se perde entre chamadas de Bash): ' +
     `(1) base verde antes do 1º mutante: \`${round}\`; ` +
     `(2) por mutante: edite a linha && \`${round}\`; ` +
-    `(3) restaure, confirme com \`git diff --quiet -- <arquivo>\` e suba a stack de novo (\`eval "$(morph-spec env ${f})" && morph-spec e2e up ${f}\`). ` +
+    `(3) restaure, confirme com \`git diff --quiet -- <arquivo>\` e suba a stack de novo (\`eval "$(morph-spec env ${f} --with-secrets)" && morph-spec e2e up ${f}\`). ` +
     'Registre cada mutante em 4-review (expect, resultado, teste que o matou).';
 }
 

package/src/commands/validation/verify.js

@@ -11,6 +11,7 @@ import { buildVerifyEvent, recordVerifyEvent, findRepeatedVerify } from '../../l
 import { treeFingerprint } from '../../lib/git/tree-fingerprint.js';
 import { HeavyBusyError } from '../../lib/heavy/gate.js';
 import { afterHeavyRun } from '../../lib/heavy/cleanup.js';
+import { memoryBusyHint } from '../../lib/heavy/live-stacks.js';
 import { readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js';
 import { runCiVerify, CiUsageError, reusableLocalStamp } from '../../lib/ci/ci-verify.js';
 
@@ -146,6 +147,8 @@ async function runLocalVerify(featureName, options) {
         }, null, 2));
       }
       console.error(chalk.yellow(`\n⏳ verify não rodou: ${err.message}. Não é vermelho — a fila já esperou o prazo dela: não repita em laço — siga sem esta rodada e avise o usuário (\`morph-spec heavy status\` mostra quem segura os slots).\n`));
+      const hint = memoryBusyHint(err, process.cwd());
+      if (hint) console.error(chalk.yellow(`${hint}\n`));
       process.exit(3);
     }
     throw err;

package/src/core/paths/output-schema.js

@@ -43,15 +43,6 @@ export function getFeatureDir(featureName) {
   return join('.morph', 'features', featureName).replace(/\\/g, '/');
 }
 
-export function getTaskReportPath(featureName, taskId) {
-  return join('.morph', 'features', featureName, '3-implement', 'reports', `${taskId}.md`)
-    .replace(/\\/g, '/');
-}
-
-export function getAbsoluteTaskReportPath(projectRoot, featureName, taskId) {
-  return join(projectRoot, '.morph', 'features', featureName, '3-implement', 'reports', `${taskId}.md`);
-}
-
 /** `multi` types contribute their directory, so `created` means "the folder exists". */
 export function getAllOutputPaths(featureName) {
   const outputs = {};

package/src/core/state/feature-identity.js

@@ -1,5 +1,3 @@
-export const IDENTITY_FIELDS = ['name', 'description', 'workType', 'createdAt'];
-
 const blank = (v) => v === undefined || v === null || String(v).trim() === '';
 
 // `workType` is excluded on purpose: absent, it defaults to `feature`.

package/src/core/state/state-manager.js

@@ -1,4 +1,4 @@
-import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, mkdirSync, rmdirSync, statSync, readdirSync } from 'fs';
+import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, mkdirSync, readdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { getAllOutputPaths, getOutputPath } from '../paths/output-schema.js';
 import { derivePhaseFrom, diskArtifactProbe } from '../../../framework/hooks/shared/state-reader.js';
@@ -248,41 +248,6 @@ export function saveState(state) {
   });
 }
 
-const LOCK_DIR_NAME = '.morph/state.json.lock';
-const LOCK_MAX_RETRIES = 5;
-const LOCK_BASE_MS = 100;
-const LOCK_STALE_MS = 30_000;
-
-export async function withStateLock(fn) {
-  const lockPath = join(process.cwd(), LOCK_DIR_NAME);
-
-  for (let attempt = 0; attempt <= LOCK_MAX_RETRIES; attempt++) {
-    try {
-      mkdirSync(lockPath);
-      break;
-    } catch (err) {
-      if (err.code !== 'EEXIST') throw err;
-      try {
-        const lockStat = statSync(lockPath);
-        if (Date.now() - lockStat.mtimeMs > LOCK_STALE_MS) {
-          try { rmdirSync(lockPath); } catch { }
-          continue;
-        }
-      } catch { }
-      if (attempt === LOCK_MAX_RETRIES) {
-        throw new Error('Could not acquire state lock after retries');
-      }
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, LOCK_BASE_MS * (2 ** attempt));
-    }
-  }
-
-  try {
-    return await fn();
-  } finally {
-    try { rmdirSync(lockPath); } catch { }
-  }
-}
-
 export function initState(options = {}) {
   const { force = false, projectName = '{PROJECT_NAME}', projectType = 'dotnet-nextjs' } = options;
 
@@ -402,29 +367,6 @@ export async function updateFeature(featureName, key, value) {
   saveState(state);
 }
 
-export async function updateFeatureMultiple(featureName, updates) {
-  await ensureFeature(featureName);
-  const state = loadState(); // Load AFTER ensuring feature exists
-
-  for (const [key, value] of Object.entries(updates)) {
-    const keys = key.split('.');
-    let target = state.features[featureName];
-
-    for (let i = 0; i < keys.length - 1; i++) {
-      if (!target[keys[i]]) {
-        target[keys[i]] = {};
-      }
-      target = target[keys[i]];
-    }
-
-    const finalKey = keys[keys.length - 1];
-    target[finalKey] = value;
-  }
-
-  state.features[featureName].updatedAt = new Date().toISOString();
-  saveState(state);
-}
-
 function normalizeOutputType(type) {
   if (!type.includes('-')) {
     return type;
@@ -544,91 +486,6 @@ export async function markOutput(featureName, outputType) {
   saveState(state);
 }
 
-export async function trackFileChange(featureName, filePath, action, phase) {
-  await ensureFeature(featureName);
-  const state = loadState();
-
-  if (!Array.isArray(state.features[featureName].fileChanges)) {
-    state.features[featureName].fileChanges = [];
-  }
-
-  state.features[featureName].fileChanges.push({
-    path: filePath,
-    action,
-    phase: phase || state.features[featureName].phase || 'plan',
-    timestamp: new Date().toISOString()
-  });
-
-  state.features[featureName].updatedAt = new Date().toISOString();
-  saveState(state);
-}
-
-export function getFileChanges(featureName, options = {}) {
-  const state = loadState();
-  const feature = state.features[featureName];
-
-  if (!feature) {
-    throw new Error(`Feature '${featureName}' not found.`);
-  }
-
-  const changes = feature.fileChanges || [];
-
-  if (options.groupByPhase) {
-    const grouped = {};
-    for (const change of changes) {
-      const phase = change.phase || 'unknown';
-      if (!grouped[phase]) grouped[phase] = [];
-      grouped[phase].push(change);
-    }
-    return grouped;
-  }
-
-  return changes;
-}
-
-export async function skipPhase(featureName, phase, reason = '') {
-  await ensureFeature(featureName);
-  const state = loadState();
-
-  if (!state.features[featureName].skippedPhases) {
-    state.features[featureName].skippedPhases = [];
-  }
-
-  const existing = state.features[featureName].skippedPhases.find(s => s.phase === phase);
-  if (!existing) {
-    state.features[featureName].skippedPhases.push({
-      phase,
-      reason,
-      timestamp: new Date().toISOString()
-    });
-  }
-
-  state.features[featureName].updatedAt = new Date().toISOString();
-  saveState(state);
-}
-
-export function getSkippedPhases(featureName) {
-  const state = loadState();
-  if (!state.features[featureName]) {
-    return [];
-  }
-  return state.features[featureName].skippedPhases || [];
-}
-
-export function listFeatures() {
-  const state = loadState();
-  return Object.entries(state.features);
-}
-
-export function getSummary() {
-  const state = loadState();
-  return {
-    project: state.project,
-    metadata: state.metadata,
-    featuresCount: Object.keys(state.features).length
-  };
-}
-
 export async function setApprovalGate(featureName, gate, approved, metadata = {}) {
   const state = loadState();
   const feature = await ensureFeature(featureName);
@@ -666,31 +523,6 @@ export function getApprovalGate(featureName, gate) {
   return feature.approvalGates[gate] || null;
 }
 
-export function isPendingApproval(featureName) {
-  const state = loadState();
-  const feature = state.features[featureName];
-
-  if (!feature || !feature.approvalGates) {
-    return false;
-  }
-
-  const currentPhase = feature.phase || 'plan';
-
-  const phaseGateMap = {
-    'plan': 'plan',
-    'review': 'review',
-    'uiux': 'uiux'
-  };
-
-  const relevantGate = phaseGateMap[currentPhase];
-  if (!relevantGate) {
-    return false;
-  }
-
-  const gate = feature.approvalGates[relevantGate];
-  return gate && !gate.approved;
-}
-
 export function getApprovalHistory(featureName) {
   const state = loadState();
   const feature = state.features[featureName];

package/src/core/templates/template-renderer.js

@@ -340,15 +340,6 @@ export function renderTemplateString(templateString, variables, options = {}) {
   }
 }
 
-export function getTemplatePlaceholders(templatePath) {
-  if (!existsSync(templatePath)) {
-    throw new Error(`Template file not found: ${templatePath}`);
-  }
-
-  const templateContent = readFileSync(templatePath, 'utf-8');
-  return getTemplatePlaceholdersFromString(templateContent);
-}
-
 export function getTemplatePlaceholdersFromString(templateString) {
   const placeholders = new Set();
 
@@ -380,18 +371,4 @@ export function getTemplatePlaceholdersFromString(templateString) {
   return Array.from(placeholders).sort();
 }
 
-export function validateTemplatePlaceholders(templatePath, variables, optionalPlaceholders = []) {
-  const placeholders = getTemplatePlaceholders(templatePath);
-  const providedKeys = Object.keys(variables);
-
-  const missing = placeholders.filter(
-    p => !providedKeys.includes(p) && !optionalPlaceholders.includes(p)
-  );
-
-  return {
-    valid: missing.length === 0,
-    missing
-  };
-}
-
 export { Handlebars };

package/src/dashboard/app/lib/format.js

@@ -48,13 +48,6 @@ export function bytes(n) {
   return `${(n / 1024 / 1024).toFixed(1)} MB`;
 }
 
-export function duration(seconds) {
-  if (typeof seconds !== 'number' || !Number.isFinite(seconds) || seconds <= 0) return '—';
-  const m = Math.round(seconds / 60);
-  if (m < 60) return `${m} min`;
-  return `${Math.floor(m / 60)} h ${m % 60} min`;
-}
-
 export function splitFrontmatter(text) {
   const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text || '');
   if (!m) return { meta: null, body: text || '' };

package/src/dashboard/app/lib/phases.js

@@ -36,13 +36,6 @@ export const STATUS_LABEL = {
   abandoned: 'Abandonada',
 };
 
-export const WORKTYPE_LABEL = {
-  feature: 'feature',
-  bug: 'bug',
-  chore: 'chore',
-  hotfix: 'hotfix',
-};
-
 export const LOCATION_LABEL = {
   root: 'raiz',
   worktree: 'worktree',

package/src/dashboard/scanner/activity-scanner.js

@@ -145,10 +145,6 @@ export function lastActivityByFeature(events) {
   return out;
 }
 
-export function loadProjectEvents(projectDir) {
-  return dedupeEvents(loadTelemetryAllTrees(projectDir).flatMap((t) => t.events));
-}
-
 const LIVE_LOG = join('.morph', 'logs', 'events.jsonl');
 
 function eventKey(e) {

package/src/lib/ai/ai-project-scan.js

@@ -2,7 +2,7 @@
 // `[]` é "perguntei e não achei". Worktrees ficam fora: são o checkout de outra feature.
 
 import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
-import { join, basename } from 'node:path';
+import { join } from 'node:path';
 import { WORKTREE_DIR_NAMES } from '../worktree/dirs.js';
 
 export const SCAN_IGNORED_DIRS = new Set([
@@ -246,8 +246,3 @@ export function findPackage(scan, name) {
   if (!scan || !Array.isArray(scan.packages)) return null;
   return scan.packages.find((p) => p.name === name) ?? null;
 }
-
-export function projectFileNames(scan) {
-  if (!scan) return [];
-  return scan.projectFiles.map((f) => basename(f));
-}