@polymorphism-tech/morph-spec 8.46.0 → 9.0.0

package/framework/commands/commit.md

@@ -1,166 +0,0 @@
----
-allowed-tools: Bash(git add:*), Bash(git status:*), Bash(git commit:*), Bash(git diff:*), Bash(git log:*)
-argument-hint: [message] | --no-verify | --amend
-description: Create well-formatted commits with conventional commit format and emoji
----
-
-# Smart Git Commit
-
-Create well-formatted commit: $ARGUMENTS
-
-## Current Repository State
-
-- Git status: !git status --porcelain
-- Current branch: !git branch --show-current
-- Staged changes: !git diff --cached --stat
-- Unstaged changes: !git diff --stat
-- Recent commits: !git log --oneline -5
-
-## What This Command Does
-
-1. Unless specified with --no-verify, automatically runs pre-commit checks:
-   - pnpm lint to ensure code quality
-   - pnpm build to verify the build succeeds
-   - pnpm generate:docs to update documentation
-2. Checks which files are staged with git status
-3. If 0 files are staged, automatically adds all modified and new files with git add
-4. Performs a git diff to understand what changes are being committed
-5. Analyzes the diff to determine if multiple distinct logical changes are present
-6. If multiple distinct changes are detected, suggests breaking the commit into multiple smaller commits
-7. For each commit (or the single commit if not split), creates a commit message using emoji conventional commit format
-
-## Best Practices for Commits
-
-- **Verify before committing**: Ensure code is linted, builds correctly, and documentation is updated
-- **Atomic commits**: Each commit should contain related changes that serve a single purpose
-- **Split large changes**: If changes touch multiple concerns, split them into separate commits
-- **Conventional commit format**: Use the format <type>: <description> where type is one of:
-  - feat: A new feature
-  - fix: A bug fix
-  - docs: Documentation changes
-  - style: Code style changes (formatting, etc)
-  - refactor: Code changes that neither fix bugs nor add features
-  - perf: Performance improvements
-  - test: Adding or fixing tests
-  - chore: Changes to the build process, tools, etc.
-- **Present tense, imperative mood**: Write commit messages as commands (e.g., "add feature" not "added feature")
-- **Concise first line**: Keep the first line under 72 characters
-- **Emoji**: Each commit type is paired with an appropriate emoji:
-  - ✨ feat: New feature
-  - 🐛 fix: Bug fix
-  - 📝 docs: Documentation
-  - 💄 style: Formatting/style
-  - ♻️ refactor: Code refactoring
-  - ⚡️ perf: Performance improvements
-  - ✅ test: Tests
-  - 🔧 chore: Tooling, configuration
-  - 🚀 ci: CI/CD improvements
-  - 🗑️ revert: Reverting changes
-  - 🧪 test: Add a failing test
-  - 🚨 fix: Fix compiler/linter warnings
-  - 🔒️ fix: Fix security issues
-  - 👥 chore: Add or update contributors
-  - 🚚 refactor: Move or rename resources
-  - 🏗️ refactor: Make architectural changes
-  - 🔀 chore: Merge branches
-  - 📦️ chore: Add or update compiled files or packages
-  - ➕ chore: Add a dependency
-  - ➖ chore: Remove a dependency
-  - 🌱 chore: Add or update seed files
-  - 🧑‍💻 chore: Improve developer experience
-  - 🧵 feat: Add or update code related to multithreading or concurrency
-  - 🔍️ feat: Improve SEO
-  - 🏷️ feat: Add or update types
-  - 💬 feat: Add or update text and literals
-  - 🌐 feat: Internationalization and localization
-  - 👔 feat: Add or update business logic
-  - 📱 feat: Work on responsive design
-  - 🚸 feat: Improve user experience / usability
-  - 🩹 fix: Simple fix for a non-critical issue
-  - 🥅 fix: Catch errors
-  - 👽️ fix: Update code due to external API changes
-  - 🔥 fix: Remove code or files
-  - 🎨 style: Improve structure/format of the code
-  - 🚑️ fix: Critical hotfix
-  - 🎉 chore: Begin a project
-  - 🔖 chore: Release/Version tags
-  - 🚧 wip: Work in progress
-  - 💚 fix: Fix CI build
-  - 📌 chore: Pin dependencies to specific versions
-  - 👷 ci: Add or update CI build system
-  - 📈 feat: Add or update analytics or tracking code
-  - ✏️ fix: Fix typos
-  - ⏪️ revert: Revert changes
-  - 📄 chore: Add or update license
-  - 💥 feat: Introduce breaking changes
-  - 🍱 assets: Add or update assets
-  - ♿️ feat: Improve accessibility
-  - 💡 docs: Add or update comments in source code
-  - 🗃️ db: Perform database related changes
-  - 🔊 feat: Add or update logs
-  - 🔇 fix: Remove logs
-  - 🤡 test: Mock things
-  - 🥚 feat: Add or update an easter egg
-  - 🙈 chore: Add or update .gitignore file
-  - 📸 test: Add or update snapshots
-  - ⚗️ experiment: Perform experiments
-  - 🚩 feat: Add, update, or remove feature flags
-  - 💫 ui: Add or update animations and transitions
-  - ⚰️ refactor: Remove dead code
-  - 🦺 feat: Add or update code related to validation
-  - ✈️ feat: Improve offline support
-
-## Guidelines for Splitting Commits
-
-When analyzing the diff, consider splitting commits based on these criteria:
-
-1. **Different concerns**: Changes to unrelated parts of the codebase
-2. **Different types of changes**: Mixing features, fixes, refactoring, etc.
-3. **File patterns**: Changes to different types of files (e.g., source code vs documentation)
-4. **Logical grouping**: Changes that would be easier to understand or review separately
-5. **Size**: Very large changes that would be clearer if broken down
-
-## Examples
-
-Good commit messages:
-- ✨ feat: add user authentication system
-- 🐛 fix: resolve memory leak in rendering process
-- 📝 docs: update API documentation with new endpoints
-- ♻️ refactor: simplify error handling logic in parser
-- 🚨 fix: resolve linter warnings in component files
-- 🧑‍💻 chore: improve developer tooling setup process
-- 👔 feat: implement business logic for transaction validation
-- 🩹 fix: address minor styling inconsistency in header
-- 🚑️ fix: patch critical security vulnerability in auth flow
-- 🎨 style: reorganize component structure for better readability
-- 🔥 fix: remove deprecated legacy code
-- 🦺 feat: add input validation for user registration form
-- 💚 fix: resolve failing CI pipeline tests
-- 📈 feat: implement analytics tracking for user engagement
-- 🔒️ fix: strengthen authentication password requirements
-- ♿️ feat: improve form accessibility for screen readers
-
-Example of splitting commits:
-- First commit: ✨ feat: add new solc version type definitions
-- Second commit: 📝 docs: update documentation for new solc versions
-- Third commit: 🔧 chore: update package.json dependencies
-- Fourth commit: 🏷️ feat: add type definitions for new API endpoints
-- Fifth commit: 🧵 feat: improve concurrency handling in worker threads
-- Sixth commit: 🚨 fix: resolve linting issues in new code
-- Seventh commit: ✅ test: add unit tests for new solc version features
-- Eighth commit: 🔒️ fix: update dependencies with security vulnerabilities
-
-## Command Options
-
-- --no-verify: Skip running the pre-commit checks (lint, build, generate:docs)
-
-## Important Notes
-
-- By default, pre-commit checks (pnpm lint, pnpm build, pnpm generate:docs) will run to ensure code quality
-- If these checks fail, you'll be asked if you want to proceed with the commit anyway or fix the issues first
-- If specific files are already staged, the command will only commit those files
-- If no files are staged, it will automatically stage all modified and new files
-- The commit message will be constructed based on the changes detected
-- Before committing, the command will review the diff to identify if multiple commits would be more appropriate
-- If suggesting multiple commits, it will help you stage and commit the changes separately
-- Always reviews the commit diff to ensure the message matches the changes

