@polymorphism-tech/morph-spec 8.47.0 → 9.0.0

package/framework/hooks/claude-code/core/worktree-context.js

@@ -44,8 +44,8 @@ import {
   getActiveFeature,
   getFeaturePhase,
   getPendingGates,
-  getTaskStats,
 } from '../../shared/state-reader.js';
+import { sliceProgress } from '../../shared/slice-progress.js';
 import { contextResult, runStandalone } from '../../shared/hook-response.js';
 import { acquireClaim, foreignClaim, claimAge } from '../../shared/claim-registry.js';
 import { rotateActivityLogIfLarge } from '../../shared/activity-logger.js';
@@ -232,10 +232,11 @@ function buildActiveFeatureSummary(dir) {
   if (!active) return null;
 
   const phase = getFeaturePhase(active.name, dir);
-  const stats = getTaskStats(active.feature);
+  const slices = sliceProgress(join(dir, '.morph', 'features', active.name));
   const pending = getPendingGates(active.name, dir);
 
-  let text = `MORPH-SPEC: feature ativa ${active.name} (fase ${phase}) · tasks ${stats.completed}/${stats.total}`;
+  let text = `MORPH-SPEC: feature ativa ${active.name} (fase ${phase})`;
+  if (slices) text += ` · fatias ${slices.done}/${slices.total}`;
   if (pending.length) {
     text += ` · gates pendentes: ${pending.join(', ')}`;
   }
@@ -264,7 +265,7 @@ function claimBlock(dir, feature, sessionId) {
     if (!other) return '';
     return `\n⚠️  ATENÇÃO — a feature ${feature} tem claim VIVO de OUTRA sessão`
       + `\n   pid ${other.pid}${other.path ? ` · ${other.path}` : ''} · visto há ${claimAge(other)}`
-      + '\n   Duas sessões na mesma feature já custaram um recap.md inteiro e um sub-agent'
+      + '\n   Duas sessões na mesma feature já custaram um relatório de fatia inteiro e um sub-agent'
       + '\n   (o worktree sumiu debaixo dele). Confirme com a outra sessão ANTES de agir —'
       + '\n   principalmente antes de `finish`, `archive` ou `delete`.'
       + `\n   Se aquela sessão morreu: morph-spec claim ${feature} --release`;

package/framework/hooks/claude-code/statusline.py

@@ -56,28 +56,26 @@ SEP = f" {GRAY}│{R} "
 
 # ── MORPH framework constants ────────────────────────────────────────────────
 
-# Mirrors derivePhase() in src/core/state/state-manager.js — the first phase
-# (scanning backwards) whose CANONICAL artifact exists wins. An empty folder
-# is not enough.
+# Mirrors derivePhaseFrom() in framework/hooks/shared/state-reader.js — the
+# first phase (scanning backwards) whose CANONICAL artifact exists wins. An
+# empty folder is not enough; a canonical ending in '/' is any .md under it.
 PHASE_MAP = [
-    ('4-review',    'review',    'review-report.md'),
-    ('3-implement', 'implement', 'recap.md'),
-    ('2-plan',      'plan',      'spec.md'),
+    ('4-review',    'review',    'verifier.md'),
+    ('3-implement', 'implement', 'reports/'),
     ('1-design',    'uiux',      'design-system.md'),
-    ('0-proposal',  'proposal',  'proposal.md'),
+    ('2-plan',      'plan',      'plan.md'),
 ]
-PHASE_INDEX = {'proposal': 0, 'uiux': 1, 'plan': 2, 'implement': 3, 'review': 4}
+PHASE_INDEX = {'plan': 0, 'uiux': 1, 'implement': 2, 'review': 3}
 PHASE_LABELS = {
-    'proposal':  'proposal',
-    'uiux':      'UI/UX',
     'plan':      'planning',
+    'uiux':      'UI/UX',
     'implement': 'implement',
     'review':    'review',
 }
-PIPELINE_TOTAL = 5
+PIPELINE_TOTAL = 4
 
 # Gates that can block; `implement` has none. Mirrors feature.schema.json.
-GATE_PHASES = ('proposal', 'uiux', 'plan', 'review')
+GATE_PHASES = ('plan', 'uiux', 'review')
 
 
 # ── Auto-compact threshold ───────────────────────────────────────────────────
@@ -358,49 +356,65 @@ def get_worktree_label(payload, cwd):
     return None
 
 
-def _gate_implied_phase(gates):
-    """Phase implied purely by approved gates (mirrors state-manager.js)."""
+def _gate_implied_phase(gates, design_started):
+    """Phase implied purely by approved gates (mirrors state-reader.js)."""
     def approved(gate):
         return (gates.get(gate) or {}).get('approved') is True
     if approved('review'):
         return 'review'
     if approved('plan'):
-        return 'implement'
-    if approved('uiux'):
-        return 'plan'
-    return 'proposal'
+        return 'uiux' if design_started and not approved('uiux') else 'implement'
+    return 'plan'
+
+
+def _has_artifact(folder, canonical):
+    if not canonical.endswith('/'):
+        return (folder / canonical).exists()
+    try:
+        return any(p.is_file() for p in (folder / canonical).glob('*.md'))
+    except OSError:
+        return False
 
 
 def derive_phase(feature_dir, gates):
     """Phase from the filesystem, bumped by approved gates."""
-    artifact_phase = 'proposal'
+    artifact_phase = 'plan'
     for folder, phase, canonical in PHASE_MAP:
-        if (feature_dir / folder / canonical).exists():
+        if _has_artifact(feature_dir / folder, canonical):
             artifact_phase = phase
             break
-    implied = _gate_implied_phase(gates)
+    implied = _gate_implied_phase(gates, (feature_dir / '1-design').exists())
     if PHASE_INDEX[implied] > PHASE_INDEX[artifact_phase]:
         return implied
     return artifact_phase
 
 
-def count_tasks(feature_dir, feature_json):
-    """(done, total) from 2-plan/tasks.json — the declared source of truth.
+PARTIAL_MARKER = re.compile(r'^[\s#>*_]*PARCIAL\b')
 
-    `skipped` counts as resolved: it will never be worked on, and leaving it
-    out would pin the bar below 100%. Falls back to feature.json's aggregate
-    counters, which the schema marks as informational.
+
+def count_slices(feature_dir):
+    """(done, total) of the slices in 2-plan/checks.json.
+
+    Same rule as framework/hooks/shared/slice-progress.js: a slice is done when
+    3-implement/reports/{id}.md exists and its first line is not PARCIAL.
     """
     try:
-        raw = (feature_dir / '2-plan' / 'tasks.json').read_text(encoding='utf-8')
-        tasks = json.loads(raw).get('tasks')
-        if isinstance(tasks, list) and tasks:
-            done = sum(1 for task in tasks if task.get('status') in ('done', 'skipped'))
-            return done, len(tasks)
+        slices = json.loads((feature_dir / '2-plan' / 'checks.json').read_text(encoding='utf-8')).get('slices')
     except Exception:
-        pass
-    aggregate = feature_json.get('tasks') or {}
-    return safe_int(aggregate.get('completed')), safe_int(aggregate.get('total'))
+        return 0, 0
+    if not isinstance(slices, list):
+        return 0, 0
+    ids = [s.get('id') for s in slices if isinstance(s, dict) and isinstance(s.get('id'), str)]
+    done = 0
+    for slice_id in ids:
+        try:
+            text = (feature_dir / '3-implement' / 'reports' / f'{slice_id}.md').read_text(encoding='utf-8')
+        except Exception:
+            continue
+        first = next((line for line in text.splitlines() if line.strip()), '')
+        if not PARTIAL_MARKER.match(first):
+            done += 1
+    return done, len(ids)
 
 
 def get_active_features(cwd):
@@ -428,15 +442,15 @@ def get_active_features(cwd):
         feature_dir = path.parent
         gates = data.get('approvalGates') or {}
         phase = derive_phase(feature_dir, gates)
-        done, total = count_tasks(feature_dir, data)
+        done, total = count_slices(feature_dir)
         pending = None
         if phase in GATE_PHASES and (gates.get(phase) or {}).get('approved') is not True:
             pending = phase
         result.append({
             'name':        feature_dir.name,
             'phase':       phase,
-            'tasks_done':  done,
-            'tasks_total': total,
+            'slices_done':  done,
+            'slices_total': total,
             'pending':     pending,
         })
     return result
@@ -484,7 +498,7 @@ def render_morph_line(feature, hook_name, columns):
     """Line 0 — the active MORPH feature.
 
     Goes through join_to_width like the status line: a feature name plus phase,
-    task bar, gate and hook is the longest thing this script prints, and a
+    slice bar, gate and hook is the longest thing this script prints, and a
     wrapping line 0 would defeat the whole point of the single-row layout.
     """
     parts = [(0, f"{CYAN}{BOLD}► {feature['name']}{R}")]
@@ -497,12 +511,12 @@ def render_morph_line(feature, hook_name, columns):
     else:
         parts.append((1, f"{CYAN}{label} {position + 1}/{PIPELINE_TOTAL}{R}"))
 
-    if feature['tasks_total'] > 0:
-        pct = feature['tasks_done'] / feature['tasks_total'] * 100
+    if feature['slices_total'] > 0:
+        pct = feature['slices_done'] / feature['slices_total'] * 100
         parts.append((
             3,
             f"{GREEN}{progress_bar(pct, 6)} "
-            f"{feature['tasks_done']}/{feature['tasks_total']} tasks{R}"
+            f"{feature['slices_done']}/{feature['slices_total']} fatias{R}"
         ))
 
     if feature['pending']:

package/framework/hooks/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/framework/hooks/shared/activity-logger.js

@@ -18,7 +18,7 @@
  *
  * Exported names/signatures are unchanged from the previous doc-based
  * implementation on purpose — hooks outside this file's ownership
- * (gate-guard.js, tasks-json-guard.js, enforce-phase-writes.js,
+ * (gate-guard.js, enforce-phase-writes.js,
  * loop-detect.js, protect-spec-files.js, validate-completion.js) call
  * logHookActivity/logEvent and must keep working untouched. Only the
  * on-disk format changed.

package/framework/hooks/shared/build-check.js

@@ -14,7 +14,7 @@ import { join } from 'path';
 const DOTNET_BUILD_CMD = 'dotnet build --no-restore --nologo -v q';
 const TSC_BUILD_CMD = 'npx tsc --noEmit';
 
-function isDotnetStack(s) {
+export function isDotnetStack(s) {
   return s.includes('dotnet') || s.includes('aspnet');
 }
 
@@ -70,16 +70,20 @@ export function getBuildCommand(stack, hasTsConfig = false) {
  * `getBuildCommand()`'s existing single-stack behavior.
  *
  * @param {string} stack
- * @param {{ cwd: string, frontendPath?: string, backendPath?: string }} opts
+ * `backendTarget` names the solution/project to build (relative to the backend
+ * directory) when that directory holds none itself.
+ *
+ * @param {{ cwd: string, frontendPath?: string, backendPath?: string, backendTarget?: string }} opts
  * @returns {Array<{ command: string, cwd: string }>}
  */
-export function getBuildSteps(stack, { cwd, frontendPath, backendPath } = {}) {
+export function getBuildSteps(stack, { cwd, frontendPath, backendPath, backendTarget } = {}) {
   if (!stack || !cwd) return [];
   const s = stack.toLowerCase();
   const steps = [];
 
   if (isDotnetStack(s)) {
-    steps.push({ command: DOTNET_BUILD_CMD, cwd: backendPath ? join(cwd, backendPath) : cwd });
+    const command = backendTarget ? DOTNET_BUILD_CMD.replace(/^dotnet build/, `dotnet build "${backendTarget}"`) : DOTNET_BUILD_CMD;
+    steps.push({ command, cwd: backendPath ? join(cwd, backendPath) : cwd });
   }
 
   if (isFrontendStack(s)) {
@@ -129,11 +133,11 @@ export function parseBuildResult(exitCode, output) {
  * @param {string} cwd - Project root directory
  * @param {string} stack - Project stack string
  * @param {number} [timeout=30000] - Timeout in ms
- * @param {{ frontendPath?: string, backendPath?: string }} [paths] - Monorepo sub-paths, from config.json → project
+ * @param {{ frontendPath?: string, backendPath?: string, backendTarget?: string }} [paths] - Monorepo sub-paths, from config.json → project
  * @returns {{ status: 'pass'|'fail'|'skip', output: string }}
  */
 export function runBuildCheck(cwd, stack, timeout = 30000, paths = {}) {
-  const steps = getBuildSteps(stack, { cwd, frontendPath: paths.frontendPath, backendPath: paths.backendPath });
+  const steps = getBuildSteps(stack, { cwd, frontendPath: paths.frontendPath, backendPath: paths.backendPath, backendTarget: paths.backendTarget });
   if (steps.length === 0) return { status: 'skip', output: '' };
 
   const failures = [];

package/framework/hooks/shared/command-tokens.js

@@ -117,3 +117,172 @@ export function exitCodeMasked(command) {
   const last = segments[segments.length - 1] || '';
   return (segments.length > 1 && REPORTER.test(last)) || /\|\|/.test(last.replace(/"[^"]*"|'[^']*'/g, ''));
 }
+
+const WRITE_REDIRECT = /^(?:[1&])?>>?\|?/;
+
+function quotedTokens(text) {
+  const tokens = [];
+  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    tokens.push({ text: m[1] ?? m[2] ?? m[3], quoted: m[3] === undefined, single: m[2] !== undefined });
+  }
+  return tokens;
+}
+
+const CHAIN = /^(?:&&|\|\||\||\|&)$/;
+const ASSIGNMENT = /^([A-Za-z_]\w*)=(.*)$/;
+const REDIRECT = /^(?:\d|&)?[<>]/;
+const SCRIPT_RUNNER = /^(?:python[\d.]*|py|node|bun|deno)$/;
+
+function simpleCommands(head) {
+  const commands = [];
+  for (const segment of topLevelSegments(head).segments) {
+    let current = [];
+    for (const token of quotedTokens(segment)) {
+      if (!token.quoted && CHAIN.test(token.text)) { commands.push(current); current = []; } else current.push(token);
+    }
+    commands.push(current);
+  }
+  return commands.filter((c) => c.length > 0);
+}
+
+function positionals(args, takesValue) {
+  const out = [];
+  const values = [];
+  for (let i = 0; i < args.length; i++) {
+    const { text, quoted } = args[i];
+    if (!quoted && REDIRECT.test(text)) { if (/[<>]$/.test(text)) i++; continue; }
+    if (!quoted && text.startsWith('-') && text !== '-') {
+      if (takesValue(text) && i + 1 < args.length) values.push(args[++i].text);
+      continue;
+    }
+    out.push(text);
+  }
+  return { files: out, values };
+}
+
+function sedTargets(args) {
+  const inPlace = args.some(({ text, quoted }) => !quoted && (/^-[A-Za-z]*i/.test(text) || text.startsWith('--in-place')));
+  if (!inPlace) return [];
+  const { files, values } = positionals(args, (o) => /^-[A-Za-z]*[ef]$/.test(o) || o === '--expression' || o === '--file');
+  return values.length > 0 ? files : files.slice(1);
+}
+
+function perlTargets(args) {
+  if (!args.some(({ text, quoted }) => !quoted && /^-[A-Za-z]*i/.test(text))) return [];
+  const { files, values } = positionals(args, (o) => /^-[A-Za-z.]*[eE]$/.test(o));
+  return values.length > 0 ? files : files.slice(1);
+}
+
+function copyTargets(args) {
+  if (args.some(({ text }) => text === '-t' || text.startsWith('--target-directory'))) return [];
+  const { files } = positionals(args, () => false);
+  if (files.length < 2) return [];
+  const dest = files[files.length - 1];
+  if (!dest.endsWith('/')) return [dest];
+  return files.slice(0, -1).map((src) => dest + src.replace(/^.*\//, ''));
+}
+
+const PY_OPEN_WRITE = /\bopen\(\s*([^,()]+?)\s*,\s*(?:mode\s*=\s*)?(['"])([^'"]*)\2/g;
+const JS_WRITE = /\b(?:writeFileSync|writeFile|appendFileSync|appendFile)\(\s*([^,()]+?)\s*,/g;
+const PY_PATH_WRITE = /\.write_(?:text|bytes)\(/;
+const STRING_LITERAL = /(['"`])((?:(?!\1)[^\\\n]|\\.)*)\1/g;
+const PATH_LITERAL = /^[\w@./-]*[\w-]\.[A-Za-z]{1,5}$/;
+
+function literalOf(expr) {
+  const m = /^(['"`])([^'"`]*)\1$/.exec(expr.trim());
+  return m ? m[2] : null;
+}
+
+// A write call with a computed path (`open(p, "w")`) counts every path-shaped literal in the script.
+function scriptWrites(script) {
+  const literals = [];
+  let computed = PY_PATH_WRITE.test(script);
+  for (const m of script.matchAll(PY_OPEN_WRITE)) {
+    if (!/[wax+]/.test(m[3])) continue;
+    const lit = literalOf(m[1]);
+    if (lit === null) computed = true; else literals.push(lit);
+  }
+  for (const m of script.matchAll(JS_WRITE)) {
+    const lit = literalOf(m[1]);
+    if (lit === null) computed = true; else literals.push(lit);
+  }
+  if (!computed) return literals;
+  const mentioned = [...script.matchAll(STRING_LITERAL)].map((m) => m[2]).filter((s) => PATH_LITERAL.test(s));
+  return [...new Set([...literals, ...mentioned])];
+}
+
+function runnerScript(args, body) {
+  for (let i = 0; i < args.length; i++) {
+    if (['-c', '-e', '-p', '--eval', '--print'].includes(args[i].text) && !args[i].quoted) return args[i + 1]?.text ?? null;
+  }
+  const { files } = positionals(args, () => false);
+  return (files.length === 0 || files[0] === '-') ? body : null;
+}
+
+function heredocBody(lines, at) {
+  if (at < 0) return null;
+  const delim = /<<-?\s*(['"]?)([\w.-]+)\1/.exec(lines[at])?.[2];
+  if (!delim) return null;
+  const end = lines.findIndex((line, i) => i > at && line.trim() === delim);
+  return lines.slice(at + 1, end < 0 ? undefined : end).join('\n');
+}
+
+function commandWriteTargets(head, body) {
+  const vars = new Map();
+  const expand = ({ text, single }) => (single ? text : text.replace(/\$\{?([A-Za-z_]\w*)\}?/g, (all, name) => vars.get(name) ?? all));
+  const targets = [];
+  for (const tokens of simpleCommands(head)) {
+    let i = 0;
+    for (; i < tokens.length && !tokens[i].quoted && ASSIGNMENT.test(tokens[i].text); i++) {
+      const [, name, value] = ASSIGNMENT.exec(tokens[i].text);
+      vars.set(name, value);
+    }
+    if (i >= tokens.length) continue;
+    const word = tokens[i].text.replace(/^.*[\\/]/, '').replace(/\.exe$/i, '');
+    const args = tokens.slice(i + 1).map((t) => ({ ...t, text: expand(t) }));
+    if (word === 'sed') targets.push(...sedTargets(args));
+    else if (word === 'perl') targets.push(...perlTargets(args));
+    else if (word === 'cp' || word === 'mv') targets.push(...copyTargets(args));
+    else if (SCRIPT_RUNNER.test(word)) {
+      const script = runnerScript(args, body);
+      if (script) targets.push(...scriptWrites(script));
+    }
+  }
+  return targets;
+}
+
+/**
+ * Files a command writes: stdout redirection (`>`, `>>`, `1>`, `&>`), `tee`, `sed -i`,
+ * `perl -i`, the `cp`/`mv` destination, and a python/node `-c`/`-e`/heredoc script's writes.
+ * The redirect scan stops at the line that opens a heredoc: the body is data, and an
+ * apostrophe in it would derail the quote-aware split. Quoted operators are text.
+ * @param {string} command
+ * @returns {string[]}
+ */
+export function writeTargets(command) {
+  const lines = String(command || '').split('\n');
+  const heredocAt = lines.findIndex((line) => line.includes('<<'));
+  const head = (heredocAt >= 0 ? lines.slice(0, heredocAt + 1) : lines).join('\n');
+  const tokens = quotedTokens(head);
+
+  const targets = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const { text, quoted } = tokens[i];
+    if (quoted) continue;
+    const op = text.match(WRITE_REDIRECT);
+    if (op) {
+      const rest = text.slice(op[0].length);
+      const target = rest || tokens[i + 1]?.text;
+      if (target && !target.startsWith('&')) targets.push(target);
+      continue;
+    }
+    if (text.replace(/^.*[\/]/, '') === 'tee') {
+      for (let j = i + 1; j < tokens.length && !/^[;&|]/.test(tokens[j].text); j++) {
+        if (!tokens[j].text.startsWith('-')) targets.push(tokens[j].text);
+      }
+    }
+  }
+  return [...new Set([...targets, ...commandWriteTargets(head, heredocBody(lines, heredocAt))])];
+}

package/framework/hooks/shared/comment-rules.js

@@ -2,7 +2,7 @@
  * The comment shapes the `architecture-code-comments` standard forbids in
  * every case, judged only on the comments an edit ADDED. Whether a short
  * comment restates the code is not decidable here; that stays with the
- * Gate 3 evaluator and the `code-budget` density.
+ * Gate 3 reviewer and the `code-budget` density.
  *
  * @module comment-rules
  */

package/framework/hooks/shared/comment-scanner.js

@@ -10,42 +10,29 @@
 
 import { stripComments } from './comment-stripper.js';
 
-/** Vocabulário de processo do morph-spec, fora o id de task (abaixo). */
+/**
+ * Id de cenário (`C{n}`) e de fatia (`F{n}`) do plano. A mesma grafia também é
+ * tecla de função, métrica, célula de planilha ou o modelo C-quatro: esses
+ * vizinhos não contam (casos em comment-scanner.test.js).
+ */
+const PLAN_ID = new RegExp(String.raw`(?<!\b(?:key|tecla|press|aperte|cell|c[eé]lula|column|coluna)\s+)(?<![\w.#$/-])[CF]\d{1,2}(?![\w.(-]|\s+(?:key|tecla|score|model|modelo|diagram|diagrama)\b)`, 'i');
+
 const PROCESS_CITATION = [
   /\bUC[-\s]?\d+/,
   /\bADR[-\s]?\d+/,
   /\bFR[-\s]?\d+/,
   /\bgate\s?[1-3]\b/i,
-  /\bspec\.md\b/i,
+  /\bplan\.md\b/i,
+  /\bchecks\.json\b/i,
   /\bmockups?\b/i,
 ];
 
-/**
- * `T{n}` também é nome de parâmetro genérico. Não casa depois de `template`/
- * `typename`/`generic`, nem colado a letra ou dígito (a hora ISO `24T10`).
- */
-const TASK_ID = /(?<!\b(?:[Tt]emplate|[Tt]ypename|[Gg]eneric)\s+)(?<![\w"])T\d{1,3}\b(?!")/;
-
-/** Lista de tipos `<…>` e `{…}` (`Func<T1, T2>`, `cref="Func{T1,T2}"`, XML doc), de dentro para fora. */
-const TYPE_LIST = /<[^<>]*>|\{[^{}]*\}/g;
-
-function withoutTypeLists(text) {
-  let previous;
-  let current = text;
-  do {
-    previous = current;
-    current = current.replace(TYPE_LIST, ' ');
-  } while (current !== previous);
-  return current;
-}
-
 /**
  * @param {string} commentText
  * @returns {boolean} o comentário usa o vocabulário de processo acima
  */
 export function citesProcess(commentText) {
-  return PROCESS_CITATION.some((re) => re.test(commentText))
-    || TASK_ID.test(withoutTypeLists(commentText));
+  return PROCESS_CITATION.some((re) => re.test(commentText)) || PLAN_ID.test(commentText);
 }
 
 /**

package/framework/hooks/shared/comment-stripper.js

@@ -10,7 +10,7 @@
  *   - `registry-audit.js` — precisa ler **JSONC**, a forma que o exemplar
  *     canônico `model-registry.v2.json` usa e que o leitor C# do kit aceita de
  *     propósito (`JsonCommentHandling.Skip`, `AllowTrailingCommas`);
- *   - `dotnet-test-introspection.js` — lê o `global.json` por `jsoncToJson`;
+ *   - `mutation/dotnet-introspection.js` — lê o `global.json` por `jsoncToJson`;
  *   - `comment-scanner.js` (ao lado; lido pelo `code-budget` e pelo hook
  *     `comment-guard`) — acha as linhas de
  *     comentário de `.cs`/`.ts`/`.js`, e é o único que liga a opção `js`.