@polymorphism-tech/morph-spec 8.46.0 → 9.0.0

package/framework/hooks/claude-code/core/protect-spec-files.js

@@ -6,19 +6,9 @@
  * Event: PreToolUse | Matcher: Write|Edit
  *
  * Blocks Write/Edit to spec artifacts after their approval gate has passed:
- *   - 2-plan/spec.md, etc. → blocked if 'plan' gate approved
- *   - 1-design/design-system.md, etc. → blocked if 'uiux' gate approved
- *
- * Semantic exception for files in MUTABLE_SPEC_FIELDS (e.g. tasks.json):
- * the plan contract is frozen, but per-task progress fields (status, outputs,
- * notes) may still change during the implement phase. For those files BOTH a
- * full Write and a targeted Edit are allowed — but only when the semantic diff
- * touches solely the mutable fields. The Edit is simulated (old_string →
- * new_string applied to the current file) and diffed exactly like a Write, so a
- * one-field status flip via Edit is permitted while any change to the frozen
- * plan contract (titles, dependencies, doneCriteria, the task set) is blocked.
- * This is the sanctioned progress path — the agent never has to rewrite the
- * whole file nor reach for a Node script to record task status.
+ *   - 2-plan/plan.md → after 'plan', only an append under `## Errata`
+ *   - 2-plan/checks.json → never by hand: `morph-spec plan-check` is its only writer
+ *   - 1-design/design-system.md, etc. → after 'uiux', only an errata append
  *
  * A gate freezes the APPROVED ARTIFACT, so a protected file that does not yet
  * exist on disk is a CREATION and passes — the criterion is the file's
@@ -33,152 +23,14 @@ import {
   isFeaturePath,
   extractFeatureName,
   getBasename,
-  PROTECTED_SPEC_FILES,
-  MUTABLE_SPEC_FIELDS
+  PROTECTED_SPEC_FILES
 } from '../../shared/phase-utils.js';
 import { blockResult, runStandalone } from '../../shared/hook-response.js';
 import { logHookActivity } from '../../shared/activity-logger.js';
 import { getFilePath, getToolName, resolveMorphRoot, resolveTargetPath } from '../../shared/payload-utils.js';
