@polymorphism-tech/morph-spec 8.15.1 → 8.16.0

package/framework/hooks/shared/state-writer.js

@@ -12,6 +12,7 @@
 
 import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
+import { clearStateCache } from './state-reader.js';
 
 const STATE_FILE = '.morph/state.json';
 const STATE_VERSION = '5.0.0';
@@ -73,6 +74,21 @@ export function persistFeature(featureName, feature, projectPath) {
     root.metadata = root.metadata || {};
     root.metadata.totalFeatures = Object.keys(root.features).length;
     atomicWriteJson(statePath, root);
+
+    // R1's loadState() memoizes per projectPath for the lifetime of the
+    // process. That was always safe when every hook was its own short-lived
+    // process (README history), but core/chain.js now runs multiple hooks
+    // — e.g. state-sync then gate-guard — IN ONE process. Without this,
+    // a loadState() call earlier in that same process (state-sync's
+    // handleWriteEdit reads via loadState before this write) would leave a
+    // stale snapshot cached, and gate-guard's loadState() right after this
+    // write would silently read the PRE-write state instead of what was
+    // just persisted — inverting the "gate-guard runs after state-sync so it
+    // sees the gate state-sync just recorded" ordering guarantee the
+    // registry comment documents. Invalidating here (the one place
+    // feature.json/state.json are actually written) covers every current
+    // and future caller, not just this one chain.
+    clearStateCache();
     return true;
   } catch {
     return false;

package/framework/skills/core/create-umbraco-lp/SKILL.md

@@ -4,7 +4,7 @@ description: Guia a criação de uma landing page nova ponta-a-ponta a partir do
 version: core
 when-to-invoke: ao iniciar um novo projeto de LP com o template Umbraco genérico
 user-invokable: true
-cliVersion: "8.15.1"
+cliVersion: "8.16.0"
 ---
 
 # create-umbraco-lp

package/framework/skills/core/migrate-lp-to-umbraco/SKILL.md

@@ -4,7 +4,7 @@ description: Migra uma landing page existente (React/Vite, Next.js estático ou
 version: core
 when-to-invoke: ao receber instrução "use /migrate-lp-to-umbraco {projeto}" do usuário, ou quando o usuário descrever necessidade de migrar uma LP para Umbraco
 user-invokable: true
-cliVersion: "8.15.1"
+cliVersion: "8.16.0"
 ---
 
 # migrate-lp-to-umbraco

package/framework/skills/core/morph-apply/SKILL.md

@@ -4,7 +4,7 @@ description: Orquestra a execução autônoma de tasks de uma feature morph-spec
 version: core
 when-to-invoke: após Gate 2 aprovado, ao receber instrução "use /morph-apply" ou "implementar feature"
 user-invokable: true
-cliVersion: "8.15.1"
+cliVersion: "8.16.0"
 ---
 
 # morph-apply

package/framework/skills/core/morph-brainstorming/SKILL.md

@@ -4,7 +4,7 @@ description: Entende o negócio, os usuários e a arquitetura antes de qualquer
 version: core
 when-to-invoke: ao receber um novo request de feature, antes de morph-plan
 user-invokable: true
-cliVersion: "8.15.1"
+cliVersion: "8.16.0"
 ---
 
 # morph-brainstorming

package/framework/skills/core/morph-eval/SKILL.md

@@ -4,7 +4,7 @@ description: Avalia a qualidade de uma tarefa ou fase com rubricas graduadas 0-1
 version: core
 when-to-invoke: ao completar uma tarefa ou ao finalizar uma fase de implementação
 user-invokable: false
-cliVersion: "8.15.1"
+cliVersion: "8.16.0"
 ---
 
 # morph-eval

package/framework/skills/core/morph-hotfix/SKILL.md

@@ -4,7 +4,7 @@ description: ADW cirúrgico de hotfix — resolve uma queda/bug crítico de prod
 version: core
 when-to-invoke: ao receber "/morph-hotfix {feature}", quando a morph-proposal classifica o pedido como workType hotfix (Passo 0), ou o usuário diz "produção caiu / hotfix / urgente"
 user-invokable: true
-cliVersion: "8.15.1"
+cliVersion: "8.16.0"
 ---
 
 # morph-hotfix

package/framework/skills/core/morph-implement/SKILL.md

@@ -4,7 +4,7 @@ description: Guia a execução de cada tarefa de implementação com standard e
 version: core
 when-to-invoke: ao iniciar cada task de implementação listada em tasks.json
 user-invokable: false
-cliVersion: "8.15.1"
+cliVersion: "8.16.0"
 ---
 
 # morph-implement

package/framework/skills/core/morph-plan/SKILL.md

@@ -4,7 +4,7 @@ description: Guia a produção dos artefatos de planejamento de uma feature (use
 version: core
 when-to-invoke: ao iniciar a fase plan de uma feature, após o Gate 1 (proposal aprovado)
 user-invokable: true
-cliVersion: "8.15.1"
+cliVersion: "8.16.0"
 ---
 
 # morph-plan

package/framework/skills/core/morph-proposal/SKILL.md

@@ -4,7 +4,7 @@ description: Orquestra a fase de proposta+plano de uma feature morph-spec. Encad
 version: core
 when-to-invoke: ao receber instrução "use /morph-proposal" do usuário, ou ao iniciar uma nova feature
 user-invokable: true
-cliVersion: "8.15.1"
+cliVersion: "8.16.0"
 ---
 
 # morph-proposal

package/framework/skills/core/morph-review/SKILL.md

@@ -4,7 +4,7 @@ description: Conduz a fase de revisão e produz o review-report.md para o Gate 3
 version: core
 when-to-invoke: ao iniciar a fase review, após todas as tasks de tasks.json estarem com status `done`
 user-invokable: true
-cliVersion: "8.15.1"
+cliVersion: "8.16.0"
 ---
 
 # morph-review

package/framework/skills/core/morph-stack-scan/SKILL.md

@@ -4,7 +4,7 @@ description: Varre o codebase existente, detecta stack atual, compara com o stac
 version: core
 when-to-invoke: ao iniciar uma feature em projeto brownfield (codebase já existente)
 user-invokable: true
-cliVersion: "8.15.1"
+cliVersion: "8.16.0"
 ---
 
 # morph-stack-scan

package/framework/skills/core/morph-standards/SKILL.md

@@ -4,7 +4,7 @@ description: Localiza e carrega um standard específico do STANDARDS.json sob de
 version: core
 when-to-invoke: quando precisar consultar um standard específico durante a implementação
 user-invokable: true
-cliVersion: "8.15.1"
+cliVersion: "8.16.0"
 ---
 
 # morph-standards

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "8.15.1",
+  "version": "8.16.0",
   "description": "MORPH-SPEC: NLH (Natural Language Harness) for spec-driven development with Claude Code",
   "keywords": [
     "claude-code",

package/src/commands/observability/cost.js

@@ -0,0 +1,137 @@
+/**
+ * `morph-spec cost [feature] [--by task|phase] [--json]`
+ *
+ * A cost-facing view over the same harness event stream `telemetry` reads
+ * (.morph/logs/events.jsonl): how much wall-clock time was spent inside
+ * measured tasks (TaskStart→TaskEnd), how many context bytes were
+ * re-ingested (grouped by kind: rubric/standard/skill/agents/plan-artifact/
+ * code), and how many sub-agent dispatches happened (with total prompt
+ * chars).
+ *
+ * IMPORTANT: bytes re-ingested is a DETERMINISTIC PROXY for cost, not a
+ * token count. Hooks only see what tools read off disk — never the model's
+ * actual token usage — so this measures re-ingestion pressure, not spend.
+ *
+ * Read-only, always exits 0 on a normal (even empty) run — fail-open, an
+ * empty stream is an answer, not an error. Only `--by` with an unknown value
+ * is a usage error (exit 1).
+ */
+
+import chalk from 'chalk';
+import { loadTelemetry, aggregateCost } from '../../lib/telemetry/telemetry-reader.js';
+
+const BYTES_CAVEAT =
+  'Bytes re-ingeridos são um PROXY determinístico de custo (o que as ferramentas leram do disco) — NÃO são tokens reais. Hooks não enxergam o uso real de tokens do modelo.';
+
+const BY_MODES = ['task', 'phase'];
+
+function fmtBytes(n) {
+  if (!n) return '0 B';
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+
+function fmtDuration(s) {
+  if (s === null || s === undefined) return '-';
+  if (s < 60) return `${s.toFixed(1)}s`;
+  const m = Math.floor(s / 60);
+  const rem = Math.round(s % 60);
+  return `${m}m${rem}s`;
+}
+
+function printBytesByKind(bytesByKind) {
+  const entries = Object.entries(bytesByKind);
+  if (!entries.length) {
+    console.log(chalk.gray('    (0 bytes re-ingeridos — nenhum Read com bytes/kind neste escopo)'));
+    return;
+  }
+  for (const [kind, bytes] of entries.sort((a, b) => b[1] - a[1])) {
+    console.log(`    ${chalk.yellow(kind.padEnd(14))} ${fmtBytes(bytes)}`);
+  }
+}
+
+function printTasks(tasks) {
+  if (!tasks.length) {
+    console.log(chalk.gray('\nNenhuma task com TaskStart/TaskEnd capturada.'));
+    return;
+  }
+  for (const t of tasks) {
+    const status = t.open ? chalk.yellow('[em aberto]') : (t.status || '-');
+    console.log('\n' + chalk.white.bold(`Task ${t.task}`) + chalk.gray(` · ${t.feature ?? '(sem feature)'}`) + ` · ${status}`);
+    console.log(`  duração: ${fmtDuration(t.durationSeconds)}`);
+    console.log(`  dispatches: ${t.dispatches.count} (${t.dispatches.promptChars} chars de prompt)`);
+    console.log('  bytes re-ingeridos por kind:');
+    printBytesByKind(t.bytesByKind);
+  }
+}
+
+function printPhases(phases) {
+  if (!phases.length) {
+    console.log(chalk.gray('\nNenhum byte de Read com phase capturado.'));
+    return;
+  }
+  for (const p of phases) {
+    console.log('\n' + chalk.white.bold(`Fase ${p.phase}`) + chalk.gray(` · ${fmtBytes(p.bytesTotal)} total`));
+    printBytesByKind(p.bytesByKind);
+  }
+}
+
+function printSummary(summary) {
+  console.log(`\n  duração dentro de tasks medidas: ${fmtDuration(summary.taskDurationSeconds)}`);
+  console.log(`  dispatches: ${summary.dispatches.count} (${summary.dispatches.promptChars} chars de prompt)`);
+
+  console.log('\n' + chalk.white.bold('Bytes re-ingeridos por kind') + ` (${fmtBytes(summary.bytesTotal)} total)`);
+  printBytesByKind(summary.bytesByKind);
+
+  if (summary.tools.length) {
+    console.log('\n' + chalk.white.bold('Mix de tools'));
+    for (const t of summary.tools) console.log(`  ${t.name.padEnd(16)} ${t.count}`);
+  }
+}
+
+/**
+ * @param {string} [feature] - narrow to a single feature
+ * @param {{ json?: boolean, by?: 'task'|'phase', cwd?: string }} [options]
+ */
+export function costCommand(feature, options = {}) {
+  if (options.by && !BY_MODES.includes(options.by)) {
+    console.error(chalk.red(`\n❌ Invalid --by: "${options.by}"`));
+    console.error(chalk.gray(`Valid modes: ${BY_MODES.join(', ')}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  const events = loadTelemetry(options.cwd || process.cwd());
+  const summary = aggregateCost(events, { feature });
+
+  if (options.json) {
+    // No forced process.exit() here: on Windows a piped stdout write is
+    // async, and exit()ing right after a large console.log can race the
+    // flush and truncate output. Letting the event loop drain naturally
+    // (nothing else keeps it alive in this command) exits 0 without risk.
+    console.log(JSON.stringify(summary));
+    return;
+  }
+
+  if (summary.total === 0) {
+    const scope = feature ? ` para a feature "${feature}"` : '';
+    console.log(chalk.gray(`Telemetria vazia${scope} — nenhum evento capturado ainda em .morph/logs/events.jsonl.`));
+    return;
+  }
+
+  const scope = feature ? chalk.cyan(` · feature ${feature}`) : '';
+  console.log(chalk.white.bold(`Custo do harness (proxy determinística) — ${summary.total} eventos${scope}`));
+  console.log(chalk.gray(`⚠ ${BYTES_CAVEAT}`));
+  if (summary.features.length) {
+    console.log(chalk.gray(`Features: ${summary.features.join(', ')}`));
+  }
+
+  if (options.by === 'task') {
+    printTasks(summary.tasks);
+  } else if (options.by === 'phase') {
+    printPhases(summary.phases);
+  } else {
+    printSummary(summary);
+  }
+}

package/src/commands/state/approve.js

@@ -283,17 +283,38 @@ export async function approveCommand(featureName, gateName, options = {}) {
 
     let selfAssessed = false;
     if (gateName === 'review') {
-      const evaluatorReport = join(process.cwd(), '.morph', 'features', featureName, '4-review', 'evaluator-report.md');
-      if (!existsSync(evaluatorReport)) {
-        if (!options.selfAssessed) {
-          console.error(chalk.red('\n❌ Gate 3 exige o avaliador independente — `4-review/evaluator-report.md` não existe.'));
-          console.error(chalk.gray('   O score composto da feature vem do avaliador (persona `evaluator`, contexto fresco)'));
-          console.error(chalk.gray('   despachado pela morph-review, nunca de auto-avaliação de quem implementou.'));
-          console.error(chalk.gray('   Se o dispatch for impossível nesta sessão, aprove com --self-assessed —'));
-          console.error(chalk.gray('   a degradação fica registrada no feature.json e aparece no `list`/`fleet`.\n'));
+      if (feature.workType === 'hotfix') {
+        // Hotfix Gate 3 does NOT require the independent evaluator: `morph-hotfix`
+        // (SKILL.md §7) never dispatches `morph-evaluator` — speed over ceremony
+        // is the point of a hotfix — and instead writes `4-review/review-report.md`
+        // (diff + real test evidence) before asking the human to approve. Requiring
+        // evaluator-report.md here made the skill's own documented flow unable to
+        // clear its own Gate 3 (the only escape was --self-assessed, which stamps
+        // a degradation for a report that was never supposed to exist). The human
+        // signature is already enforced above (line ~215) — this only checks the
+        // artifact the skill actually produces.
+        const reviewReport = join(process.cwd(), '.morph', 'features', featureName, '4-review', 'review-report.md');
+        if (!existsSync(reviewReport)) {
+          console.error(chalk.red('\n❌ Gate 3 de hotfix exige `4-review/review-report.md` — não existe.'));
+          console.error(chalk.gray('   É o artefato que a `morph-hotfix` produz (diff do fix + evidência real de'));
+          console.error(chalk.gray('   teste do `morph-spec verify`), não o `evaluator-report.md` do avaliador'));
+          console.error(chalk.gray('   independente — hotfix nunca despacha o avaliador. Escreva o relatório antes'));
+          console.error(chalk.gray('   de aprovar; a assinatura humana já é exigida pelo backstop acima.\n'));
           process.exit(1);
         }
-        selfAssessed = true;
+      } else {
+        const evaluatorReport = join(process.cwd(), '.morph', 'features', featureName, '4-review', 'evaluator-report.md');
+        if (!existsSync(evaluatorReport)) {
+          if (!options.selfAssessed) {
+            console.error(chalk.red('\n❌ Gate 3 exige o avaliador independente — `4-review/evaluator-report.md` não existe.'));
+            console.error(chalk.gray('   O score composto da feature vem do avaliador (persona `evaluator`, contexto fresco)'));
+            console.error(chalk.gray('   despachado pela morph-review, nunca de auto-avaliação de quem implementou.'));
+            console.error(chalk.gray('   Se o dispatch for impossível nesta sessão, aprove com --self-assessed —'));
+            console.error(chalk.gray('   a degradação fica registrada no feature.json e aparece no `list`/`fleet`.\n'));
+            process.exit(1);
+          }
+          selfAssessed = true;
+        }
       }
     }
 

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

@@ -63,8 +63,17 @@ export function hookRegistrations(definitions = getHookDefinitions()) {
     for (const h of def.hooks || []) {
       const file = basename(String(h.command || '').trim());
       if (!file.endsWith('.js')) continue;
-      if (!byFile.has(file)) byFile.set(file, []);
-      byFile.get(file).push({ event: key, rawEvent: def.event, matcher: def.matcher || null });
+      // Grupos consolidados apontam para chain.js com os hooks reais em
+      // `args` (base names, na ordem de execução) — registre cada elo, não o
+      // runner: é o elo que o Inspector precisa mostrar. chain.js em si não é
+      // um hook de domínio e ficaria como nó fantasma em todo evento.
+      const files = file === 'chain.js' && Array.isArray(h.args) && h.args.length
+        ? h.args.map(a => `${a}.js`)
+        : [file];
+      for (const f of files) {
+        if (!byFile.has(f)) byFile.set(f, []);
+        byFile.get(f).push({ event: key, rawEvent: def.event, matcher: def.matcher || null });
+      }
     }
   }
   return byFile;

package/src/lib/installers/memory-installer.js

@@ -87,7 +87,7 @@ metadata:
 - \`.morph/framework/schemas/tasks.schema.json\` — tasks.json schema reference
 - \`.morph/framework/phases.json\` — phase folder mapping and skill associations
 - \`.morph/framework/agents.json\` — domain persona definitions (dotnet-senior, ef-modeler, etc.)
-- \`.morph/framework/rubrics/\` — eval rubrics for morph-eval scoring
+- \`.morph/framework/evals/rubrics/\` — eval rubrics for morph-eval scoring (architecture/contracts/code-quality/test-coverage)
 `;
 
 /**

package/src/lib/telemetry/telemetry-reader.js

@@ -101,3 +101,216 @@ export function aggregateTelemetry(events, opts = {}) {
     features: [...features],
   };
 }
+
+// ─────────────────────────────────────────────────────────────────────────
+// Cost aggregation — sibling to aggregateTelemetry (kept separate rather than
+// folded in: aggregateTelemetry's return shape is pinned by
+// test/commands/telemetry.test.js, which spreads it wholesale into --json
+// output — adding fields there would leak into that contract).
+//
+// Turns the same raw event stream into a cost-facing view: how much
+// wall-clock time was spent inside measured tasks, how many context bytes
+// were re-ingested (by kind), and how many sub-agent dispatches happened
+// (and how many prompt chars they cost).
+//
+// "Bytes re-ingested" is a DETERMINISTIC PROXY for cost, not a token count —
+// hooks can only see what tools read off disk, never the model's actual
+// token usage. The `cost` command surfaces that caveat; this module only
+// computes the numbers.
+// ─────────────────────────────────────────────────────────────────────────
+
+// Sentinel used to key the open-task map when an event carries no feature
+// (e.g. telemetry-log's getActiveFeature() found none). Without this, a
+// TaskStart with feature: null would silently fail to open (map keyed on
+// undefined/null never matches itself across two different `null`-feature
+// pairs is fine, but `if (e.feature)` truthiness checks would just drop the
+// event) — keying explicitly avoids that class of "counter never increments"
+// bug.
+const NO_FEATURE = '\u0000no-feature';
+
+function featureKey(e) {
+  return e && e.feature ? e.feature : NO_FEATURE;
+}
+
+function tsToMs(ts) {
+  const t = Date.parse(ts);
+  return Number.isNaN(t) ? null : t;
+}
+
+/**
+ * Seconds between two ISO timestamps, rounded to millisecond precision to
+ * absorb float noise from the division. null if either ts is unparsable.
+ */
+function durationSeconds(startTs, endTs) {
+  const a = tsToMs(startTs);
+  const b = tsToMs(endTs);
+  if (a === null || b === null) return null;
+  return Math.round(((b - a) / 1000) * 1000) / 1000;
+}
+
+function mapToObj(map) {
+  const out = {};
+  for (const key of [...map.keys()].sort()) out[key] = map.get(key);
+  return out;
+}
+
+function sumValues(map) {
+  let total = 0;
+  for (const v of map.values()) total += v;
+  return total;
+}
+
+function newTaskState(feature, task, ts) {
+  return {
+    feature: feature ?? null,
+    task,
+    startTs: ts,
+    endTs: null,
+    status: null,
+    open: true,
+    tools: new Map(),
+    bytesByKind: new Map(),
+    dispatches: { count: 0, promptChars: 0 },
+  };
+}
+
+function finalizeTask(state) {
+  return {
+    feature: state.feature,
+    task: state.task,
+    startTs: state.startTs,
+    endTs: state.endTs,
+    durationSeconds: state.endTs ? durationSeconds(state.startTs, state.endTs) : null,
+    status: state.status,
+    open: state.open,
+    tools: rank(state.tools),
+    bytesByKind: mapToObj(state.bytesByKind),
+    bytesTotal: sumValues(state.bytesByKind),
+    dispatches: { ...state.dispatches },
+  };
+}
+
+/**
+ * Summarize an event stream for cost purposes: task segmentation (duration +
+ * per-task tool/byte/dispatch aggregates), bytes-re-ingested buckets by
+ * `kind` (global, per task, per phase), and sub-agent dispatch counts.
+ *
+ * Segmentation model: a task is "open" for a feature from its TaskStart
+ * event until the matching TaskEnd (same feature + task name). Only one task
+ * is assumed open per feature at a time — matches how the implement phase
+ * actually runs (auto-advance processes tasks sequentially, never two tasks
+ * of the same feature concurrently). Events for a feature with no open task
+ * simply don't attribute to any task (they still count toward the
+ * global/phase totals). A TaskEnd with no matching open TaskStart is ignored
+ * — a truncated stream or a legacy event mix never throws. A task left open
+ * at the end of the stream (TaskStart with no TaskEnd yet) is still reported,
+ * with `open: true` and `durationSeconds: null`, rather than silently
+ * dropped.
+ *
+ * Byte attribution keys off `typeof e.bytes === 'number'` alone (not a tool
+ * check) — today only Read events carry `bytes`, but this stays correct if
+ * that widens rather than reporting a silent 0.
+ *
+ * @param {Object[]} events - raw events (from loadTelemetry)
+ * @param {{ feature?: string }} [opts] - optional feature filter
+ * @returns {{
+ *   total: number,
+ *   features: string[],
+ *   taskDurationSeconds: number,
+ *   bytesByKind: Object<string, number>,
+ *   bytesTotal: number,
+ *   dispatches: {count:number, promptChars:number},
+ *   tools: Array<{name:string,count:number}>,
+ *   tasks: Array<Object>,
+ *   phases: Array<{phase:string, bytesByKind:Object<string,number>, bytesTotal:number}>,
+ * }}
+ */
+export function aggregateCost(events, opts = {}) {
+  const scoped = opts.feature
+    ? (events || []).filter(e => e.feature === opts.feature)
+    : (events || []);
+
+  const features = new Set();
+  const toolCounts = new Map();
+  const bytesByKindGlobal = new Map();
+  const dispatches = { count: 0, promptChars: 0 };
+  const phaseBytes = new Map(); // phase -> Map(kind -> bytes)
+  const activeByFeature = new Map(); // featureKey -> open task state
+  const tasks = [];
+
+  for (const e of scoped) {
+    if (!e || typeof e !== 'object') continue;
+    if (e.feature) features.add(e.feature);
+
+    if (e.event === 'TaskStart' && e.task) {
+      activeByFeature.set(featureKey(e), newTaskState(e.feature, e.task, e.ts));
+      continue;
+    }
+
+    if (e.event === 'TaskEnd' && e.task) {
+      const key = featureKey(e);
+      const state = activeByFeature.get(key);
+      if (state && state.task === e.task) {
+        state.endTs = e.ts;
+        state.status = e.status ?? null;
+        state.open = false;
+        activeByFeature.delete(key);
+        tasks.push(finalizeTask(state));
+      }
+      continue;
+    }
+
+    if (e.tool) toolCounts.set(e.tool, (toolCounts.get(e.tool) || 0) + 1);
+    const active = activeByFeature.get(featureKey(e));
+    if (active && e.tool) {
+      active.tools.set(e.tool, (active.tools.get(e.tool) || 0) + 1);
+    }
+
+    if (typeof e.bytes === 'number' && Number.isFinite(e.bytes)) {
+      const kind = e.kind || 'unknown';
+      bytesByKindGlobal.set(kind, (bytesByKindGlobal.get(kind) || 0) + e.bytes);
+      if (active) active.bytesByKind.set(kind, (active.bytesByKind.get(kind) || 0) + e.bytes);
+      if (e.phase) {
+        if (!phaseBytes.has(e.phase)) phaseBytes.set(e.phase, new Map());
+        const m = phaseBytes.get(e.phase);
+        m.set(kind, (m.get(kind) || 0) + e.bytes);
+      }
+    }
+
+    if ((e.tool === 'Agent' || e.tool === 'Task') && typeof e.prompt === 'string' && e.prompt) {
+      dispatches.count += 1;
+      dispatches.promptChars += e.prompt.length;
+      if (active) {
+        active.dispatches.count += 1;
+        active.dispatches.promptChars += e.prompt.length;
+      }
+    }
+  }
+
+  // Tasks still open when the stream ends (no TaskEnd observed yet) are
+  // reported, not dropped — see the "open" contract in the docstring above.
+  for (const state of activeByFeature.values()) tasks.push(finalizeTask(state));
+  tasks.sort((a, b) => (a.startTs || '').localeCompare(b.startTs || ''));
+
+  const phases = [...phaseBytes.entries()]
+    .map(([phase, kindMap]) => ({
+      phase,
+      bytesByKind: mapToObj(kindMap),
+      bytesTotal: sumValues(kindMap),
+    }))
+    .sort((a, b) => a.phase.localeCompare(b.phase));
+
+  const taskDurationSeconds = tasks.reduce((sum, t) => sum + (t.durationSeconds || 0), 0);
+
+  return {
+    total: scoped.length,
+    features: [...features],
+    taskDurationSeconds,
+    bytesByKind: mapToObj(bytesByKindGlobal),
+    bytesTotal: sumValues(bytesByKindGlobal),
+    dispatches,
+    tools: rank(toolCounts),
+    tasks,
+    phases,
+  };
+}