package/framework/evals/trace-schema.md

@@ -1,67 +0,0 @@
-# Trace Schema — morph-spec NLH
-
-## Local de armazenamento
-
-`.morph/traces/YYYY-MM-DD-{feature}-{phase}.json`
-
-Um arquivo por fase. Se a fase for executada em múltiplas sessões, o mesmo arquivo é atualizado incrementalmente.
-
-## Formato JSON
-
-```json
-{
-  "schema_version": "1.0",
-  "session_id": "YYYY-MM-DD-HH-MM-SS",
-  "feature": "nome-da-feature",
-  "phase": "implement | plan | review",
-  "started_at": "ISO 8601",
-  "completed_at": "ISO 8601",
-  "tasks": [
-    {
-      "id": "T1",
-      "title": "descrição da task",
-      "status": "completed | failed | skipped",
-      "standards_consulted": ["id-do-standard-1"],
-      "agent_persona": "dotnet-senior | nextjs-expert | etc",
-      "sub_agent_dispatched": false,
-      "files_modified": ["path/relativo/arquivo.cs"],
-      "duration_seconds": null
-    }
-  ],
-  "phase_summary": {
-    "tasks_completed": 3,
-    "tasks_failed": 0,
-    "standards_most_used": ["architecture-vertical-slice"],
-    "sub_agents_dispatched": 0
-  }
-}
-```
-
-## Como o trace é gerado (automático — não escreva à mão)
-
-O trace é **gerado pelo hook `trace-autogen`** (PostToolUse em Write|Edit) a cada
-write de `2-plan/tasks.json` — o último write da cerimônia de cada task. As skills
-(`morph-implement`, `morph-review`) **não escrevem o trace**.
-
-| Fonte | O que alimenta |
-|-------|----------------|
-| `tasks.json` | conjunto de tasks, `status` (done→completed, skipped→skipped, blocked→failed; pending/in_progress ficam fora), `outputs` → `files_modified` |
-| `recap.md` | `**Standard:**` → `standards_consulted`; `**Persona:**` → `agent_persona` + `sub_agent_dispatched` (`morph-{id}`/`general-purpose` = true) |
-
-`completed_at` e `phase_summary` são preenchidos quando nenhuma task resta
-`pending`/`in_progress`. O arquivo existente da mesma feature+fase é atualizado
-in place (`session_id`/`started_at` preservados entre sessões).
-
-**Se o trace parecer incompleto, corrija a FONTE** (um recap sem o bloco `## T{N}`), nunca o trace.
-
-## Regras de geração
-
-- Se um campo não tiver valor disponível, o hook usa `null` — nunca omite o campo.
-- Estrutura completa mantida para compatibilidade com análise de meta-harness.
-- `session_id` usa o formato `YYYY-MM-DD-HH-MM-SS` da primeira geração.
-- `standards_consulted` contém os `id`s do STANDARDS.json, não os paths.
-- `files_modified` usa paths relativos à raiz do repositório (vem de `outputs`).
-
-## Motivação
-
-Raw traces preservam o sinal completo de execução. Summaries comprimem informação e perdem sinais que o meta-harness usa para otimização. Regra: logar o trace completo — nunca substituir por resumo.

package/framework/hooks/claude-code/core/tasks-json-guard.js

@@ -1,83 +0,0 @@
-#!/usr/bin/env node
-/**
- * tasks-json-guard.js — PostToolUse hook (validate-and-warn, never block)
- *
- * Event: PostToolUse | Matcher: Write|Edit
- *
- * After any Write/Edit that touches a tasks.json under .morph/features/,
- * re-reads the file from disk and validates the schema (status enum, effort
- * enum). Invalid → injects a warning so the LLM fixes the file immediately;
- * valid → logs one activity line and stays silent.
- *
- * The production failure this guards: a leaf sub-agent wrote
- * status:"completed" (not in the enum — the schema accepts "done") into
- * tasks.json and nothing flagged it. The blocking pre-write validation for
- * post-Gate-2 edits lives in protect-spec-files.js (PreToolUse); this
- * PostToolUse pass also covers pre-gate authoring (morph-plan) and anything
- * that landed on disk regardless.
- *
- * Fail-open: exits 0 on any error.
- */
-
-import { readFileSync } from 'fs';
-import { isAbsolute, join } from 'path';
-import { stateExists } from '../../shared/state-reader.js';
-import { contextResult, runStandalone } from '../../shared/hook-response.js';
-import { logHookActivity } from '../../shared/activity-logger.js';
-import { getFilePath } from '../../shared/payload-utils.js';
-import { isFeaturePath, getBasename } from '../../shared/phase-utils.js';
-import { VALID_TASK_STATUS, validateTasksDoc } from '../../shared/tasks-validator.js';
-
-function projectDir() {
-  return process.env.CLAUDE_PROJECT_DIR || process.cwd();
-}
-
-/**
- * @param {object} payload - parsed PostToolUse stdin payload (Write|Edit)
- * @returns {Promise<object|null>} a hookSpecificOutput warning when tasks.json
- *   is unparseable or schema-invalid, or null (pass/silent).
- */
-export async function run(payload) {
-  try {
-    const cwd = projectDir();
-    if (!stateExists(cwd)) return null;
-
-    const filePath = getFilePath(payload);
-    if (!filePath) return null;
-    if (!isFeaturePath(filePath)) return null;
-    if (getBasename(filePath) !== 'tasks.json') return null;
-
-    const absPath = isAbsolute(filePath) ? filePath : join(cwd, filePath);
-
-    let doc;
-    try {
-      doc = JSON.parse(readFileSync(absPath, 'utf-8'));
-    } catch {
-      logHookActivity('tasks-json-guard', 'PostToolUse', 'invalid', cwd);
-      return contextResult(
-        '⚠️ [morph-spec] tasks.json INVÁLIDO — o arquivo gravado não parseia como JSON. ' +
-        'Corrija o arquivo antes de continuar.',
-        'PostToolUse'
-      );
-    }
-
-    const { valid, errors } = validateTasksDoc(doc);
-    if (!valid) {
-      logHookActivity('tasks-json-guard', 'PostToolUse', 'invalid', cwd);
-      return contextResult(
-        '⚠️ [morph-spec] tasks.json com schema inválido após o write:\n' +
-        errors.map(e => `  • ${e}`).join('\n') +
-        `\nStatus válidos: ${VALID_TASK_STATUS.join(', ')}. Corrija antes de marcar a task como done.`,
-        'PostToolUse'
-      );
-    }
-
-    logHookActivity('tasks-json-guard', 'PostToolUse', 'ok', cwd);
-    return null;
-  } catch {
-    // Fail-open
-    return null;
-  }
-}
-
-await runStandalone(run);

package/framework/hooks/claude-code/core/trace-autogen.js

@@ -1,277 +0,0 @@
-#!/usr/bin/env node
-/**
- * trace-autogen.js — PostToolUse hook (Write|Edit)
- *
- * Auto-generates the execution trace
- * `.morph/traces/YYYY-MM-DD-{feature}-implement.json` from tasks.json +
- * recap.md whenever tasks.json is written during
- * the implement phase.
- *
- * This removes the manual trace-writing step from the skills (friction item
- * observed in MORPH_GHLBrain 2026-07-11: 5 writes per task). The tasks.json
- * status flip — the last write of every task's ceremony — now produces the
- * trace for free: deterministic, idempotent, always in sync with the real
- * on-disk state. The skills must NOT write traces by hand anymore.
- *
- * Sources:
- *  - tasks.json      → task set, status (done→completed, skipped→skipped,
- *                      blocked→failed; pending/in_progress stay out), outputs
- *  - recap.md        → per-task `**Standard:**` id and `**Persona:**` line
- *
- * The most recent existing `*-{feature}-implement.json` is updated in place
- * (session_id/started_at preserved); a new dated file is created otherwise.
- * `completed_at` + phase_summary are stamped when no task is left
- * pending/in_progress. Fail-open: any error exits 0 silently.
- *
- * This is also the vantage point for TaskStart/TaskEnd telemetry: a
- * pending→in_progress flip and a flip to done/skipped are the only two task
- * transitions the harness can observe (tasks.json is the single place task
- * status is written), so this hook diffs each task's previous status against
- * `.morph/logs/task-times.json` and appends the matching event via the shared
- * telemetry logger (see `updateTaskTimes` below). The same start/end pair
- * feeds `duration_seconds` in the trace entry.
- */
-
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
-import { join } from 'path';
-import { runStandalone } from '../../shared/hook-response.js';
-import { stateExists } from '../../shared/state-reader.js';
-import { getFilePath, resolveMorphRoot } from '../../shared/payload-utils.js';
-import { appendTelemetryEvent } from '../../shared/telemetry-logger.js';
-
-function projectDir() {
-  return process.env.CLAUDE_PROJECT_DIR || process.cwd();
-}
-
-function extractFeature(filePath) {
-  const normalized = String(filePath).replace(/\\/g, '/');
-  const match = normalized.match(/\.morph\/features\/([^/]+)\/2-plan\/tasks\.json$/);
-  return match ? match[1] : null;
-}
-
-/**
- * Parse recap.md task blocks (`## T{N} — ...`) into
- * { [id]: { standard, persona } }. Best-effort: missing fields stay null.
- */
-function parseRecap(raw) {
-  const map = {};
-  const blocks = String(raw).split(/^## (?=T\d+)/m).slice(1);
-  for (const block of blocks) {
-    const id = (block.match(/^(T\d+)/) ?? [])[1];
-    if (!id) continue;
-    const standard = (block.match(/\*\*Standard:\*\*\s*([^\s(]+)/) ?? [])[1] ?? null;
-    const persona = (block.match(/\*\*Persona:\*\*\s*(.+)$/m) ?? [])[1]?.trim() ?? null;
-    map[id] = { standard, persona };
-  }
-  return map;
-}
-
-/** session_id in the trace-schema format YYYY-MM-DD-HH-MM-SS. */
-function sessionId(d) {
-  const p = (n) => String(n).padStart(2, '0');
-  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}-${p(d.getHours())}-${p(d.getMinutes())}-${p(d.getSeconds())}`;
-}
-
-/** tasks.json status → trace-schema status. Unsettled statuses are omitted. */
-const STATUS_MAP = { done: 'completed', skipped: 'skipped', blocked: 'failed' };
-
-const TASK_TIMES_PATH = join('.morph', 'logs', 'task-times.json');
-
-/**
- * Read `.morph/logs/task-times.json`: `{ [feature]: { [taskId]: { status,
- * start?, end? } } }`. Nested by feature — not flat by task id, as a literal
- * reading of "keyed by taskId" might suggest — because task ids (T1, T2…)
- * are only unique WITHIN a feature; a flat map would let two sibling
- * features in the same tree (see worktree-state-resolution.test.js for that
- * shape) clobber each other's start/end timestamps.
- * Fail-open: a missing/corrupt file reads as {}.
- */
-function readTaskTimes(root) {
-  const p = join(root, TASK_TIMES_PATH);
-  if (!existsSync(p)) return {};
-  try {
-    return JSON.parse(readFileSync(p, 'utf8'));
-  } catch {
-    return {};
-  }
-}
-
-function writeTaskTimes(root, allTimes) {
-  mkdirSync(join(root, '.morph', 'logs'), { recursive: true });
-  writeFileSync(join(root, TASK_TIMES_PATH), JSON.stringify(allTimes, null, 2), 'utf8');
-}
-
-/**
- * Diff each task's PREVIOUS status (from `times`, this feature's slice of
- * task-times.json) against its status in the tasks.json that was just
- * written, and append the matching telemetry event via the shared logger —
- * same shape/mechanism as every other event in events.jsonl, just a
- * different `event` value.
- *
- *  - pending → in_progress   ⇒ TaskStart, stamp `start`
- *  - anything → done/skipped ⇒ TaskEnd (carries the new status), stamp `end`
- *  - first sight of a task id (no prior entry) only seeds the baseline,
- *    silently — there is no prior status to diff, and emitting an event here
- *    would fabricate a transition that never happened (e.g. a task whose
- *    first-ever tasks.json write already shows it `done`, from historical
- *    data predating this file).
- *
- * Mutates `times` in place and returns whether anything changed, so the
- * caller only rewrites task-times.json when needed and the entries built
- * right after this call see the freshly-stamped start/end for
- * `duration_seconds`.
- */
-function updateTaskTimes(times, tasks, feature, root, nowIso) {
-  let changed = false;
-  for (const t of tasks) {
-    const prev = times[t.id];
-    if (!prev) {
-      times[t.id] = { status: t.status };
-      changed = true;
-      continue;
-    }
-    if (prev.status === t.status) continue;
-
-    if (prev.status === 'pending' && t.status === 'in_progress') {
-      appendTelemetryEvent({ event: 'TaskStart', feature, task: t.id, phase: 'implement' }, root);
-      times[t.id] = { ...prev, status: t.status, start: nowIso };
-    } else if (t.status === 'done' || t.status === 'skipped') {
-      appendTelemetryEvent({ event: 'TaskEnd', feature, task: t.id, status: t.status, phase: 'implement' }, root);
-      times[t.id] = { ...prev, status: t.status, end: nowIso };
-    } else {
-      times[t.id] = { ...prev, status: t.status };
-    }
-    changed = true;
-  }
-  return changed;
-}
-
-/** Seconds between recorded start/end for a task, or null when either is missing. */
-function taskDuration(times, taskId) {
-  const rec = times[taskId];
-  if (!rec?.start || !rec?.end) return null;
-  const secs = (new Date(rec.end).getTime() - new Date(rec.start).getTime()) / 1000;
-  return Number.isFinite(secs) ? Math.round(secs * 10) / 10 : null;
-}
-
-/**
- * @param {object} payload - parsed PostToolUse stdin payload (Write|Edit)
- * @returns {Promise<null>} always null — this hook is pure side-effect (trace
- *   file + task-times.json), never prints/injects context.
- */
-export async function run(payload) {
-  try {
-    await generateTrace(payload);
-  } catch {
-    // Fail-open
-  }
-  return null;
-}
-
-async function generateTrace(payload) {
-  if (!payload) return;
-
-  const filePath = getFilePath(payload);
-  const feature = filePath ? extractFeature(filePath) : null;
-  if (!feature) return;
-
-  // Read the sources — and write the trace — in the tree that owns the written
-  // tasks.json. Resolving from the session instead made this hook INERT for
-  // every worktree feature: the root's copy of the feature has no
-  // `2-plan/tasks.json`, so the `existsSync` guard below returned silently and
-  // no trace was ever produced for work done in a worktree.
-  const cwd = resolveMorphRoot(filePath, projectDir());
-  if (!stateExists(cwd)) return;
-
-  const featureDir = join(cwd, '.morph', 'features', feature);
-  const tasksPath = join(featureDir, '2-plan', 'tasks.json');
-  if (!existsSync(tasksPath)) return;
-  const tasksDoc = JSON.parse(readFileSync(tasksPath, 'utf8'));
-  const tasks = Array.isArray(tasksDoc.tasks) ? tasksDoc.tasks : [];
-
-  const now = new Date();
-
-  // TaskStart/TaskEnd telemetry + duration_seconds source: diff each task's
-  // previous status (persisted below) against the status just written.
-  const allTimes = readTaskTimes(cwd);
-  const times = allTimes[feature] ?? (allTimes[feature] = {});
-  if (updateTaskTimes(times, tasks, feature, cwd, now.toISOString())) {
-    writeTaskTimes(cwd, allTimes);
-  }
-
-  let recap = {};
-  const recapPath = join(featureDir, '3-implement', 'recap.md');
-  if (existsSync(recapPath)) {
-    try { recap = parseRecap(readFileSync(recapPath, 'utf8')); } catch { recap = {}; }
-  }
-
-  const tracesDir = join(cwd, '.morph', 'traces');
-  mkdirSync(tracesDir, { recursive: true });
-
-  // Multi-session phases update the same file incrementally (trace-schema):
-  // reuse the most recent trace for this feature+phase if one exists.
-  const suffix = `-${feature}-implement.json`;
-  const existing = readdirSync(tracesDir)
-    .filter(f => /^\d{4}-\d{2}-\d{2}-/.test(f) && f.endsWith(suffix))
-    .sort()
-    .pop();
-
-  let previous = null;
-  if (existing) {
-    try { previous = JSON.parse(readFileSync(join(tracesDir, existing), 'utf8')); } catch { previous = null; }
-  }
-
-  const fileName = existing ?? `${now.toISOString().slice(0, 10)}${suffix}`;
-
-  const entries = tasks
-    .filter(t => STATUS_MAP[t.status])
-    .map(t => {
-      const recapEntry = recap[t.id] ?? {};
-      return {
-        id: t.id,
-        title: t.title ?? null,
-        status: STATUS_MAP[t.status],
-        standards_consulted: recapEntry.standard ? [recapEntry.standard] : [],
-        agent_persona: recapEntry.persona ?? null,
-        sub_agent_dispatched: recapEntry.persona
-          ? /^morph-|general-purpose/.test(recapEntry.persona)
-          : false,
-        files_modified: Array.isArray(t.outputs) ? t.outputs.filter(o => typeof o === 'string') : [],
-        duration_seconds: taskDuration(times, t.id),
-      };
-    });
-
-  const allSettled = tasks.length > 0 &&
-    tasks.every(t => t.status !== 'pending' && t.status !== 'in_progress');
-
-  const standardCounts = {};
-  for (const entry of entries) {
-    for (const std of entry.standards_consulted) {
-      standardCounts[std] = (standardCounts[std] ?? 0) + 1;
-    }
-  }
-  const mostUsed = Object.entries(standardCounts)
-    .sort((a, b) => b[1] - a[1])
-    .slice(0, 3)
-    .map(([std]) => std);
-
-  const trace = {
-    schema_version: '1.0',
-    session_id: previous?.session_id ?? sessionId(now),
-    feature,
-    phase: 'implement',
-    started_at: previous?.started_at ?? now.toISOString(),
-    completed_at: allSettled ? (previous?.completed_at ?? now.toISOString()) : null,
-    tasks: entries,
-    phase_summary: {
-      tasks_completed: entries.filter(e => e.status === 'completed').length,
-      tasks_failed: entries.filter(e => e.status === 'failed').length,
-      standards_most_used: mostUsed,
-      sub_agents_dispatched: entries.filter(e => e.sub_agent_dispatched).length,
-    },
-  };
-
-  writeFileSync(join(tracesDir, fileName), JSON.stringify(trace, null, 2), 'utf8');
-}
-
-await runStandalone(run);

package/framework/hooks/git/pre-commit/specs.sh

@@ -1,50 +0,0 @@
-#!/bin/bash
-# Scope: universal | Validates spec.md required sections
-# MORPH-SPEC Pre-Commit Hook: Spec Validation
-# Validates that spec.md files have required sections
-
-echo "🔍 Validating spec files..."
-
-# Find modified spec.md files
-SPEC_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep 'spec\.md$')
-
-if [ -z "$SPEC_FILES" ]; then
-  echo "✓ No spec files modified"
-  exit 0
-fi
-
-HAS_ERRORS=false
-
-for spec_file in $SPEC_FILES; do
-  echo "Checking: $spec_file"
-
-  # Required sections
-  REQUIRED_SECTIONS=(
-    "## 📋 Metadata"
-    "## 🎯 Overview"
-    "## 🏗️ Technical Design"
-    "## ✅ Acceptance Criteria"
-  )
-
-  for section in "${REQUIRED_SECTIONS[@]}"; do
-    if ! grep -q "$section" "$spec_file"; then
-      echo "  ❌ Missing section: $section"
-      HAS_ERRORS=true
-    fi
-  done
-
-  # Check if has at least one user story or requirement
-  if ! grep -qi "user story\|requirement\|acceptance criteria" "$spec_file"; then
-    echo "  ⚠️  Warning: No user stories or requirements found"
-  fi
-done
-
-if [ "$HAS_ERRORS" = true ]; then
-  echo ""
-  echo "❌ COMMIT BLOCKED: spec.md files are incomplete"
-  echo "   Add missing sections before committing"
-  exit 1
-fi
-
-echo "✓ All spec files are valid"
-exit 0