-import { validateTasksDoc, outputsDivergenceViolations } from '../../shared/tasks-validator.js';
-
-/**
- * Compare two tasks.json structures and return the list of plan-contract
- * violations — changes that touch anything other than the mutable fields.
- *
- * Frozen-by-default, not an enumerated frozen list: the loop below walks the
- * UNION of old/new task keys and flags any key not in `mutableFields`. A new
- * plan-contract field (e.g. `agent`/`standards`, stamped by morph-plan — R2
- * token-cut) needs NO entry added here to become protected; it is frozen the
- * moment it exists on a task, simply by never being added to
- * MUTABLE_SPEC_FIELDS (output-schema.js → `npm run generate` →
- * framework/hooks/shared/phase-utils.js). Only fields that must stay
- * EDITABLE post-Gate-2 (today: status, outputs, notes) belong in that list.
- *
- * @param {object} oldDoc - parsed previous file content
- * @param {object} newDoc - parsed proposed file content
- * @param {string[]} mutableFields - field names allowed to change
- * @returns {string[]} human-readable violation messages (empty = OK)
- */
-function diffPlanContract(oldDoc, newDoc, mutableFields) {
-  const violations = [];
-  const mutable = new Set(mutableFields);
-
-  // Backfilling a previously-absent `version` (undefined → any value) is a
-  // benign schema-tooling update, not a plan-contract change — it's what
-  // lets legacy tasks.json adopt the field so `morph-spec dag` can analyze
-  // it without a lenient fallback. An actual change between two SET
-  // versions is still a real contract change and stays blocked.
-  const versionBackfilled = oldDoc.version === undefined && newDoc.version !== undefined;
-  if (!versionBackfilled && oldDoc.version !== newDoc.version) {
-    violations.push(`'version' changed (${oldDoc.version} → ${newDoc.version})`);
-  }
-  if (oldDoc.feature !== newDoc.feature) {
-    violations.push(`'feature' changed (${oldDoc.feature} → ${newDoc.feature})`);
-  }
-
-  const oldTasks = Array.isArray(oldDoc.tasks) ? oldDoc.tasks : [];
-  const newTasks = Array.isArray(newDoc.tasks) ? newDoc.tasks : [];
-
-  if (oldTasks.length !== newTasks.length) {
-    violations.push(`task count changed (${oldTasks.length} → ${newTasks.length}) — tasks cannot be added or removed`);
-  }
-
-  const oldById = new Map(oldTasks.map(t => [t.id, t]));
-  const newById = new Map(newTasks.map(t => [t.id, t]));
-
-  // A task present before must still exist (no removals / id renames).
-  for (const id of oldById.keys()) {
-    if (!newById.has(id)) violations.push(`task '${id}' was removed`);
-  }
-  for (const id of newById.keys()) {
-    if (!oldById.has(id)) violations.push(`task '${id}' was added`);
-  }
-
-  // For tasks present on both sides, only mutable fields may differ.
-  for (const [id, newTask] of newById) {
-    const oldTask = oldById.get(id);
-    if (!oldTask) continue;
-    const keys = new Set([...Object.keys(oldTask), ...Object.keys(newTask)]);
-    for (const key of keys) {
-      if (mutable.has(key)) continue;
-      if (JSON.stringify(oldTask[key]) !== JSON.stringify(newTask[key])) {
-        violations.push(`task '${id}': immutable field '${key}' changed`);
-      }
-    }
-  }
-
-  return violations;
-}
-
-/**
- * O heading que abre o bloco de errata, no fim de um arquivo congelado.
- *
- * Congelar o CONTRATO não é a mesma coisa que congelar um ERRO DE FATO. Caso
- * real: a spec afirmava, entre parênteses, que certos registros também eram
- * escritos por humanos; o código mostrava que os três escritores eram do
- * próprio motor. A afirmação era falsa sobre o código, não uma mudança de
- * escopo — mas a trava cega não distingue as duas coisas, então a mentira
- * ficava na spec e a correção morava em outro arquivo. Quem abrisse a spec
- * primeiro lia a versão errada.
- *
- * A errata resolve isso SEM abrir o contrato: o corpo continua byte-idêntico e
- * só se acrescenta texto ao fim, num bloco identificado. Escopo negociado ⇒
- * revogar o gate. Fato errado sobre o código ⇒ errata.
- */
-const ERRATA_HEADING = '## Errata';
-
-/** Índice onde começa o bloco de errata (-1 se não há). Só reconhece o heading em início de linha. */
-function errataIndex(text) {
-  if (text.startsWith(ERRATA_HEADING)) return 0;
-  const at = text.indexOf(`\n${ERRATA_HEADING}`);
-  return at === -1 ? -1 : at + 1;
-}
-
-/**
- * Corpo congelado = tudo ANTES do bloco de errata (ou o texto inteiro, se não
- * há bloco), sem o branco final.
- *
- * O `trimEnd` não é frouxidão: separar o bloco por uma linha em branco é o
- * formato markdown natural, e sem isso a primeira errata de todas seria
- * recusada por "mudou o corpo" — quando o que mudou foi um `\n` de formatação.
- * A garantia que importa (nenhum caractere SIGNIFICATIVO do texto aprovado
- * muda) fica intacta, porque só espaço em branco terminal é ignorado.
- */
-function frozenBody(text) {
-  const at = errataIndex(text);
-  return (at === -1 ? text : text.slice(0, at)).trimEnd();
-}
+import { ERRATA_HEADING, errataViolation } from '../../shared/errata.js';
 
-/**
- * A mudança proposta é uma errata legítima?
- *
- * Três condições, todas necessárias — frouxo em qualquer uma delas e a trava
- * cega vira uma trava que uma edição criativa atravessa:
- *   1. o corpo congelado permanece BYTE-IDÊNTICO;
- *   2. o resultado de fato tem um bloco `## Errata` (senão é edição do corpo);
- *   3. a errata só CRESCE — o que já estava escrito nela não é reescrito.
- *
- * A (3) existe porque uma errata reescrita perde a serventia: o valor dela é
- * ser trilha acumulada, não um segundo lugar editável.
- *
- * @returns {{ok: true} | {ok: false, why: string}}
- */
-function errataViolation(original, proposed) {
-  if (frozenBody(proposed) !== frozenBody(original)) {
-    return { ok: false, why: 'o corpo da spec mudou — errata só ACRESCENTA ao fim, nunca altera o texto aprovado' };
-  }
-  if (errataIndex(proposed) === -1) {
-    return { ok: false, why: `o conteúdo novo precisa estar sob um bloco \`${ERRATA_HEADING}\` no fim do arquivo` };
-  }
-  const oldAt = errataIndex(original);
-  if (oldAt !== -1) {
-    const oldErrata = original.slice(oldAt);
-    if (!proposed.slice(errataIndex(proposed)).startsWith(oldErrata)) {
-      return { ok: false, why: 'a errata existente foi reescrita — ela é append-only, entradas anteriores não se apagam' };
-    }
-  }
-  return { ok: true };
-}
+const CHECKS_FILE = 'checks.json';
 
 /**
  * Texto proposto para um arquivo totalmente travado, a partir de Write ou Edit.
@@ -221,7 +73,7 @@ export async function run(payload) {
     // The gate that locks this file is recorded in the feature.json of the tree
     // that OWNS it. Asking the session's tree instead made this guard go DARK in
     // a secondary worktree: the root had no approved gate, so a post-Gate-2
-    // spec.md rewrite sailed through. Same defect as enforce-phase-writes,
+    // plan.md rewrite sailed through. Same defect as enforce-phase-writes,
     // opposite direction — there it over-blocked, here it under-protected.
     const root = resolveMorphRoot(filePath, process.cwd());
     if (!stateExists(root)) return null;
@@ -235,6 +87,19 @@ export async function run(payload) {
     // Not a protected file
     if (!requiredGate) return null;
 
+    // Only plan-check writes checks.json; a hand-written one would carry
+    // checks the parser never judged. Decided before the creation carve-out:
+    // chore/hotfix are born with the plan gate stamped.
+    if (filename === CHECKS_FILE) {
+      logHookActivity('protect-spec-files', 'PreToolUse', 'blocked');
+      return blockResult(
+        `MORPH-SPEC: '${CHECKS_FILE}' is generated — never written by hand.\n` +
+        `Edit 2-plan/plan.md and run \`morph-spec plan-check ${featureName}\`: it parses the plan and writes ${CHECKS_FILE}.\n` +
+        `After the plan gate the plan is frozen: a wrong fact goes in \`${ERRATA_HEADING}\` (append-only, ${CHECKS_FILE} unchanged);\n` +
+        `a real scope change needs \`morph-spec unapprove ${featureName} plan\`, then plan-check and the gate again.`
+      );
+    }
+
     // Gate not yet approved — allow editing
     if (!isGateApproved(featureName, requiredGate, root)) {
       logHookActivity('protect-spec-files', 'PreToolUse', 'ok');
@@ -247,9 +112,9 @@ export async function run(payload) {
     // Um gate aprovado congela o ARTEFATO APROVADO. Se o arquivo ainda não
     // existe no disco, não há artefato aprovado a proteger: isto é a CRIAÇÃO
     // inicial, não a edição de uma spec fechada. O caso é real e não é raro —
-    // `chore`/`hotfix` nascem com `proposal`+`plan` carimbados `policy:{tipo}`
+    // `chore`/`hotfix` nascem com `plan` carimbado `policy:{tipo}`
     // (create.js → work-types.js skippedGates), então o primeiro `Write` de
-    // `2-plan/spec.md` já chega aqui com o gate "aprovado" sem que humano
+    // `2-plan/plan.md` já chega aqui com o gate "aprovado" sem que humano
     // nenhum tenha aprovado coisa alguma — e era barrado com uma mensagem
     // mandando revogar o gate de um arquivo inexistente.
     //
@@ -259,93 +124,16 @@ export async function run(payload) {
     // sobre o disco, a janela fecha sozinha no instante em que o arquivo
     // existe — os contra-canários de test/hooks/protect-spec-files.test.js
     // pinam exatamente isso.
-    //
-    // A decisão é explícita e vale para as DUAS metades do hook. Antes, o ramo
-    // de campos mutáveis (tasks.json) já deixava a primeira criação passar, mas
-    // por acidente — o ENOENT caía no catch fail-open da leitura — enquanto o
-    // ramo travado bloqueava. Duas metades respondendo à mesma pergunta em
-    // direções opostas; agora respondem aqui, uma vez só. O `result` distinto
-    // no log é o que torna essa unificação observável.
+    // O `result` distinto no log é o que torna a criação observável.
     if (!existsSync(absPath)) {
       logHookActivity('protect-spec-files', 'PreToolUse', 'ok:absent');
       return null;
     }
 
-    const mutableFields = MUTABLE_SPEC_FIELDS[filename];
-
-    // Files with mutable progress fields (e.g. tasks.json): allow a full Write
-    // that touches only those fields. Anything else stays blocked.
-    if (mutableFields) {
-      const toolName = getToolName(payload);
-
-      // Build the proposed document from either a full Write or a targeted Edit,
-      // then semantic-diff it against the current file on disk. Any failure to
-      // read / parse / apply → fail-open (pass), never a false block. O arquivo
-      // EXISTE aqui (a inexistência já foi decidida acima), então este catch
-      // volta a significar só o que dizia originalmente: não deu para diffar.
-      let oldDoc, newDoc;
-      try {
-        const original = readFileSync(absPath, 'utf-8');
-        oldDoc = JSON.parse(original);
-
-        if (toolName === 'Edit') {
-          // Simulate the edit: apply old_string → new_string to the current file.
-          const oldStr = payload?.tool_input?.old_string;
-          const newStr = payload?.tool_input?.new_string;
-          if (typeof oldStr !== 'string' || typeof newStr !== 'string') throw new Error('no edit strings');
-          const edited = payload?.tool_input?.replace_all
-            ? original.split(oldStr).join(newStr)
-            : original.replace(oldStr, newStr);
-          newDoc = JSON.parse(edited);
-        } else {
-          const newContent = payload?.tool_input?.content;
-          if (typeof newContent !== 'string') throw new Error('no content');
-          newDoc = JSON.parse(newContent);
-        }
-      } catch {
-        logHookActivity('protect-spec-files', 'PreToolUse', 'ok');
-        return null;
-      }
-
-      const violations = diffPlanContract(oldDoc, newDoc, mutableFields);
-
-      // Schema check on the proposed doc: even mutable-field writes must keep a
-      // valid status enum (a leaf agent writing status:"completed" was the
-      // production failure this closes). Only NEWLY introduced schema errors
-      // block — a pre-existing violation must not deadlock progress writes.
-      const preExisting = new Set(validateTasksDoc(oldDoc).errors);
-      violations.push(...validateTasksDoc(newDoc).errors.filter(e => !preExisting.has(e)));
-
-      // Planned-vs-real outputs diff: changing `outputs` is allowed, but the
-      // divergence must be explained in `notes` in the same edit.
-      violations.push(...outputsDivergenceViolations(oldDoc, newDoc));
-
-      if (violations.length === 0) {
-        // Only mutable progress fields changed — a legitimate implement-phase
-        // update via Write OR Edit.
-        logHookActivity('protect-spec-files', 'PreToolUse', 'ok');
-        return null;
-      }
-
-      logHookActivity('protect-spec-files', 'PreToolUse', 'blocked');
-      return blockResult(
-        `MORPH-SPEC: '${filename}' write rejected — the '${requiredGate}' gate has been approved.\n` +
-        `This ${toolName} violates the plan contract or the tasks schema:\n` +
-        violations.map(v => `  • ${v}`).join('\n') + '\n\n' +
-        `During the implement phase only these fields may change: ${mutableFields.join(', ')}\n` +
-        `(status must stay in the schema enum, and outputs that diverge from the plan\n` +
-        `require an explanatory 'notes' in the same edit).\n` +
-        `To change the plan itself, ask the user to revoke the '${requiredGate}' gate,\n` +
-        `then re-present it for approval.`
-      );
-    }
-
-    // ── Arquivo totalmente travado (spec.md, design) ────────────
+    // ── Arquivo totalmente travado (plan.md, design) ────────────
     // O corpo continua congelado. A ÚNICA passagem é a errata append-only:
     // corpo byte-idêntico + texto novo sob `## Errata` no fim. Qualquer falha
-    // de leitura/reconstrução cai no bloqueio (o conservador aqui é BLOQUEAR —
-    // ao contrário do ramo do tasks.json, onde não conseguir diffar significa
-    // não ter como provar violação; aqui a regra base é "não se edita").
+    // de leitura/reconstrução cai no bloqueio: a regra base é "não se edita".
     //
     // O arquivo EXISTE neste ponto — a inexistência foi decidida lá em cima, e
     // é a única coisa que este catch NÃO significa mais. ENOENT tratado como
@@ -368,13 +156,13 @@ export async function run(payload) {
     logHookActivity('protect-spec-files', 'PreToolUse', 'blocked');
     return blockResult(
       `MORPH-SPEC: '${filename}' is locked — the '${requiredGate}' gate has been approved.\n` +
-      `Editing approved specs breaks the spec contract.\n\n` +
+      `Editing an approved artifact breaks its contract.\n\n` +
       (errataCheck ? `Esta mudança não é uma errata válida: ${errataCheck.why}.\n\n` : '') +
-      `Corrigir um FATO ERRADO sobre o código (a spec afirma algo que o código\n` +
-      `desmente) não exige revogar o gate: acrescente um bloco \`${ERRATA_HEADING}\` no\n` +
+      `Corrigir um FATO ERRADO sobre o código (o texto aprovado afirma algo que o\n` +
+      `código desmente) não exige revogar o gate: acrescente sob \`${ERRATA_HEADING}\` no\n` +
       `FIM do arquivo, deixando o corpo intacto — é append-only e fica na trilha.\n\n` +
-      `Mudar o ESCOPO acordado é outra coisa: peça ao usuário para revogar o gate\n` +
-      `'${requiredGate}', edite, e re-apresente o gate para aprovação.`
+      `Mudar o ESCOPO acordado é outra coisa: \`morph-spec unapprove ${featureName} ${requiredGate}\`,\n` +
+      `edite, rode plan-check quando for o plan.md, e re-apresente o gate para aprovação.`
     );
   } catch {
     // Fail-open

package/framework/hooks/claude-code/core/state-sync.js

@@ -6,15 +6,18 @@
  * the agent to think about state. Fail-open: any error returns {} silently.
  *
  * Triggers:
- *  - Write/Edit of .morph/features/{feature}/0-proposal/proposal.md  → register feature
+ *  - Write/Edit of .morph/features/{feature}/2-plan/plan.md          → register feature
  *  - Write/Edit of .morph/features/{feature}/{phase}/{output}        → mark output created
  *  - AskUserQuestion answered with option starting "aprovado"        → advance gate
  */
 
