@polymorphism-tech/morph-spec 8.47.0 → 9.1.0

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

@@ -1,28 +1,5 @@
-/**
- * Activity Logger — Session-scoped hook event log
- *
- * Writes hook activity to .morph/logs/activity.jsonl for live consumption
- * (statusline, `morph-spec fleet`, etc).
- *
- * Design constraints:
- * - Synchronous only (hooks run in process, no async overhead)
- * - Fail-silent (never throws — hooks must not be blocked by the logger)
- * - ≤5ms per call (no retries, no network)
- * - APPEND-ONLY: one `appendFileSync` line per event, O(1) per call. The
- *   previous format did a read-modify-write of the WHOLE JSON doc per call
- *   (logHookActivity/logEvent both read, mutated, and rewrote the entire
- *   file) — O(n²) across a session once tool calls number in the hundreds,
- *   with 6 hooks each calling this 3-5x per Write. Same discipline as
- *   telemetry-logger.js's events.jsonl.
- * - Windows-safe paths via path.join
- *
- * 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,
- * loop-detect.js, protect-spec-files.js, validate-completion.js) call
- * logHookActivity/logEvent and must keep working untouched. Only the
- * on-disk format changed.
- */
+// Append-only on purpose: rewriting a whole JSON doc per event is O(n²) across
+// a session. Fail-silent: never blocks a hook.
 
 import {
   appendFileSync, readFileSync, mkdirSync, existsSync, statSync, renameSync, writeFileSync,
@@ -32,10 +9,7 @@ import { join } from 'path';
 const LOGS_DIR = '.morph/logs';
 export const ACTIVITY_FILE = join(LOGS_DIR, 'activity.jsonl');
 
-// SessionStart (worktree-context.js) rotates the log once it crosses this
-// size — the archive/rotation call site resetActivity()/archiveSession()
-// were written for but never got until now.
-export const ROTATE_THRESHOLD_BYTES = 2 * 1024 * 1024; // 2 MB
+export const ROTATE_THRESHOLD_BYTES = 2 * 1024 * 1024;
 
 function getActivityPath(projectPath) {
   return join(projectPath || process.cwd(), ACTIVITY_FILE);
@@ -49,20 +23,17 @@ function ensureLogsDir(projectPath) {
 }
 
 function nowTs() {
-  return new Date().toTimeString().slice(0, 8); // HH:MM:SS — matches the previous format
+  return new Date().toTimeString().slice(0, 8);
 }
 
-/** Append one JSON line. Fail-silent, O(1) regardless of file size. */
 function appendLine(projectPath, line) {
   try {
     ensureLogsDir(projectPath);
     appendFileSync(getActivityPath(projectPath), JSON.stringify(line) + '\n', 'utf-8');
   } catch {
-    // Fail-silent — never block hooks
   }
 }
 
-/** Read every parseable line back. A corrupt/truncated line is skipped, not fatal. */
 function readLines(projectPath) {
   try {
     const activityPath = getActivityPath(projectPath);
@@ -75,7 +46,7 @@ function readLines(projectPath) {
       try {
         lines.push(JSON.parse(trimmed));
       } catch {
-        // skip a single corrupt line — don't lose the whole stream
+        // a process killed mid-write leaves a truncated line
       }
     }
     return lines;
@@ -84,38 +55,15 @@ function readLines(projectPath) {
   }
 }
 
-/**
- * Log a hook firing event to the session activity log.
- *
- * @param {string} name   - Hook name (e.g. 'dispatch.js', 'enrich-prompt')
- * @param {string} event  - Claude Code event (e.g. 'PostToolUse', 'UserPromptSubmit')
- * @param {string} result - Outcome summary (e.g. 'ok', 'blocked', 'checkpoint_saved')
- * @param {string} [projectPath] - Project root (defaults to cwd)
- */
 export function logHookActivity(name, event, result, projectPath) {
   appendLine(projectPath, { kind: 'hook', name, event, result, ts: nowTs() });
 }
 
-/**
- * Log a structured event to the session activity log.
- *
- * @param {string} type   - Event type (e.g., 'task_start', 'loop_detected')
- * @param {Object} data   - Event data payload
- * @param {string} [projectPath] - Project root (defaults to cwd)
- */
 export function logEvent(type, data, projectPath) {
   appendLine(projectPath, { kind: 'event', type, data, ts: nowTs() });
 }
 
-/**
- * Read the current activity log, reconstructed into the aggregate shape
- * older consumers expect: `{ sessionId, feature, phase, hooks, events }`.
- * `sessionId`/`feature`/`phase` come from the synthetic 'session' header
- * line `resetActivity()` writes, when present.
- *
- * @param {string} [projectPath]
- * @returns {{ sessionId: string, feature: string, phase: string, hooks: Array, events: Array }|null}
- */
+/** @returns {{ sessionId: string, feature: string, phase: string, hooks: Array, events: Array }|null} */
 export function readActivity(projectPath) {
   const lines = readLines(projectPath);
   if (lines.length === 0) return null;
@@ -132,17 +80,8 @@ export function readActivity(projectPath) {
   };
 }
 
-/**
- * Reset the activity log for a new session — the one operation in this file
- * that is NOT append-only (a session boundary, not a log entry). Truncates
- * the file and writes a 'session' header line so `readActivity()` can
- * recover sessionId/feature/phase.
- *
- * @param {string} sessionId  - ISO timestamp of new session
- * @param {string} feature    - Active feature name (empty string if none)
- * @param {string} phase      - Current phase (empty string if none)
- * @param {string} [projectPath]
- */
+// The one write that truncates: the 'session' header is what `readActivity()`
+// recovers sessionId/feature/phase from.
 export function resetActivity(sessionId, feature, phase, projectPath) {
   try {
     ensureLogsDir(projectPath);
@@ -154,18 +93,9 @@ export function resetActivity(sessionId, feature, phase, projectPath) {
     };
     writeFileSync(getActivityPath(projectPath), JSON.stringify(session) + '\n', 'utf-8');
   } catch {
-    // Fail-silent
   }
 }
 
-/**
- * Archive the current activity log to sessions/ for historical logging.
- * Only archives when there is at least one hook or event line — a bare (or
- * absent) log is not worth preserving. `renameSync` keeps this O(1) even at
- * the multi-MB sizes rotation is meant to catch (no read+rewrite of content).
- *
- * @param {string} [projectPath] - Project root (defaults to cwd)
- */
 export function archiveSession(projectPath) {
   try {
     const activityPath = getActivityPath(projectPath);
@@ -183,20 +113,10 @@ export function archiveSession(projectPath) {
     const archivePath = join(sessionsDir, `${stamp}.jsonl`);
     renameSync(activityPath, archivePath);
   } catch {
-    // Fail-silent
   }
 }
 
-/**
- * Rotate the activity log when it crosses `thresholdBytes` — the real call
- * site for archiveSession() (previously written but never invoked anywhere).
- * Called from worktree-context.js on SessionStart, the only reliable
- * "between sessions" checkpoint the harness gets.
- *
- * @param {string} [projectPath] - Project root (defaults to cwd)
- * @param {number} [thresholdBytes] - Rotate once the log is at least this large
- * @returns {boolean} true if a rotation was performed
- */
+/** @returns {boolean} true if a rotation was performed */
 export function rotateActivityLogIfLarge(projectPath, thresholdBytes = ROTATE_THRESHOLD_BYTES) {
   try {
     const activityPath = getActivityPath(projectPath);

package/framework/hooks/shared/agent-reap.js

@@ -1,15 +1,5 @@
-/**
- * agent-reap.js — dispara `morph-spec worktree reap` em background no SessionStart.
- *
- * O hook de SessionStart tem 5 s de timeout e o reaper mede git por árvore: por isso o
- * disparo só olha o disco (nenhum subprocesso) e solta este arquivo como worker DESTACADO
- * (`--run <raiz>`), que chama o CLI. Só a raiz: o worker nasce com `cwd` no git common dir
- * e nunca segura o diretório de uma worktree.
- *
- * Fail-open em tudo. `MORPH_WORKTREE_REAP=0` desliga.
- *
- * @module agent-reap
- */
+// O SessionStart tem 5 s: o disparo só olha o disco e solta um worker DESTACADO
+// com `cwd` no git common dir, que nunca segura o diretório de uma worktree.
 
 import { spawn } from 'child_process';
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'fs';
@@ -29,7 +19,6 @@ function anyEntry(dir, pattern) {
   try { return readdirSync(dir).some((name) => pattern.test(name)); } catch { return false; }
 }
 
-/** Uma worktree de agent registrada, ou uma branch `morph-task/agent-*` (solta ou empacotada). */
 export function hasAgentLeftovers(common) {
   if (anyEntry(join(common, 'worktrees'), ADMIN_DIR)) return true;
   if (anyEntry(join(common, 'refs', 'heads', 'morph-task'), AGENT_BRANCH_FILE)) return true;
@@ -49,10 +38,6 @@ function recentlyKicked(marker, now) {
   }
 }
 
-/**
- * @param {string} dir - diretório do projeto da sessão
- * @returns {{ kicked: boolean, reason?: string, pid?: number }}
- */
 export function kickAgentReap(dir, { spawnFn = spawn, env = process.env, now = Date.now } = {}) {
   if (env.MORPH_WORKTREE_REAP === '0') return { kicked: false, reason: 'disabled' };
   const common = resolveGitCommonDir(dir);

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

@@ -1,12 +1,3 @@
-/**
- * Build/Typecheck verification utility.
- *
- * Stack-aware: determines the correct build command(s) based on project stack.
- * Used by the Stop hook and `morph-spec verify` to verify code health.
- *
- * Pure functions — no I/O except the actual build execution.
- */
-
 import { execSync } from 'child_process';
 import { existsSync } from 'fs';
 import { join } from 'path';
@@ -14,7 +5,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');
 }
 
@@ -22,25 +13,8 @@ function isFrontendStack(s) {
   return s.includes('nextjs') || s.includes('node') || s.includes('react') || s.includes('vue');
 }
 
-/**
- * Determine the build command for a SINGLE (non-monorepo) stack string.
- *
- * Kept for backward compatibility with single-stack projects and existing
- * callers. A monorepo stack that mixes a frontend token with "dotnet" (e.g.
- * the detector's own `${frontendStack}+dotnet` format, or a hyphenated
- * `dotnet-nextjs`) should resolve through `getBuildSteps()` instead: this
- * function alone can only ever return ONE command, and — because it checks
- * `dotnet` before the frontend tokens — a compound stack always resolves to
- * `dotnet build` even when the frontend is what actually needs checking (or
- * when there's no root-level `.sln`/`.csproj`, e.g. in a monorepo where the
- * backend lives in a subfolder). `getBuildSteps()` runs BOTH sides, each
- * from its own working directory, instead of one command winning by
- * substring match order.
- *
- * @param {string} stack - Project stack (e.g., 'dotnet-nextjs', 'nextjs')
- * @param {boolean} [hasTsConfig] - Whether tsconfig.json exists (for TS projects)
- * @returns {string|null} Build command or null if no check available
- */
+// Single stack only: a compound stack resolves to `dotnet build` alone. Use
+// `getBuildSteps()` for those.
 export function getBuildCommand(stack, hasTsConfig = false) {
   if (!stack) return null;
   const s = stack.toLowerCase();
@@ -56,38 +30,21 @@ export function getBuildCommand(stack, hasTsConfig = false) {
   return null;
 }
 
-/**
- * Resolve the build step(s) to run for a project, monorepo-aware.
- *
- * A monorepo stack mixes a frontend token and "dotnet" (see
- * `detectProject()`'s own `${frontendStack}+dotnet` format) — in that case
- * BOTH sides are checked, each from its own working directory
- * (`frontendPath` / `backendPath`, as stored in
- * `.morph/config/config.json → project`), instead of one command silently
- * winning — or running from the wrong cwd — by substring match order.
- * Single-stack projects (no `frontendPath`/`backendPath`, or a stack that
- * only matches one side) resolve to exactly one step, from `cwd`, matching
- * `getBuildCommand()`'s existing single-stack behavior.
- *
- * @param {string} stack
- * @param {{ cwd: string, frontendPath?: string, backendPath?: string }} opts
- * @returns {Array<{ command: string, cwd: string }>}
- */
-export function getBuildSteps(stack, { cwd, frontendPath, backendPath } = {}) {
+// A compound stack checks BOTH sides, each from its own directory.
+// `backendTarget` names the solution when the backend directory holds none.
+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)) {
     const frontendDir = frontendPath ? join(cwd, frontendPath) : cwd;
-    // node_modules guard : a fresh worktree before
-    // `morph-spec worktree link` has tsconfig.json (versioned) but no toolchain — running
-    // `npx tsc` there fetches an unrelated "tsc" package and fails noisily. No toolchain →
-    // no tsc step; the real typecheck runs wherever node_modules exists (root/CI).
+    // Without node_modules, `npx tsc` fetches an unrelated "tsc" package.
     if (
       existsSync(join(frontendDir, 'tsconfig.json')) &&
       existsSync(join(frontendDir, 'node_modules'))
@@ -99,41 +56,19 @@ export function getBuildSteps(stack, { cwd, frontendPath, backendPath } = {}) {
   return steps;
 }
 
-/**
- * Parse build command result into a structured object.
- *
- * @param {number} exitCode - Process exit code (0 = success)
- * @param {string} output - stdout+stderr from build
- * @returns {{ status: 'pass'|'fail', output: string }}
- */
 export function parseBuildResult(exitCode, output) {
   const trimmed = (output || '').trim();
   if (exitCode === 0) {
     return { status: 'pass', output: '' };
   }
-  // Truncate to last 20 lines
   const lines = trimmed.split('\n');
   const truncated = lines.slice(-20).join('\n');
   return { status: 'fail', output: truncated };
 }
 
-/**
- * Run build check for a project — monorepo-aware (see `getBuildSteps()`).
- *
- * For a compound stack (e.g. "nextjs+dotnet"), runs each resolved step in
- * its own working directory and fails if any step fails; output from all
- * failing steps is concatenated (prefixed by the command that produced it)
- * so a frontend typecheck failure and a backend build failure are never
- * silently masked by one another.
- *
- * @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
- * @returns {{ status: 'pass'|'fail'|'skip', output: string }}
- */
+/** @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 = [];