@polymorphism-tech/morph-spec 8.46.0 → 9.0.0

package/src/lib/tasks/test-runner.js

@@ -28,7 +28,7 @@
  */
 
 import { execSync, execFileSync } from 'child_process';
-import { existsSync, readFileSync, readdirSync, realpathSync } from 'fs';
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from 'fs';
 import { join, resolve, relative, isAbsolute } from 'path';
 import { globSync } from 'glob';
 
@@ -170,11 +170,6 @@ function collectDotnetTestProjects(projectPath) {
  * says "not inside" for the same directory and a linked worktree leaks into
  * the test command. Only `realpathSync.native` asks the OS. Fail-open to the
  * plain resolve for a path that does not exist (yet).
- *
- * Exported because test-scope.js spells every task output with it (#87 F4): a
- * mis-cased output resolves on a case-insensitive disk and was forwarded to the
- * runner verbatim — and the `--linux` container is case-sensitive. The OS also
- * returns the real CASE of each component, so this one call is both answers.
  */
 export function canonicalPath(p) {
   try {
@@ -338,6 +333,75 @@ export function resolveTestBuildTargets(node) {
   return extractCsprojTargets(node.command);
 }
 
+const DOTNET_BUILDABLE = /"([^"]+\.(?:slnx?|csproj))"|'([^']+\.(?:slnx?|csproj))'|(\S+\.(?:slnx?|csproj))/gi;
+
+/**
+ * What `dotnet test` compiles for this node, relative to its `cwd`: declared `build`,
+ * else what the command names, else the directory's single solution/project; `[]` = undiscoverable.
+ */
+export function discoverDotnetBuildTargets(node, cwd) {
+  if (node?.runner !== 'dotnet') return [];
+  if (Array.isArray(node.build) && node.build.length > 0) return node.build;
+  const command = typeof node.command === 'string' ? node.command : '';
+  const named = [...command.matchAll(DOTNET_BUILDABLE)].map((m) => m[1] ?? m[2] ?? m[3]);
+  if (named.length > 0) return [...new Set(named)];
+
+  const dirArg = command.split(/\s+/).find((token) => token && !token.startsWith('-') && token !== 'dotnet' && token !== 'test'
+    && isDirectory(join(cwd, token)));
+  const dir = dirArg ?? '.';
+  let entries;
+  try { entries = readdirSync(join(cwd, dir)); } catch { return []; }
+  const only = singleDotnetBuildable(entries);
+  return only ? [dir === '.' ? only : join(dir, only).replace(/\\/g, '/')] : [];
+}
+
+/** The one solution among `files`, else the one project; `null` when `dotnet build` would have to guess. */
+function singleDotnetBuildable(files) {
+  const solutions = files.filter((f) => /\.slnx?$/i.test(f));
+  const projects = files.filter((f) => /\.csproj$/i.test(f));
+  if (solutions.length) return solutions.length === 1 ? solutions[0] : null;
+  return projects.length === 1 ? projects[0] : null;
+}
+
+const DOTNET_SCAN_SKIPPED = new Set([WORKTREES_DIR, LEGACY_WORKTREES_DIR, 'node_modules', 'bin', 'obj']);
+const DOTNET_SCAN_DEPTH = 6;
+
+function dotnetBuildablesUnder(root, rel = '', depth = 0, found = []) {
+  let entries;
+  try { entries = readdirSync(join(root, rel), { withFileTypes: true }); } catch { return found; }
+  for (const e of entries) {
+    const path = rel ? `${rel}/${e.name}` : e.name;
+    if (e.isFile() && /\.(?:slnx?|csproj)$/i.test(e.name)) found.push(path);
+    else if (e.isDirectory() && depth < DOTNET_SCAN_DEPTH && !e.name.startsWith('.') && !DOTNET_SCAN_SKIPPED.has(e.name)) {
+      dotnetBuildablesUnder(root, path, depth + 1, found);
+    }
+  }
+  return found;
+}
+
+/**
+ * What a root `dotnet build` compiles when the root itself holds no solution or
+ * project: the repository's single .sln/.slnx, else its single .csproj, never
+ * looking inside worktree containers, node_modules, bin or obj.
+ *
+ * @returns {{ target: string|null, candidates: string[] }} `target` relative to
+ *   `root` (`.` when the root already has one); `null` for zero or several, listed.
+ */
+export function discoverDotnetSolution(root) {
+  let rootEntries;
+  try { rootEntries = readdirSync(root); } catch { return { target: null, candidates: [] }; }
+  if (rootEntries.some((e) => /\.(?:slnx?|csproj)$/i.test(e))) return { target: '.', candidates: [] };
+  const all = dotnetBuildablesUnder(root).sort();
+  const solutions = all.filter((f) => /\.slnx?$/i.test(f));
+  const pool = solutions.length ? solutions : all;
+  const single = singleDotnetBuildable(pool);
+  return { target: single, candidates: pool };
+}
+
+function isDirectory(path) {
+  try { return statSync(path).isDirectory(); } catch { return false; }
+}
+
 /**
  * `dotnet build "<target>" …`, built from the SAME step build-check.js
  * resolves for a .NET stack — the string "dotnet build" is not typed a second
@@ -488,29 +552,6 @@ function parseDotnetCount(output) {
   return seen ? sum : null;
 }
 
-/**
- * The `total` of every MTP summary block in `output`, ANSI stripped — one per
- * `dotnet test` invocation (measured: a solution prints ONE aggregated block).
- * `[]` when none is readable. Read by `judgeNarrowedRun` (verify-runner.js): in a
- * narrowed `&&` chain the SUM can be > 0 while one link ran nothing — its exit 8
- * ignored by a path the scanner cannot read — and that link's own block says
- * `total: 0`.
- *
- * @param {string|null|undefined} output
- * @returns {number[]}
- */
-export function mtpSummaryTotals(output) {
-  if (typeof output !== 'string' || !output) return [];
-  const lines = stripAnsi(output).split('\n');
-  const totals = [];
-  lines.forEach((line, i) => {
-    if (!MTP_SUMMARY_HEADER.test(line)) return;
-    const { total } = mtpSummaryBlock(lines, i + 1);
-    if (total !== null) totals.push(total);
-  });
-  return totals;
-}
-
 /** Last value of a `# key N` (TAP) or `ℹ key N` (spec reporter) summary line. */
 function lastSummaryValue(output, key) {
   const re = new RegExp(`^\\s*[#ℹ]\\s*${key}\\s+(\\d+)\\s*$`, 'gim');
@@ -578,8 +619,8 @@ const ANSI_PATTERN = /\x1b(?:\[[0-?]*[ -/]*[@-~]|\][^\x07\x1b]*(?:\x07|\x1b\\))/
 /**
  * Strip ANSI escape sequences (CSI/SGR and OSC) from captured process output.
  *
- * Non-string input is returned UNCHANGED, never coerced to `''` — the callers
- * that matter (`parseTestCount`, `isZeroTestRun`) already treat a non-string
+ * Non-string input is returned UNCHANGED, never coerced to `''` — the caller
+ * that matters (`parseTestCount`) already treats a non-string
  * output as "nothing to read" on their own; making this function opinionated
  * about that too would be a second place for the same rule to drift.
  *
@@ -640,91 +681,6 @@ export function parseTestCount(output, runner) {
   return extractor(stripAnsi(output));
 }
 
-// ============================================================================
-// "Zero tests ran" signatures, per runner (#87 PR B / #110 parte 1)
-// ============================================================================
-
-/**
- * Per-runner signal for "the run matched/executed NOTHING" — a category
- * distinct from both a genuine `{ total: 0, ... }` summary (a suite that
- * legitimately declares zero cases) and from a summary `parseTestCount`
- * simply could not read (`null`, UNKNOWN). Its reader is `judgeNarrowedRun`
- * (verify-runner.js, #87): a narrowed `verify {feature} {task}` run that FAILED
- * with this signature, and with no count proving tests ran, is named
- * `narrowed-zero-tests (…)` instead of an anonymous red. (A PASSED narrowed run
- * needs its own proof there — a count > 0, or MTP's exit 0 — never this table.)
- *
- * Every entry was MEASURED against a real runner, not invented, and the two
- * dotnet entries disagree with each other on purpose:
- *
- *   - **MTP** (`--filter-class`, this repo's own `ai-kit`, xunit.v3 4.x):
- *     a non-matching filter exits **8** (`ZeroTests`) — reliable BY EXIT
- *     CODE. See `test/fixtures/test-output/mtp-zero-tests.txt`.
- *   - **VSTest** (`--filter "FullyQualifiedName~..."`, classic xunit 2.x):
- *     a non-matching filter exits **0** — exit code CANNOT tell a zero-match
- *     run from a green one here. Only the OUTPUT STRING can:
- *     `test/fixtures/test-output/vstest-zero-tests.txt` (pt-BR, measured).
- *     The en-US wording is the brief's documented string, not measured on
- *     this pt-BR machine — kept alongside the pt-BR one because neither is
- *     derivable from the other and the machine that runs `verify` may be in
- *     either locale.
- *
- * Exit code 8 is therefore listed ONLY as a dotnet exit code, never paired
- * with a string requirement — and exit code 9
- * (`MinimumExpectedTestsPolicyViolation`, this repo's own
- * `--minimum-expected-tests 275`) is deliberately ABSENT: it fires on a run
- * that executed fewer cases than the configured floor, including a run that
- * was entirely green (measured:
- * `test/fixtures/test-output/mtp-filter-class-policy-violation.txt`, 10/10
- * passed, exit 9). Folding 9 into this table would misreport a real pass as
- * "zero tests ran".
- */
-export const ZERO_RUN_SIGNATURES = {
-  dotnet: {
-    exitCodes: [8],
-    strings: [
-      // en-US, VSTest — documented by the brief, not measured here (pt-BR machine).
-      'No test matches the given testcase filter',
-      // pt-BR, VSTest — MEASURED, test/fixtures/test-output/vstest-zero-tests.txt.
-      'Nenhum teste corresponde ao filtro de testcase',
-    ],
-  },
-  vitest: {
-    exitCodes: [],
-    strings: ['No test files found'],
-  },
-  jest: {
-    exitCodes: [],
-    strings: ['No tests found'],
-  },
-};
-
-/**
- * True when `output`/`exitCode` carries this runner's "zero tests ran"
- * signature. Every other runner (`node-test`, `playwright`, `evals`, `none`,
- * or anything not in `ZERO_RUN_SIGNATURES`) answers `false` — an absent entry
- * is an honest "this primitive does not know that runner's zero-tests shape
- * yet", the same doctrine `COUNT_EXTRACTORS` uses for an unknown runner.
- *
- * Called by `judgeNarrowedRun` (verify-runner.js) on a FAILED narrowed run, to
- * name it `narrowed-zero-tests (…)`.
- *
- * @param {string|null|undefined} output - Combined stdout+stderr of the run
- * @param {string} runner - One of TEST_RUNNERS
- * @param {number|null|undefined} exitCode - Must be a NUMBER to match: the
- *   exit-code check is a strict `includes`, so the string `'8'` never matches 8.
- * @returns {boolean}
- */
-export function isZeroTestRun(output, runner, exitCode) {
-  const signature = ZERO_RUN_SIGNATURES[runner];
-  if (!signature) return false;
-
-  if (signature.exitCodes.includes(exitCode)) return true;
-
-  const text = stripAnsi(typeof output === 'string' ? output : '');
-  return signature.strings.some((needle) => text.includes(needle));
-}
-
 /**
  * Compare an executed count against the recorded baseline — asymmetrically,
  * and on purpose (D7).
@@ -840,7 +796,9 @@ export function runTestSuite(projectPath = '.', opts = {}) {
     });
     return { passed: true, output: output ?? '', exitCode: 0, timeoutMs: timeout };
   } catch (err) {
-    const output = (err.stdout || '') + (err.stderr || '');
+    // A spawn failure or a kill leaves both streams empty; its own error is then the only lead.
+    const output = (err.stdout || '') + (err.stderr || '')
+      || [err.code, err.signal, err.message].filter(Boolean).join(' ');
 
     // A timeout is NOT a red suite: the command was interrupted, so no verdict
     // exists. Saying so by name is the whole point — the field diagnosis of

package/src/lib/telemetry/metrics.js

@@ -1,8 +1,8 @@
 /**
  * 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
+ * rereads, verify count per feature, git calls 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
@@ -43,8 +43,7 @@ function executedText(command) {
  */
 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' };
@@ -159,8 +158,6 @@ export function computeMetrics(events, opts = {}) {
 
   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 +169,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 +179,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 +187,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 +196,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 +213,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 +258,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 +288,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 +315,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

@@ -232,10 +232,9 @@ export function aggregateTelemetry(events, opts = {}) {
 // 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).
+// Turns the same raw event stream into a cost-facing view: how many context
+// bytes were re-ingested (by kind, globally and per phase), 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
@@ -243,35 +242,6 @@ export function aggregateTelemetry(events, opts = {}) {
 // 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);
@@ -284,52 +254,9 @@ 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.
+ * Summarize an event stream for cost purposes: bytes-re-ingested buckets by
+ * `kind` (global and per phase) and sub-agent dispatch counts.
  *
  * 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
@@ -356,7 +283,6 @@ function finalizeTask(state) {
  * @returns {{
  *   total: number,
  *   features: string[],
- *   taskDurationSeconds: number,
  *   bytesByKind: Object<string, number>,
  *   bytesTotal: number,
  *   dispatches: {count:number, promptChars:number},
@@ -364,7 +290,6 @@ function finalizeTask(state) {
  *   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}>,
  * }}
  */
@@ -388,8 +313,6 @@ export function aggregateCost(events, opts = {}) {
   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 newUsageBucket = () => ({
     totals: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0 },
     ids: new Set(),
@@ -402,24 +325,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 +342,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 +359,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 +370,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 +384,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,6 +1,6 @@
 /**
  * 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
+ * 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.
  */
@@ -32,8 +32,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,
@@ -46,21 +44,21 @@ export function buildVerifyEvent(result, { sha, tree, persisted, reason, fingerp
 }
 
 /**
- * The last complete run of the same verify (feature, task, scope) over the
+ * The last complete run of the same feature's verify 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
+ * @param {{ feature: string, fingerprint: string|null }} run
  * @returns {{ ts: string, status: string, sha: string|null }|null}
  */
-export function findRepeatedVerify(projectPath, { feature, task, scope, fingerprint }) {
+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;
   }

package/src/lib/validators/code-budget/code-budget-validator.js

@@ -89,7 +89,7 @@ export function budgetIssues(measured) {
       level: 'warning',
       message:
         `${processLines.length} de ${comments} linhas de comentário adicionadas citam processo ` +
-        `(UC, ADR, T{n}, FR, Gate, spec.md, mockup): ${shown.join(', ')}${more > 0 ? ` (+${more})` : ''}`,
+        `(UC, ADR, FR, C{n}, F{n}, Gate, plan.md, checks.json, mockup): ${shown.join(', ')}${more > 0 ? ` (+${more})` : ''}`,
       file: processLines[0].file,
       line: processLines[0].line,
       solution: