@polymorphism-tech/morph-spec 8.47.0 → 9.1.0

package/src/lib/telemetry/metrics.js

@@ -1,18 +1,5 @@
-/**
- * Loop measurements over the harness event stream: turns, tool calls split by
- * orchestrator and sub-agent, time per command class, identical reruns, file
- * rereads, feature-scope verify count, git calls per task and whether the
- * reuse validator ran. Computed the same way on every window so a later
- * window compares with an earlier one.
- *
- * Every number degrades to null ("not measurable here") when the stream lacks
- * the field it needs — a v1 event never counts as a zero.
- *
- * A rerun is the same producer command (what runs before the output filter:
- * `dotnet test | tail -25` then `| tail -20` is one test run twice) in the same
- * feature within 10 minutes of its previous run. `rate` counts the repeats;
- * `burstRate` counts every run that belongs to a burst, the first included.
- */
+// Every number degrades to null when the stream lacks its field: a v1 event never counts as a zero.
+// A rerun is the same producer command (before the output filter) in the same feature within 10 minutes.
 
 import { ingestedBytes } from './telemetry-reader.js';
 import { producerOf } from '../../../framework/hooks/shared/command-tokens.js';
@@ -25,26 +12,16 @@ const READ_ONLY = new Set(['grep', 'rg', 'sed', 'ls', 'cat', 'find', 'head', 'ta
 const TOOL_EVENTS = new Set(['PostToolUse', 'PostToolUseFailure']);
 const NO_FEATURE = '\u0000';
 
-/**
- * The command without quoted text and heredoc bodies: `morph-spec verify`
- * inside a commit message is not a verify run.
- */
+// `morph-spec verify` inside a commit message is not a verify run.
 function executedText(command) {
   const beforeHeredoc = command.split('<<', 1)[0];
   return beforeHeredoc.replace(/"(?:[^"\\]|\\.)*"|'[^']*'/g, (q) => q[0] + ' '.repeat(q.length - 2) + q[0]);
 }
 
-/**
- * Kind (fine) and class (coarse) of a shell command. Searched anywhere in the
- * command, most specific first, so `cd x && dotnet test` is a test.
- *
- * @param {string} command
- * @returns {{ kind: string, klass: string }}
- */
+/** Searched anywhere in the command, most specific first, so `cd x && dotnet test` is a test. */
 export function classifyCommand(command) {
   const cmd = String(command || '');
-  const verify = /\bmorph-spec(?:\.js)?\s+verify\s+[^\s;&|)]+(\s+T\d+\b)?/.exec(executedText(cmd));
-  if (verify) return { kind: verify[1] ? 'verify-task' : 'verify-feature', klass: 'verify' };
+  if (/\bmorph-spec(?:\.js)?\s+verify\s+[^\s;&|)]+/.test(executedText(cmd))) return { kind: 'verify', klass: 'verify' };
   if (/\bdotnet\s+test\b/.test(cmd)) {
     if (/--list-tests\b/.test(cmd)) return { kind: 'dotnet-test-list', klass: 'test' };
     return { kind: /--filter\b/.test(cmd) ? 'dotnet-test-filtered' : 'dotnet-test-full', klass: 'test' };
@@ -121,11 +98,8 @@ function finishCounters(c, turnsObserved) {
   };
 }
 
-/**
- * Why a command ran again within the window. Edits in between and a changed
- * output filter need no exit code; the pass/fail split does, so a masked or v1
- * exit code falls back to "after an edit or not".
- */
+// Edits in between and a changed output filter need no exit code; the pass/fail split does, so a masked
+// or v1 exit code falls back to "after an edit or not".
 function rerunClass(prev, current, editsBetween) {
   if (isV2(prev) && prev.outcome === 'timeout') return 'timeout';
   if (editsBetween === 0 && prev.command !== current.command) return 'refilter';
@@ -148,19 +122,13 @@ function reuseStateOf(e) {
   return { state: 'absent', reason: null };
 }
 
-/**
- * @param {Object[]} events - deduplicated, time-ordered (loadTelemetry)
- * @param {{ feature?: string, top?: number }} [opts]
- * @returns {Object} see framework/docs/CLI.md, "cost --metrics"
- */
+/** The returned shape is documented in framework/docs/CLI.md, "cost --metrics". */
 export function computeMetrics(events, opts = {}) {
   const top = Number.isInteger(opts.top) && opts.top > 0 ? opts.top : 10;
   const scoped = (events || []).filter((e) => e && typeof e === 'object' && (!opts.feature || e.feature === opts.feature));
 
   const global = newCounters();
   const byFeature = new Map();
-  const openTask = new Map();
-  const tasks = [];
   const lastRun = new Map();
   const editCount = new Map();
   const readsSeen = new Set();
@@ -172,8 +140,6 @@ export function computeMetrics(events, opts = {}) {
   const lastFingerprint = new Map();
   const unchangedRepeats = {};
   const reuse = { runs: 0, byTree: {}, skipReasons: {} };
-  const tasksOf = new Map();
-  let callsInTaskWindows = 0;
   let v2 = 0;
   let legacy = 0;
   let turnsObserved = false;
@@ -184,16 +150,6 @@ export function computeMetrics(events, opts = {}) {
     if (!byFeature.has(key)) byFeature.set(key, newCounters());
     return byFeature.get(key);
   };
-  const closeTask = (key, endTs, status) => {
-    const task = openTask.get(key);
-    if (!task) return;
-    openTask.delete(key);
-    task.endTs = endTs;
-    task.status = status;
-    task.open = endTs === null;
-    tasks.push(task);
-  };
-
   for (const e of scoped) {
     if (isV2(e)) v2 += 1; else legacy += 1;
     if (e.ts) {
@@ -202,21 +158,7 @@ export function computeMetrics(events, opts = {}) {
     }
     const fkey = e.feature || NO_FEATURE;
 
-    if (e.event === 'TaskStart' && e.task) {
-      if (!tasksOf.has(fkey)) tasksOf.set(fkey, new Set());
-      tasksOf.get(fkey).add(e.task);
-      closeTask(fkey, null, null);
-      openTask.set(fkey, { feature: e.feature ?? null, task: e.task, startTs: e.ts, endTs: null, status: null, open: true, c: newCounters() });
-      continue;
-    }
-    if (e.event === 'TaskEnd' && e.task) {
-      if (openTask.get(fkey)?.task === e.task) closeTask(fkey, e.ts, e.status ?? null);
-      continue;
-    }
-
     const sinks = [global, featureCounters(fkey)];
-    const task = openTask.get(fkey);
-    if (task) sinks.push(task.c);
 
     if (e.event === 'ToolBatch') {
       turnsObserved = true;
@@ -225,7 +167,7 @@ export function computeMetrics(events, opts = {}) {
     }
 
     if (e.event === 'Verify') {
-      if (e.scope === 'feature' && e.fingerprint && e.persisted !== false) {
+      if (e.fingerprint && e.persisted !== false) {
         if (lastFingerprint.get(fkey) === e.fingerprint) {
           unchangedRepeats[e.feature || '(sem feature)'] = (unchangedRepeats[e.feature || '(sem feature)'] || 0) + 1;
         }
@@ -242,7 +184,6 @@ export function computeMetrics(events, opts = {}) {
 
     if (!TOOL_EVENTS.has(e.event) || !e.tool) continue;
     for (const c of sinks) { c.toolCalls.total += 1; c.toolCalls[whoOf(e)] += 1; }
-    if (task) callsInTaskWindows += 1;
 
     if (e.tool === 'Write' || e.tool === 'Edit') {
       if (!isFailedToolCall(e)) editCount.set(fkey, (editCount.get(fkey) || 0) + 1);
@@ -288,8 +229,8 @@ export function computeMetrics(events, opts = {}) {
     }
 
     if (klass === 'verify') {
-      const slot = verifyByFeature[e.feature || '(sem feature)'] ||= { feature: 0, task: 0 };
-      slot[kind === 'verify-feature' ? 'feature' : 'task'] += 1;
+      const name = e.feature || '(sem feature)';
+      verifyByFeature[name] = (verifyByFeature[name] || 0) + 1;
     }
 
     if (!RERUN_CLASSES.has(klass) || typeof e.command !== 'string') continue;
@@ -318,34 +259,15 @@ export function computeMetrics(events, opts = {}) {
     lastRun.set(runKey, run);
   }
 
-  for (const key of [...openTask.keys()]) closeTask(key, null, null);
-  tasks.sort((a, b) => String(a.startTs).localeCompare(String(b.startTs)));
-
-  const taskRows = tasks.map((t) => ({
-    feature: t.feature,
-    task: t.task,
-    startTs: t.startTs,
-    endTs: t.endTs,
-    open: t.open,
-    status: t.status,
-    ...finishCounters(t.c, turnsObserved),
-  }));
-
   const featureRows = [...byFeature.entries()]
     .filter(([key]) => key !== NO_FEATURE)
     .map(([feature, c]) => ({
       feature,
       ...finishCounters(c, turnsObserved),
-      verify: verifyByFeature[feature] || { feature: 0, task: 0 },
+      verify: verifyByFeature[feature] || 0,
     }))
     .sort((a, b) => b.toolCalls.total - a.toolCalls.total || a.feature.localeCompare(b.feature));
 
-  // A task window only holds what ran between its TaskStart and TaskEnd, and
-  // a parallel batch or a late `in_progress` leaves most calls outside any
-  // window. Dividing each feature's totals by its task count needs no window.
-  const perTaskOfFeature = (pick) => median(featureRows
-    .filter((f) => tasksOf.has(f.feature))
-    .map((f) => Math.round((pick(f) / tasksOf.get(f.feature).size) * 10) / 10));
   const byKind = {};
   for (const [kind, slot] of Object.entries(rerunByKind)) {
     byKind[kind] = { ...slot, rate: rate(slot.reruns, slot.runs), burstRate: rate(slot.inBursts, slot.runs) };
@@ -364,23 +286,11 @@ export function computeMetrics(events, opts = {}) {
       .slice(0, top),
     verify: {
       byFeature: verifyByFeature,
-      featureScopeMedian: median(featureRows.map((f) => f.verify.feature).filter((n) => n > 0)),
+      median: median(featureRows.map((f) => f.verify).filter((n) => n > 0)),
       unchangedRepeats,
     },
-    gitPerTaskMedian: {
-      status: median(taskRows.map((t) => t.git.status)),
-      diff: median(taskRows.map((t) => t.git.diff)),
-    },
-    turnsPerTaskMedian: turnsObserved ? median(taskRows.map((t) => t.turns.total)) : null,
-    taskWindowCoverage: rate(callsInTaskWindows, global.toolCalls.total),
-    perTaskByFeature: {
-      git: perTaskOfFeature((f) => f.git.status + f.git.diff),
-      toolCalls: perTaskOfFeature((f) => f.toolCalls.total),
-      turns: turnsObserved ? perTaskOfFeature((f) => f.turns.total) : null,
-    },
     dotnetFullSuite: fullSuite,
     reuse,
     features: featureRows,
-    tasks: taskRows,
   };
 }

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

@@ -1,14 +1,3 @@
-/**
- * Telemetry aggregation — reads the append-only harness event stream
- * (.morph/logs/events.jsonl, written by the telemetry-log hook) and summarizes
- * the whole execution path: which skills ran, which personas were dispatched,
- * which standards (knowledge base) were read, the tool mix, and the prompts.
- *
- * Pure aggregation (`aggregateTelemetry`) is separated from disk I/O
- * (`loadTelemetry`) so the summary logic is unit-testable without fixtures —
- * the same split fleet-scanner uses. CLI-side; runs in the target project cwd.
- */
-
 import { readFileSync, existsSync, readdirSync } from 'fs';
 import { join, basename } from 'path';
 import { parseWorktreeList, resolvePrimaryRoot } from '../../commands/project/worktree.js';
@@ -21,11 +10,8 @@ const EVENTS_LOG = /^events(-.+)?\.jsonl$/;
 // Caches a finish backup may hold; none of them contains a log.
 const BACKUP_SKIP_DIRS = new Set(['node_modules', '.next', 'bin', 'obj', 'TestResults', 'graphify-out', '.git']);
 
-/**
- * The same line reaches the reader through the live log, its rotated archives
- * and every finish backup that copied it. v2 events carry an `eventId`; a v1
- * event is identical only to a byte-identical copy of itself.
- */
+// The same line arrives through the live log, its rotated archives and every finish backup. v2 events
+// carry an `eventId`; a v1 event is identical only to a byte-identical copy of itself.
 function dedupeKey(event) {
   return event.eventId ? `id:${event.eventId}` : `raw:${JSON.stringify(event)}`;
 }
@@ -35,13 +21,7 @@ function eventTime(event) {
   return Number.isNaN(t) ? 0 : t;
 }
 
-/**
- * Collapse copies of the same event and restore time order across sources.
- * The sort is stable, so events sharing a timestamp keep their write order.
- *
- * @param {Object[]} events
- * @returns {Object[]}
- */
+/** Stable sort, so events sharing a timestamp keep their write order. */
 export function dedupeEvents(events) {
   const seen = new Set();
   const out = [];
@@ -61,9 +41,9 @@ function readJsonlFile(path, out) {
     for (const line of readFileSync(path, 'utf-8').split('\n')) {
       const trimmed = line.trim();
       if (!trimmed) continue;
-      try { out.push(JSON.parse(trimmed)); } catch { /* skip corrupt line */ }
+      try { out.push(JSON.parse(trimmed)); } catch {}
     }
-  } catch { /* unreadable file contributes nothing */ }
+  } catch {}
 }
 
 function archiveFiles(sessionsDir) {
@@ -77,15 +57,7 @@ function archiveFiles(sessionsDir) {
   }
 }
 
-/**
- * Read the event stream of a project root: the live log plus, by default, the
- * archives SessionStart rotated into `.morph/logs/sessions/` — reading only the
- * live file loses everything older than the last 5 MB.
- *
- * @param {string} [projectPath]
- * @param {{ archives?: boolean }} [options]
- * @returns {Object[]} deduplicated, in time order; [] when there is no log
- */
+/** Live log plus, by default, the rotated archives: the live file alone loses everything past 5 MB. */
 export function loadTelemetry(projectPath, { archives = true } = {}) {
   const root = projectPath || process.cwd();
   const events = [];
@@ -108,14 +80,7 @@ function collectBackupLogs(dir, depth, out) {
   }
 }
 
-/**
- * Event logs that `finish` saved under `<git-common-dir>/morph-spec/finish-backup/`
- * before tearing a worktree down — once the worktree is gone, a feature built
- * there leaves its telemetry nowhere else.
- *
- * @param {string} [cwd]
- * @returns {{ path: string, events: Object[] }|null}
- */
+/** Logs `finish` saved before tearing a worktree down: once it is gone, they are the feature's only telemetry. */
 export function loadFinishBackupTelemetry(cwd = process.cwd()) {
   const common = resolveGitCommonDir(cwd);
   if (!common) return null;
@@ -128,19 +93,7 @@ export function loadFinishBackupTelemetry(cwd = process.cwd()) {
   return { path: base, events: dedupeEvents(events) };
 }
 
-/**
- * Every git worktree that has its OWN `.morph/logs/events.jsonl` — the source
- * of `cost --all-trees` — plus a `finish-backup` entry for worktrees already
- * torn down. Reuses the worktree enumeration of `doctor --worktrees`/`fleet`.
- *
- * The PRIMARY worktree is labeled `'root'`; every other entry by its directory
- * basename (typically the feature slug). A tree that never ran the harness
- * contributes nothing. Outside a git repo this degrades to a single root
- * entry — never throws.
- *
- * @param {string} [cwd]
- * @returns {Array<{ tree: string, path: string, events: Object[] }>}
- */
+/** Labels the primary worktree `'root'`, the others by directory basename. Outside git, a single root entry. */
 export function loadTelemetryAllTrees(cwd = process.cwd()) {
   const root = resolvePrimaryRoot(cwd);
   const entries = parseWorktreeList(root);
@@ -167,21 +120,6 @@ function rank(map) {
     .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
 }
 
-/**
- * Summarize an event stream.
- *
- * @param {Object[]} events - raw events (from loadTelemetry)
- * @param {{ feature?: string }} [opts] - optional feature filter
- * @returns {{
- *   total: number,
- *   skills: Array<{name:string,count:number}>,
- *   personas: Array<{name:string,count:number}>,
- *   standards: Array<{path:string,count:number}>,
- *   tools: Array<{name:string,count:number}>,
- *   prompts: Array<{ts:string,source:'user'|'agent',feature:?string,phase:?string,text:string}>,
- *   features: string[]
- * }}
- */
 export function aggregateTelemetry(events, opts = {}) {
   const scoped = opts.feature
     ? (events || []).filter(e => e.feature === opts.feature)
@@ -226,51 +164,8 @@ export function aggregateTelemetry(events, opts = {}) {
   };
 }
 
-// ─────────────────────────────────────────────────────────────────────────
-// 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;
-}
+// Kept apart from aggregateTelemetry: its return shape is spread into `telemetry --json`, so new fields
+// there would leak into that contract. Bytes re-ingested is a proxy for cost, never a token count.
 
 function mapToObj(map) {
   const out = {};
@@ -284,90 +179,8 @@ function sumValues(map) {
   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 prefers `bytesRead` (the line window a Read put in context)
- * and falls back to `bytes` (the file size — all v1 events have) — keyed off
- * the number alone, not the tool.
- *
- * Dispatch prompt size (Furo 3 — contract with the hooks-side telemetry-log
- * rewrite): a dispatch event's `prompt` field is now TRUNCATED to 2k chars on
- * write, with the original length carried separately as `promptChars`. When
- * `promptChars` (a number) is present it is preferred; a legacy stream that
- * only ever had the untruncated `prompt` string falls back to
- * `prompt.length`, unchanged from before — every existing byte count stays
- * exact against old logs.
- *
- * SessionUsage (main session) and AgentUsage (each sub-agent) are real token
- * counts, not the bytes proxy, and never touch toolCounts/bytesByKind/
- * dispatches. Only their `delta` is summed — the top-level numbers are a
- * running total repeated on every sample — so a v1 sample (no `delta`) is
- * counted in `sessionUsageLegacySamples` and never added in. Like any event
- * they obey the `--feature` filter. `sessionUsage`/`agentUsage` are `null`
- * when nothing summable was observed, never a zeroed object.
- *
- * @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},
- *   sessionUsage: {inputTokens:number, outputTokens:number, cacheReadTokens:number, cacheCreationTokens:number, sessions:number, samples:number}|null,
- *   sessionUsageLegacySamples: number,
- *   agentUsage: {inputTokens:number, outputTokens:number, cacheReadTokens:number, cacheCreationTokens:number, agents:number, samples:number}|null,
- *   tools: Array<{name:string,count:number}>,
- *   tasks: Array<Object>,
- *   phases: Array<{phase:string, bytesByKind:Object<string,number>, bytesTotal:number}>,
- * }}
- */
+// Prefers `promptChars` over `prompt.length`: the prompt is truncated on write. Session and agent usage sum
+// only their `delta`, never the running total; they are `null` when nothing summable was seen.
 const SESSION_USAGE_KEYS = ['inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheCreationTokens'];
 
 /** Bytes a Read put in context: its window when known, else the file size. */
@@ -387,9 +200,7 @@ export function aggregateCost(events, opts = {}) {
   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 = [];
+  const phaseBytes = new Map();
   const newUsageBucket = () => ({
     totals: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0 },
     ids: new Set(),
@@ -402,24 +213,6 @@ export function aggregateCost(events, opts = {}) {
     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.event === 'SessionUsage' || e.event === 'AgentUsage') {
       const bucket = e.event === 'SessionUsage' ? usage.session : usage.agent;
       // Only a delta can be summed: the top-level numbers are the transcript's
@@ -437,16 +230,11 @@ export function aggregateCost(events, opts = {}) {
     }
 
     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);
-    }
 
     const read = ingestedBytes(e);
     if (read !== null) {
       const kind = e.kind || 'unknown';
       bytesByKindGlobal.set(kind, (bytesByKindGlobal.get(kind) || 0) + read);
-      if (active) active.bytesByKind.set(kind, (active.bytesByKind.get(kind) || 0) + read);
       if (e.phase) {
         if (!phaseBytes.has(e.phase)) phaseBytes.set(e.phase, new Map());
         const m = phaseBytes.get(e.phase);
@@ -459,18 +247,9 @@ export function aggregateCost(events, opts = {}) {
       const chars = hasPromptChars ? e.promptChars : e.prompt.length;
       dispatches.count += 1;
       dispatches.promptChars += chars;
-      if (active) {
-        active.dispatches.count += 1;
-        active.dispatches.promptChars += chars;
-      }
     }
   }
 
-  // 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,
@@ -479,12 +258,9 @@ export function aggregateCost(events, opts = {}) {
     }))
     .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,
@@ -496,7 +272,6 @@ export function aggregateCost(events, opts = {}) {
       ? { ...usage.agent.totals, agents: usage.agent.ids.size, samples: usage.agent.samples }
       : null,
     tools: rank(toolCounts),
-    tasks,
     phases,
   };
 }

package/src/lib/telemetry/verify-event.js

@@ -1,22 +1,9 @@
-/**
- * The `Verify` telemetry event: one line per `morph-spec verify` run with the
- * scope, per-node status and duration, the commit it covered and whether the
- * reuse validator could run. The Bash event of the same command says who
- * called it and how long the whole command took; this one says what it did.
- */
-
 import { existsSync } from 'fs';
 import { join } from 'path';
 import { appendTelemetryEvent, readTelemetryEvents } from '../../../framework/hooks/shared/telemetry-logger.js';
 
 const NODE_NAMES = ['build', 'tests', 'validators', 'e2e'];
 
-/**
- * @param {Object} result - runVerify() output
- * @param {{ sha: string|null, tree: 'root'|'worktree', persisted: boolean, reason: string|null,
- *   fingerprint?: string|null, source?: 'local'|'ci' }} context
- * @returns {Object}
- */
 export function buildVerifyEvent(result, { sha, tree, persisted, reason, fingerprint = null, source = 'local' }) {
   const nodes = {};
   for (const name of NODE_NAMES) {
@@ -32,8 +19,6 @@ export function buildVerifyEvent(result, { sha, tree, persisted, reason, fingerp
   return {
     event: 'Verify',
     feature: result.feature,
-    task: result.task ?? null,
-    scope: result.scope,
     status: result.status,
     sha,
     fingerprint,
@@ -45,35 +30,20 @@ export function buildVerifyEvent(result, { sha, tree, persisted, reason, fingerp
   };
 }
 
-/**
- * The last complete run of the same verify (feature, task, scope) over the
- * same tree, or null. A partial run (`--filter`, `--skip-*`, `--no-persist`)
- * is not the proof a complete one replaces, so it is passed over. Only the
- * live log is read: a repeat worth warning about is recent.
- *
- * @param {string} projectPath
- * @param {{ feature: string, task: string|null, scope: string, fingerprint: string|null }} run
- * @returns {{ ts: string, status: string, sha: string|null }|null}
- */
-export function findRepeatedVerify(projectPath, { feature, task, scope, fingerprint }) {
+/** A partial run (`--filter`, `--skip-*`, `--no-persist`) is not the proof a complete one replaces. */
+export function findRepeatedVerify(projectPath, { feature, fingerprint }) {
   if (!fingerprint) return null;
   const events = readTelemetryEvents(projectPath);
   for (let i = events.length - 1; i >= 0; i--) {
     const e = events[i];
-    if (e.event !== 'Verify' || e.feature !== feature || e.scope !== scope || (e.task ?? null) !== (task ?? null)) continue;
+    if (e.event !== 'Verify' || e.feature !== feature) continue;
     if (e.persisted === false) continue;
     return e.fingerprint === fingerprint ? { ts: e.ts, status: e.status, sha: e.sha ?? null } : null;
   }
   return null;
 }
 
-/**
- * Appends only where a morph project already exists: this command must never
- * be the one that creates `.morph/`.
- *
- * @param {string} projectPath
- * @param {Object} event
- */
+// Appends only where a morph project exists: this command must never be the one that creates `.morph/`.
 export function recordVerifyEvent(projectPath, event) {
   if (!existsSync(join(projectPath, '.morph'))) return;
   appendTelemetryEvent(event, projectPath);