+import { existsSync } from 'fs';
+import { join } from 'path';
 import { loadState, stateExists } from '../../shared/state-reader.js';
 import { persistFeature, setGateApproved, createDefaultFeature, readFeatureFile } from '../../shared/state-writer.js';
 import { resolveMorphRoot } from '../../shared/payload-utils.js';
 import { contextResult, runStandalone } from '../../shared/hook-response.js';
+import { gateFromQuestion } from '../../shared/gate-question.js';
 import {
   locateFeatureForQuestion,
   allWorkTrees,
@@ -23,7 +26,6 @@ import {
 } from '../../shared/feature-locator.js';
 
 const PHASE_FOLDERS = {
-  '0-proposal': 'proposal',
   '1-design': 'design',
   '1-ui': 'uiux', // legacy alias — still recognized during folder transition
   '2-plan': 'plan',
@@ -92,24 +94,10 @@ function isApprovalAnswer(answer) {
   );
 }
 
-function gateFromQuestion(question) {
-  if (typeof question !== 'string') return null;
-  // Checked BEFORE the generic patterns below: the pinned uiux template is
-  // "Gate uiux — Design de {feature} aprovado?" (morph-uiux/SKILL.md) — it
-  // must never fall through to 'plan' via a stray "plan"/"plano" substring in
-  // the feature name. `/gate\s+uiux/i` alone is unambiguous either way.
-  if (/gate\s+uiux/i.test(question)) return 'uiux';
-  const lower = question.toLowerCase();
-  if (lower.includes('gate 1') || lower.includes('proposta')) return 'proposal';
-  if (lower.includes('gate 2') || lower.includes('plano') || lower.includes('plan')) return 'plan';
-  if (lower.includes('gate 3') || lower.includes('review')) return 'review';
-  return null;
-}
-
 // Gate monotonicity — mirror of src/core/state/gate-order.js (hooks are
 // installed standalone and cannot import from src/). Keep in sync:
-// proposal → plan → review; uiux requires proposal.
-const GATE_PREREQ = { proposal: [], uiux: ['proposal'], plan: ['proposal'], review: ['plan'] };
+// plan first; uiux and review require plan.
+const GATE_PREREQ = { plan: [], uiux: ['plan'], review: ['plan'] };
 function unmetGatePrereqs(gate, gates) {
   const isApproved = (g) => gates?.[g]?.approved === true || gates?.[g] === true;
   return (GATE_PREREQ[gate] || []).filter((p) => !isApproved(p));
@@ -216,7 +204,17 @@ function handleAskUserQuestion(input, sessionRoot) {
     // (`morph-spec approve`) produce one consistent shape
     // ({ approved, timestamp, approvedBy }) in the authoritative feature.json —
     // and a manual approval stays distinguishable from a policy auto-approval.
-    setGateApproved(featureName, gate, { approvedBy: 'manual' }, root);
+    // Same contract as `approve`'s --self-assessed: a human may ship Gate 3 without the
+    // independent review reports, but the degradation is stamped, never silent.
+    const selfAssessed = gate === 'review' && feature?.workType !== 'hotfix'
+      && ['verifier.md', 'reviewer.md'].some((f) => !existsSync(join(root, '.morph', 'features', featureName, '4-review', f)));
+    if (selfAssessed) {
+      warnings.push(
+        `⚠️ [morph-spec] Gate 3 de "${featureName}" aprovado SEM os relatórios de review independentes (verifier.md, reviewer.md) — ` +
+        `registrado como selfAssessed (aparece no list/fleet).`
+      );
+    }
+    setGateApproved(featureName, gate, { approvedBy: 'manual', ...(selfAssessed ? { selfAssessed: true } : {}) }, root);
   }
   return warnings.length ? warnings.join('\n') : null;
 }

package/framework/hooks/claude-code/core/telemetry-log.js

@@ -95,11 +95,11 @@ function classifyReadKind(target) {
   if (inFeature) {
     const rel = inFeature[1];
     const PLAN_ARTIFACT_BASENAMES = new Set([
-      'proposal.md', 'spec.md', 'tasks.json',
-      'decisions.md', 'recap.md', 'handoff.md',
+      'plan.md', 'checks.json',
+      'handoff.md',
     ]);
     const base = rel.split('/').pop();
-    if (PLAN_ARTIFACT_BASENAMES.has(base) || rel.includes('usecases/') || rel.includes('reports/')) {
+    if (PLAN_ARTIFACT_BASENAMES.has(base) || rel.includes('reports/')) {
       return 'plan-artifact';
     }
   }

package/framework/hooks/claude-code/core/validate-completion.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * Stop Hook: phase-transition alert, recap/tasks audit, session usage.
+ * Stop Hook: phase-transition alert, slice report audit, session usage.
  *
  * Phase transition tracking: stores last-seen phase per feature in
  * .morph/memory/phase-watch.json so the alert fires exactly once.
@@ -19,97 +19,34 @@ import { contextResult, runStandalone } from '../../shared/hook-response.js';
 import { logHookActivity, logEvent } from '../../shared/activity-logger.js';
 import { appendTelemetryEvent } from '../../shared/telemetry-logger.js';
 import { readTranscriptUsage, usageDelta } from '../../shared/transcript-usage.js';
+import { sliceProgress, sliceReportPath, inspectReport } from '../../shared/slice-progress.js';
 
 /**
- * Audit recap.md against tasks.json + standard-citation rule.
- *
- * Returns an array of human-readable warnings. Empty array = audit clean.
- *
- * Two checks:
- *   1. Task IDs that appear as a "## T<n>" heading in recap.md but still
- *      carry status != 'done' in tasks.json — claim/state divergence.
- *   2. Task headings without a "**Standard:**" line nearby (within 10 lines
- *      after the heading) — no standard citation = unauditable decision.
+ * Slices whose report is final but lacks what the report contract asks for:
+ * prose, the files touched, every scenario the slice covers. Advisory: the
+ * same rule `report-check` applies when the orchestrator resumes control.
  */
-function auditRecapAndTasks(featurePath) {
+function auditSliceReports(featurePath) {
+  const progress = sliceProgress(featurePath);
+  if (!progress) return [];
   const warnings = [];
-  const recapPath = join(featurePath, '3-implement', 'recap.md');
-  const tasksJsonPath = join(featurePath, '2-plan', 'tasks.json');
-  if (!existsSync(recapPath) || !existsSync(tasksJsonPath)) return warnings;
-
-  let recap, tasksJson;
-  try {
-    recap = readFileSync(recapPath, 'utf-8');
-    tasksJson = JSON.parse(readFileSync(tasksJsonPath, 'utf-8'));
-  } catch {
-    return warnings;
-  }
-
-  const tasks = Array.isArray(tasksJson.tasks) ? tasksJson.tasks : [];
-  if (tasks.length === 0) return warnings;
-
-  // Index recap by task ID — collect line numbers where each task is mentioned
-  // as completed. Supports two formats agents commonly use:
-  //   (a) "## T<n>"           — heading style (per the SKILL.md template)
-  //   (b) "| T<n> | ... done" — markdown table row with done in same row
-  const lines = recap.split('\n');
-  const recapMentions = new Map(); // id → starting line index
-  const headingRe = /^##\s+(T\d+)\b/;
-  const tableRowRe = /^\|\s*(T\d+)\s*\|.*\bdone\b/i;
-  lines.forEach((ln, i) => {
-    const heading = ln.match(headingRe);
-    if (heading && !recapMentions.has(heading[1])) {
-      recapMentions.set(heading[1], i);
-      return;
-    }
-    const tableRow = ln.match(tableRowRe);
-    if (tableRow && !recapMentions.has(tableRow[1])) {
-      recapMentions.set(tableRow[1], i);
-    }
-  });
-
-  // Check 1: status drift — task mentioned as done in recap but tasks.json
-  // still shows it as pending/in_progress.
-  for (const t of tasks) {
-    if (recapMentions.has(t.id) && t.status !== 'done') {
-      warnings.push(
-        `tasks.json drift: ${t.id} appears as done in recap.md but tasks.json shows status="${t.status}". Run writeTasksJson to sync.`
-      );
+  for (const slice of progress.slices) {
+    if (slice.status !== 'feito') continue;
+    const { missing } = inspectReport(sliceReportPath(featurePath, slice.id), { covers: slice.covers });
+    if (missing.length) {
+      const hints = missing.map((id) => MISSING_HINT[id] ?? `cite ${id} pelo id`);
+      warnings.push(`relatório de ${slice.id} sem: ${missing.join(', ')} — ${hints.join('; ')} (formato na skill morph-apply; morph-spec report-check)`);
     }
   }
-
-  // Check 2: missing Standard citation per task mention. Skip pure
-  // table-row mentions (they're a summary, the heading-style block
-  // is where the standard belongs) — only flag when the agent did
-  // not produce a heading block at all for a task that is also marked
-  // done in tasks.json.
-  const standardRe = /\*\*Standard:\*\*|\bStandard\s*consulted\b|\bstandards?\s+used\b/i;
-  const headingMentions = new Map();
-  lines.forEach((ln, i) => {
-    const m = ln.match(headingRe);
-    if (m && !headingMentions.has(m[1])) headingMentions.set(m[1], i);
-  });
-  for (const t of tasks) {
-    if (t.status !== 'done') continue;
-    const lineIdx = headingMentions.get(t.id);
-    if (lineIdx === undefined) {
-      // Task is done but has no heading block at all — recap is summary-only.
-      warnings.push(
-        `recap.md task ${t.id} (status=done in tasks.json) has no detailed "## ${t.id}" block. Per morph-implement SKILL.md, each done task needs a heading block with a "**Standard:** ..." citation so the reviewer can audit the decision.`
-      );
-      continue;
-    }
-    const window = lines.slice(lineIdx, lineIdx + 12).join('\n');
-    if (!standardRe.test(window)) {
-      warnings.push(
-        `recap.md task ${t.id} is missing a "**Standard:** ..." citation within 12 lines of its heading. Cite which standard from STANDARDS.json justified the implementation (or "ad-hoc (see decisions.md ADR-N)" if intentional).`
-      );
-    }
-  }
-
   return warnings;
 }
 
+const MISSING_HINT = {
+  what: '2-3 frases do que foi feito e como foi provado',
+  files: 'linha **Arquivos:** com todo arquivo criado ou modificado',
+  partial: '1ª linha PARCIAL: a fatia não terminou',
+};
+
 // Phases where compaction is strongly recommended before starting
 const COMPACT_TRIGGER_PHASES = new Set(['implement']);
 
@@ -123,7 +60,7 @@ const HEAVY_SOURCE_PHASES = new Set(['plan', 'uiux']);
  *   `payload.session_id` for the throttle key) — the one thing only the
  *   payload carries.
  * @returns {Promise<object|null>} a hookSpecificOutput advisory (phase
- *   transition / build failure / recap drift), or null (pass/silent).
+ *   transition / build failure / incomplete slice report), or null (pass/silent).
  */
 export async function run(payload) {
   try {
@@ -171,7 +108,7 @@ export async function run(payload) {
         `⚡ Phase advanced: ${lastPhase} → implement`,
         ``,
         `💡 Recommended before starting implementation:`,
-        `   Run /compact to free up context — spec.md and tasks.json`,
+        `   Run /compact to free up context — plan.md and the design`,
         `   loaded during planning take significant space. A compact now gives`,
         `   Claude a clean slate focused on writing code.`,
         ``,
@@ -179,9 +116,8 @@ export async function run(payload) {
       );
     }
 
-    // ── Recap + tasks.json audit ──────────────────────────────────────────────
-    // Surface drift between recap.md and tasks.json, plus missing standard
-    // citations. Advisory warnings only — Stop hook never blocks.
+    // ── Slice report audit ────────────────────────────────────────────────────
+    // Advisory warnings only — Stop hook never blocks.
     //
     // The same audit re-runs every Stop; without dedup it re-injects the same
     // ~500-token block turn after turn even when nothing changed. Hash-gate it:
@@ -190,7 +126,7 @@ export async function run(payload) {
     // hash, so a later recurrence — even an identical one — is reported fresh.
     try {
       const featurePath = join(cwd, '.morph', 'features', name);
-      const recapWarnings = auditRecapAndTasks(featurePath);
+      const reportWarnings = auditSliceReports(featurePath);
 
       const warnedHashesPath = join(memDir, 'warned-hashes.json');
       let warnedHashes = {};
@@ -198,17 +134,17 @@ export async function run(payload) {
         if (existsSync(warnedHashesPath)) warnedHashes = JSON.parse(readFileSync(warnedHashesPath, 'utf-8'));
       } catch { /* corrupt file — start fresh */ }
 
-      if (recapWarnings.length > 0) {
-        const hash = createHash('sha1').update(recapWarnings.join('\n')).digest('hex');
-        if (warnedHashes[name]?.recap !== hash) {
-          warnings.push('📋 Recap audit:');
-          for (const w of recapWarnings) warnings.push(`  • ${w}`);
-          warnedHashes[name] = { ...warnedHashes[name], recap: hash };
+      if (reportWarnings.length > 0) {
+        const hash = createHash('sha1').update(reportWarnings.join('\n')).digest('hex');
+        if (warnedHashes[name]?.reports !== hash) {
+          warnings.push('📋 Relatórios de fatia:');
+          for (const w of reportWarnings) warnings.push(`  • ${w}`);
+          warnedHashes[name] = { ...warnedHashes[name], reports: hash };
           try { writeFileSync(warnedHashesPath, JSON.stringify(warnedHashes, null, 2), 'utf-8'); } catch { /* non-blocking */ }
         }
         // same hash as last time it fired → already surfaced, stay silent
-      } else if (warnedHashes[name]?.recap) {
-        delete warnedHashes[name].recap;
+      } else if (warnedHashes[name]?.reports) {
+        delete warnedHashes[name].reports;
         try { writeFileSync(warnedHashesPath, JSON.stringify(warnedHashes, null, 2), 'utf-8'); } catch { /* non-blocking */ }
       }
     } catch {

package/framework/hooks/claude-code/core/warn-bash-source-write.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+/**
+ * warn-bash-source-write — PreToolUse Bash, warn only: a project source file written
+ * by the shell (`writeTargets`) skips every Write/Edit guard (phase folders,
+ * protected files, comment-guard). The command still runs.
+ */
+import { contextResult, runStandalone } from '../../shared/hook-response.js';
+import { stateExists } from '../../shared/state-reader.js';
+import { writeTargets } from '../../shared/command-tokens.js';
+import { isProjectSource } from '../../shared/source-files.js';
+
+/**
+ * @param {object} payload - parsed PreToolUse stdin payload (Bash matcher)
+ * @returns {Promise<object|null>} additionalContext naming the files, or null
+ */
+export async function run(payload) {
+  try {
+    if (!stateExists()) return null;
+    const sources = writeTargets(payload?.tool_input?.command || '').filter(isProjectSource);
+    if (!sources.length) return null;
+    return contextResult(
+      `⚠️ Código do projeto escrito pelo Bash (${sources.join(', ')}): os guards de escrita (fase, arquivo protegido, comment-guard) ` +
+        'só enxergam Write/Edit. Reescreva esse arquivo por Write/Edit.',
+      'PreToolUse',
+    );
+  } catch {
+    return null;
+  }
+}
+
+await runStandalone(run);