@polymorphism-tech/morph-spec 8.47.0 → 9.1.0

package/src/dashboard/app/pages/HookInspector.jsx

@@ -6,12 +6,7 @@ import FlowGraph from '../components/FlowGraph.jsx';
 import DetailPanel from '../components/DetailPanel.jsx';
 import EntityLink, { useSelection } from '../components/EntityLink.jsx';
 
-/**
- * Every event the scanner can report. `when` and `power` are what the panel
- * explains; `canBlock` is the badge on the graph (the tool-call veto).
- * Colors are the dashboard palette as hex, because the MiniMap cannot read
- * CSS variables.
- */
+/** Colors are hex because the MiniMap cannot read CSS variables. */
 const EVENTS = {
   'session-start': {
     label: 'Início da sessão', color: '#73daca',
@@ -69,12 +64,7 @@ function eventMeta(key) {
   return EVENTS[key] || { label: key, color: '#8d97a5', when: 'Evento sem descrição no dashboard.', power: '' };
 }
 
-/**
- * The URL key of one registration. A hook file can register more than once
- * under the same event with different matchers, so the name alone is not
- * unique: `?sel=` holds `event:name:matcher`. A bare hook name also works and
- * opens that hook's first registration.
- */
+/** A hook can register more than once under one event, so `?sel=` holds `event:name:matcher`. */
 export function hookKey(hook) {
   return `${hook.event}:${hook.name}:${hook.matcher || ''}`;
 }
@@ -89,8 +79,6 @@ function matcherText(hook) {
   return eventMeta(hook.event).toolEvent ? 'todas as ferramentas' : null;
 }
 
-// ─── Nodes ────────────────────────────────────────────────────────────────────
-
 const NODE_W = 280;
 const ROW_H = 26;
 const HEAD_H = 58;
@@ -161,11 +149,6 @@ function ToolNode() {
 
 const nodeTypes = { eventGroupNode: EventGroupNode, toolNode: ToolNode };
 
-// ─── Layout ───────────────────────────────────────────────────────────────────
-// Main row: session-start → user-prompt → pre-tool-use → tool → post-tool-use → stop / pre-compact
-// Second row: events outside the tool-call flow (worktree pair, teammate-idle,
-// unregistered hooks and any event this page does not know).
-
 const COL_GAP = NODE_W + 90;
 const MAIN_ROW = ['session-start', 'user-prompt', 'pre-tool-use', '__tool__', 'post-tool-use'];
 const SIDE_ROW = ['worktree-create', 'worktree-remove', 'teammate-idle', 'unregistered'];
@@ -231,8 +214,6 @@ function buildNodesAndEdges(hooksByEvent, onSelectHook, selectedKey) {
   return { nodes, edges };
 }
 
-// ─── Panels ───────────────────────────────────────────────────────────────────
-
 function Section({ title, children }) {
   return (
     <section>
@@ -369,8 +350,6 @@ function ToolDetail() {
   );
 }
 
-// ─── Main Page ────────────────────────────────────────────────────────────────
-
 export default function HookInspector() {
   const { hooks } = morphData;
   const [sel, setSel] = useSelection();

package/src/dashboard/app/pages/PhasePipeline.jsx

@@ -9,12 +9,10 @@ import { phaseMeta, GATE_LABEL } from '../lib/phases.js';
 
 const phaseColor = (id) => `var(--color-phase-${id})`;
 
-/** What each approval gate checks, in the words a reader of the pipeline needs. */
 const GATE_CHECKS = {
-  proposal: 'Confere o escopo da proposta: o problema, o que entra e o que fica de fora, antes de gastar esforço em design ou plano.',
-  uiux: 'Confere o design das telas (mockups e checklist de tela). É opcional: só existe quando a feature passa pela fase de UI/UX.',
-  plan: 'Confere a spec, as tasks e o plano de implementação. Depois dele a spec congela e a implementação começa.',
-  review: 'Confere a avaliação independente: um avaliador em contexto novo dá o veredito (SHIP ou FIX) e só bloqueia com evidência, com o verify verde.',
+  plan: 'Confere o plano: o problema, o que fica de fora, os cenários com a prova de cada um e as fatias. Depois dele o plan.md congela (só a errata cresce).',
+  uiux: 'Confere o design das telas (mockups e checklist de tela). É opcional: só existe quando a feature passa pela fase de UI/UX, depois do plano.',
+  review: 'Confere a avaliação independente em contexto novo: verificador e revisor (e segurança, quando o diff toca auth, segredo ou dado pessoal), cada um com veredito SHIP ou FIX sobre o mesmo commit. Só bloqueia com evidência, com o verify verde e todo cenário provado.',
 };
 
 const GATE_PREFIX = 'gate-';
@@ -66,7 +64,6 @@ const GATE_W = 150;
 const GATE_H = 32;
 const GAP = 48;
 
-/** Left to right: each phase, then its gate (when it has one), then the next phase. */
 function buildPipelineGraph(phases, sel) {
   const nodes = [];
   const edges = [];
@@ -132,7 +129,6 @@ function Chip({ children }) {
 // Exported for the render smoke test: no page state, only the phase and the personas.
 export function PhaseDetail({ phase, agents }) {
   const color = phaseColor(phase.id);
-  // Personas this phase's skill dispatches (derived by the agents scanner).
   const activeAgents = agents.filter((a) => a.activePhases?.includes(phase.id));
 
   return (

package/src/dashboard/app/pages/Portfolio.jsx

@@ -22,7 +22,6 @@ async function send(method, url, body) {
 function ProjectBlock({ p, now, onRemove }) {
   const s = p.summary;
   const working = s ? s.activeFeatures.filter((f) => isWorking(f, now)).length : 0;
-  // What waits on you is already listed at the top of the page; here, the rest, latest first.
   const rest = s ? s.activeFeatures.filter((f) => !f.awaiting) : [];
   const shown = [...rest].sort((a, b) => (b.lastActivity?.ts || '').localeCompare(a.lastActivity?.ts || '')).slice(0, ACTIVE_SHOWN);
   return (

package/src/dashboard/app/pages/RulesMap.jsx

@@ -12,13 +12,7 @@ const RULE_COLOR = 'var(--color-phase-plan)';
 const STD_COLOR = 'var(--color-phase-proposal)';
 const NODE_W = 260;
 
-// ─── Standard resolution ──────────────────────────────────────────────────────
-
-/**
- * A rule's route → the standard it names in the registry. `id` is what the
- * Standards page selects by; with no registry match the path itself is passed,
- * so the link still says which file the rule meant.
- */
+/** With no registry match the path itself is passed, so the link still names the file. */
 function resolveStandard(ref, byPath) {
   const path = standardKey(ref);
   const std = byPath.get(path);
@@ -30,8 +24,6 @@ function resolveStandard(ref, byPath) {
   };
 }
 
-// ─── Node Components ──────────────────────────────────────────────────────────
-
 function RuleNode({ data }) {
   return (
     <div
@@ -78,8 +70,6 @@ function StandardRefNode({ data }) {
 
 const nodeTypes = { ruleNode: RuleNode, standardRefNode: StandardRefNode };
 
-// ─── Graph Builder ────────────────────────────────────────────────────────────
-
 function matchesFilter(rule, search, stackFilter) {
   const q = search.toLowerCase();
   const matchSearch = !q || rule.name.toLowerCase().includes(q) || rule.stacks.some((s) => s.toLowerCase().includes(q));
@@ -153,8 +143,6 @@ function buildGraph(rules, byPath, search, stackFilter, selected) {
   return { nodes, edges };
 }
 
-// ─── Detail Content ───────────────────────────────────────────────────────────
-
 function Section({ title, children }) {
   return (
     <section>
@@ -221,9 +209,6 @@ function RuleDetail({ rule, byPath }) {
   );
 }
 
-// ─── Main Page ────────────────────────────────────────────────────────────────
-
-/** `?sel=` holds the rule `name` (the file name without `.md`). */
 export default function RulesMap() {
   const { rules } = morphData;
   const [search, setSearch] = useState('');

package/src/dashboard/app/pages/SkillsLibrary.jsx

@@ -22,8 +22,6 @@ const INVOKE_NO = 'só interna';
 
 const tint = (color, pct = 14) => `color-mix(in srgb, ${color} ${pct}%, var(--color-core))`;
 
-// ─── Nodes ────────────────────────────────────────────────────────────────────
-
 const HANDLE = { width: 7, height: 7, border: 0 };
 
 function PhaseNode({ data }) {
@@ -99,15 +97,11 @@ function GroupNode({ data }) {
 
 const nodeTypes = { phaseNode: PhaseNode, skillNode: SkillNode, personaNode: PersonaNode, groupNode: GroupNode };
 
-// ─── Graph model ──────────────────────────────────────────────────────────────
-
-/** The phase a skill belongs to: its own `phase`, or the phase whose `skill` it is. */
 function skillPhaseOf(skill, phases) {
   if (skill.phase) return skill.phase;
   return phases.find((p) => p.skill === skill.id)?.id || null;
 }
 
-/** The persona targets of a skill's dispatches: generic ones go to the one "implementadores" node. */
 function dispatchTargets(skill) {
   const out = new Set();
   for (const d of skill.dispatches || []) {
@@ -127,7 +121,7 @@ const SUPPORT_PER_ROW = 5;
 function buildGraph({ skills, phases, agents, isMatch, hasFilter }) {
   const nodes = [];
   const edges = [];
-  const phaseSkills = new Map(); // phaseId → skill[]
+  const phaseSkills = new Map();
   const support = [];
   for (const s of skills) {
     const ph = skillPhaseOf(s, phases);
@@ -137,7 +131,6 @@ function buildGraph({ skills, phases, agents, isMatch, hasFilter }) {
     } else support.push(s);
   }
 
-  // Row 0 + 1: one column per phase, its skill(s) below it.
   phases.forEach((p, i) => {
     const meta = phaseMeta(p.id);
     const x = i * COL;
@@ -154,7 +147,6 @@ function buildGraph({ skills, phases, agents, isMatch, hasFilter }) {
     });
   });
 
-  // Row 3+: the support skills, in a labelled group under the personas.
   const supportCols = Math.min(SUPPORT_PER_ROW, Math.max(1, support.length));
   const supportRows = Math.ceil(support.length / supportCols);
   const supportWidth = supportCols * COL;
@@ -173,7 +165,6 @@ function buildGraph({ skills, phases, agents, isMatch, hasFilter }) {
     nodes.push(skillNode(s, x, y, SUPPORT_COLOR, SUPPORT_LABEL));
   });
 
-  // Row 2: the personas the skills dispatch prompts to.
   const personaIds = new Set();
   for (const s of skills) for (const t of dispatchTargets(s)) personaIds.add(t);
   const agentOrder = agents.map((a) => a.id);
@@ -197,7 +188,6 @@ function buildGraph({ skills, phases, agents, isMatch, hasFilter }) {
     });
   });
 
-  // skill → persona, from the dispatch prompts.
   const supportIds = new Set(support.map((s) => s.id));
   for (const s of skills) {
     const fromSupport = supportIds.has(s.id);
@@ -226,8 +216,6 @@ function buildGraph({ skills, phases, agents, isMatch, hasFilter }) {
   }
 }
 
-// ─── Detail ───────────────────────────────────────────────────────────────────
-
 function Section({ title, children }) {
   return (
     <section className="space-y-2">
@@ -252,7 +240,6 @@ function PromptBlock({ text, label = 'Prompt enviado ao sub-agent' }) {
   );
 }
 
-/** Plain text of a hast node (the `node` react-markdown hands to overrides). */
 function hastText(node) {
   if (!node) return '';
   if (node.type === 'text') return node.value || '';
@@ -372,8 +359,6 @@ export function SkillDetail({ skill, phases = morphData.phases?.list || [] }) {
   );
 }
 
-// ─── Page ─────────────────────────────────────────────────────────────────────
-
 export default function SkillsLibrary() {
   const skills = morphData.skills || [];
   const phases = morphData.phases?.list || [];

package/src/dashboard/app/pages/Standards.jsx

@@ -8,9 +8,6 @@ import SearchFilter from '../components/SearchFilter.jsx';
 import Markdown from '../components/Markdown.jsx';
 import EntityLink, { useSelection, standardKey } from '../components/EntityLink.jsx';
 
-// ─── Colors ───────────────────────────────────────────────────────────────────
-
-/** Token palette the categories draw from, in order; the categories come from the data. */
 const PALETTE = [
   'var(--color-phase-implement)',
   'var(--color-phase-uiux)',
@@ -24,20 +21,17 @@ const PALETTE = [
 
 const tint = (color, pct = 14) => `color-mix(in srgb, ${color} ${pct}%, var(--color-core))`;
 
-/** category → color, stable by category name so a color never jumps between renders. */
+/** Stable by category name, so a color never jumps between renders. */
 function categoryColors(standards) {
   const cats = [...new Set(standards.map((s) => s.category || 'outros'))].sort();
   return Object.fromEntries(cats.map((c, i) => [c, PALETTE[i % PALETTE.length]]));
 }
 
-/** Resolve `?sel=` to a standard: by id first, then by the path a task cites. */
 export function findStandard(list, sel) {
   if (!sel) return null;
   return list.find((s) => s.id === sel) || list.find((s) => s.path === standardKey(sel)) || null;
 }
 
-// ─── Nodes ────────────────────────────────────────────────────────────────────
-
 const HANDLE = { width: 7, height: 7, border: 0 };
 const NODE_W = 230;
 const NODE_H = 52;
@@ -97,8 +91,6 @@ function CategoryNode({ data }) {
 
 const nodeTypes = { standardNode: StandardNode, agentNode: AgentNode, categoryNode: CategoryNode };
 
-// ─── Layout ───────────────────────────────────────────────────────────────────
-
 const CELL_W = NODE_W + 14;
 const CELL_H = NODE_H + 12;
 const PAD = 16;
@@ -106,7 +98,6 @@ const HEADER = 40;
 const BLOCK_GAP = 36;
 const MAX_ROW_W = 1700;
 
-/** How many columns a category block gets: tall categories spread sideways. */
 function colsFor(n) {
   if (n > 12) return 3;
   if (n > 5) return 2;
@@ -127,7 +118,6 @@ function buildGraph({ standards, agents, colors, isMatch, hasFilter, persona, se
     .map(([cat, list]) => [cat, [...list].sort((a, b) => (a.subcategory || '').localeCompare(b.subcategory || '') || a.name.localeCompare(b.name))])
     .sort((a, b) => b[1].length - a[1].length || a[0].localeCompare(b[0]));
 
-  // Pack the category blocks into rows no wider than MAX_ROW_W.
   const blocks = cats.map(([cat, list]) => {
     const cols = colsFor(list.length);
     const rows = Math.ceil(list.length / cols);
@@ -141,7 +131,7 @@ function buildGraph({ standards, agents, colors, isMatch, hasFilter, persona, se
   }
   const totalW = Math.max(...rows.map((r) => r.w), 0);
 
-  const std = new Set(); // node ids present
+  const std = new Set();
   let y = 180;
   for (const row of rows) {
     let x = (totalW - row.w) / 2;
@@ -170,7 +160,6 @@ function buildGraph({ standards, agents, colors, isMatch, hasFilter, persona, se
     y += row.h + BLOCK_GAP;
   }
 
-  // The personas on top, each with an edge to every standard it consults.
   const withStandards = agents.filter((a) => (a.standards || []).some((id) => std.has(id)));
   const agentX0 = (totalW - withStandards.length * (NODE_W + 24)) / 2;
   const byId = new Map(standards.map((s) => [s.id, s]));
@@ -194,8 +183,6 @@ function buildGraph({ standards, agents, colors, isMatch, hasFilter, persona, se
   return { nodes, edges, categories: cats.map(([c, l]) => [c, l.length]) };
 }
 
-// ─── Detail ───────────────────────────────────────────────────────────────────
-
 function Section({ title, children }) {
   return (
     <section className="space-y-2">
@@ -307,8 +294,6 @@ export function StandardDetail({ std, color = 'var(--color-dim)' }) {
   );
 }
 
-// ─── Page ─────────────────────────────────────────────────────────────────────
-
 export default function Standards() {
   const standards = morphData.standards?.list || [];
   const version = morphData.standards?.version;

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

@@ -1,12 +1,6 @@
 /**
- * The harness event stream (`.morph/logs/events.jsonl`, schema v2 of
- * framework/hooks/shared/telemetry-logger.js) told as a feed a person can read.
- *
- * Reading and summing are NOT done here: `loadTelemetryAllTrees` gathers every
- * tree's log plus the finish backups, and `aggregateCost` is the one place
- * tokens are added up (only `delta` can be summed; a v1 stream yields `null`,
- * which the UI shows as unknown — never 0). This module only decides what each
- * event means in words, and which ones are worth a line.
+ * `loadTelemetryAllTrees` reads and `aggregateCost` is the one place tokens are
+ * summed: a v1 stream yields `null`, shown as unknown, never 0.
  */
 
 import { statSync, openSync, readSync, closeSync } from 'fs';
@@ -14,8 +8,7 @@ import { join, resolve } from 'path';
 import { loadTelemetryAllTrees, aggregateCost, dedupeEvents } from '../../lib/telemetry/telemetry-reader.js';
 import { isFailedToolCall } from '../../../framework/hooks/shared/telemetry-logger.js';
 
-/** Kinds a person follows by default; the rest are one click away. */
-export const DEFAULT_KINDS = ['prompt', 'question', 'skill', 'dispatch', 'handback', 'task', 'verify', 'gate', 'failure'];
+export const DEFAULT_KINDS = ['prompt', 'question', 'skill', 'dispatch', 'handback', 'verify', 'gate', 'failure'];
 export const ALL_KINDS = [...DEFAULT_KINDS, 'write', 'read', 'command', 'tool'];
 
 const GATE_COMMAND = /\bmorph-spec\s+(approve|gate-check|gate-decision|advance|finish)\b/;
@@ -44,20 +37,10 @@ function nodesSummary(nodes) {
   return Object.entries(nodes).map(([name, n]) => ({ name, status: typeof n === 'string' ? n : n?.status ?? null }));
 }
 
-/**
- * One event → one feed line, or null when the event is bookkeeping.
- *
- * @returns {null | {
- *   id: string, ts: string, feature: string|null, phase: string|null,
- *   kind: string, title: string, detail: string|null, status: 'ok'|'fail'|null,
- *   refs: { persona?: string, skill?: string, task?: string, path?: string },
- *   nodes?: Array<{name: string, status: string|null}>
- * }}
- */
 export function describeEvent(e) {
   if (!e || typeof e !== 'object' || SILENT_EVENTS.has(e.event)) return null;
   const base = {
-    id: e.eventId || `${e.ts}:${e.event}:${e.tool || ''}:${e.task || ''}`,
+    id: e.eventId || `${e.ts}:${e.event}:${e.tool || ''}`,
     ts: e.ts || null,
     feature: e.feature || null,
     phase: e.phase || null,
@@ -69,27 +52,18 @@ export function describeEvent(e) {
   const line = (kind, title, extra = {}) => ({ ...base, kind, title, ...extra, refs: { ...base.refs, ...(extra.refs || {}) } });
 
   if (e.event === 'UserPromptSubmit') {
-    // Hand-backs, task notifications and reminders arrive through the same door
-    // as a person's prompt, wrapped in a tag. A slash command is the one tagged
-    // prompt a person typed.
+    // Hand-backs, notifications and reminders arrive as a prompt wrapped in a tag;
+    // a slash command is the one tagged prompt a person typed.
     const text = typeof e.prompt === 'string' ? e.prompt.trim() : '';
     const command = /^<command-name>\/?([^<]+)<\/command-name>/.exec(text);
     if (command) return line('prompt', `Você rodou /${command[1].trim()}`);
     if (text.startsWith('<')) return null;
     return line('prompt', 'Você escreveu', { detail: clip(text) });
   }
-  if (e.event === 'TaskStart') return line('task', `${e.task} começou`, { refs: { task: e.task } });
-  if (e.event === 'TaskEnd') {
-    const done = e.status === 'done';
-    return line('task', done ? `${e.task} concluída` : `${e.task} terminou (${e.status ?? 'sem status'})`, {
-      status: done ? 'ok' : null, refs: { task: e.task },
-    });
-  }
   if (e.event === 'Verify') {
     const ok = e.status === 'pass';
-    const scope = e.task ? e.task : 'feature inteira';
-    return line('verify', `verify ${scope} ${ok ? 'passou' : 'falhou'}`, {
-      status: ok ? 'ok' : 'fail', nodes: nodesSummary(e.nodes), refs: e.task ? { task: e.task } : {},
+    return line('verify', `verify ${ok ? 'passou' : 'falhou'}`, {
+      status: ok ? 'ok' : 'fail', nodes: nodesSummary(e.nodes),
       detail: e.persisted === false && e.reason ? `não carimbou: ${e.reason}` : null,
     });
   }
@@ -127,8 +101,7 @@ export function describeEvent(e) {
   return line('tool', tool || e.event);
 }
 
-// The same event array is fed again on every request until the log changes:
-// describing ~100k events once, not per page, is the difference that matters.
+// Memoized per events array: describing ~100k events once, not per page.
 const described = new WeakMap();
 
 function describeAll(events) {
@@ -145,12 +118,6 @@ function describeAll(events) {
   return described.get(events);
 }
 
-/**
- * The feed, newest first, filtered and paginated by a `before` timestamp cursor.
- *
- * @param {Object[]} events - raw events, any order
- * @param {{ feature?: string, kinds?: string[], before?: string, limit?: number }} [opts]
- */
 export function buildFeed(events, { feature, kinds = DEFAULT_KINDS, before, limit = 100 } = {}) {
   const wanted = new Set(kinds);
   const lines = describeAll(events).filter((l) => wanted.has(l.kind) && (!feature || l.feature === feature));
@@ -160,15 +127,6 @@ export function buildFeed(events, { feature, kinds = DEFAULT_KINDS, before, limi
   return { items: page, next: page.length === limit && last ? last.ts : null, total: lines.length };
 }
 
-/**
- * What the feature list shows as "the last thing that happened" in each
- * feature: the newest line a person follows by default (a dispatch, a verify, a
- * task — not a Read or a shell command), plus `ts`, the newest event of ANY kind,
- * which is what says an agent is working right now.
- *
- * @param {Object[]} events
- * @returns {Record<string, {ts: string, title: string|null, kind: string|null, status: string|null, titleTs: string|null}>}
- */
 const lastByLines = new WeakMap();
 
 export function lastActivityByFeature(events) {
@@ -187,7 +145,6 @@ export function lastActivityByFeature(events) {
   return out;
 }
 
-/** Every event of the project across its trees and finish backups. */
 export function loadProjectEvents(projectDir) {
   return dedupeEvents(loadTelemetryAllTrees(projectDir).flatMap((t) => t.events));
 }
@@ -203,27 +160,14 @@ function fileSize(path) {
 }
 
 /**
- * The project's events kept in memory and followed as they are appended.
- *
- * A running agent appends one line to its tree's `events.jsonl` per tool call.
- * Re-reading every log (≈100k events, seconds) on each append would block the
- * dev server for the whole run, so the store remembers how far it read each
- * live log and parses only the bytes after that. Anything it cannot follow
- * that way — a log that shrank (SessionStart rotated it), a log it has never
- * seen (a new worktree), an archive or backup — falls back to a full reload
- * through `loadTelemetryAllTrees`, the same reader as always. Copies of one
- * event are still dropped by `eventId`.
- *
- * Every update yields a NEW events array, so everything memoized per array
- * (described lines, per-feature cost) follows the change.
- *
- * @param {string} projectDir
- * @param {{ loadTrees?: Function }} [deps] - test seam, defaults to loadTelemetryAllTrees
+ * Tails each live log from the last byte read; a shrunk (rotated) or unseen log,
+ * an archive or a backup falls back to a full reload. Every update yields a NEW
+ * events array, so everything memoized per array follows the change.
  */
 export function createEventStore(projectDir, { loadTrees = loadTelemetryAllTrees } = {}) {
   let events = null;
   let seen = new Set();
-  let offsets = new Map(); // live log path -> bytes consumed (up to the last newline)
+  let offsets = new Map();
   let pending = new Set();
   let fullReload = true;
   const costs = new Map();
@@ -246,7 +190,6 @@ export function createEventStore(projectDir, { loadTrees = loadTelemetryAllTrees
     costs.clear();
   }
 
-  /** Parse the bytes appended to `path` since the last read; false when it cannot follow. */
   function tail(path) {
     const from = offsets.get(path);
     const size = fileSize(path);
@@ -281,7 +224,6 @@ export function createEventStore(projectDir, { loadTrees = loadTelemetryAllTrees
       const prevLines = described.get(events);
       const merged = events.concat(fresh);
       events = fresh.every((e) => (e.ts || '') >= last) ? merged : dedupeEvents(merged);
-      // Carry the described lines over instead of describing 100k events again.
       if (prevLines) {
         const byTsDesc = (a, b) => (b.ts || '').localeCompare(a.ts || '');
         const added = fresh.map(describeEvent).filter(Boolean).sort(byTsDesc);
@@ -310,19 +252,13 @@ export function createEventStore(projectDir, { loadTrees = loadTelemetryAllTrees
 
   return {
     events: current,
-    /**
-     * Something under `.morph/logs` changed. A known live log is tailed on the
-     * next read; anything else (rotation archive, new tree, backup) reloads.
-     */
     changed(path) {
       const known = path && [...offsets.keys()].find((p) => resolve(p) === resolve(path));
       if (known) pending.add(known);
       else fullReload = true;
     },
     reset() { fullReload = true; },
-    /** Loaded and not waiting for a full reload: reading it now is cheap. */
     ready() { return events !== null && !fullReload; },
-    /** `featureCost`, memoized until the events change. */
     cost(feature) {
       const all = current();
       if (!costs.has(feature)) costs.set(feature, featureCost(all, feature));
@@ -331,10 +267,7 @@ export function createEventStore(projectDir, { loadTrees = loadTelemetryAllTrees
   };
 }
 
-/**
- * What the feature cost, straight from `aggregateCost`. `sessionUsage` and
- * `agentUsage` stay `null` when the stream has no summable sample.
- */
+/** `sessionUsage` and `agentUsage` stay `null` when the stream has no summable sample. */
 export function featureCost(events, feature) {
   const c = aggregateCost(events, { feature });
   return {
@@ -344,8 +277,6 @@ export function featureCost(events, feature) {
     dispatches: c.dispatches,
     bytesTotal: c.bytesTotal,
     bytesByKind: c.bytesByKind,
-    taskDurationSeconds: c.taskDurationSeconds,
-    tasks: c.tasks,
     events: c.total,
   };
 }

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

@@ -2,27 +2,13 @@ import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { personaStandardIds, isImplementer, renderAgentMd, loadKnownMcpIds } from '../../utils/agents-installer.js';
 
-/** A line of a phase skill that dispatches a sub-agent. */
 const DISPATCH_LINE = /despach|dispatch|subagent_type/i;
 
-/** The generic dispatch token: "the implementer of the task's domain". */
 const GENERIC_DISPATCH = 'morph-{id}';
 
 /**
- * Which phases each persona works in, read from the phase skills themselves.
- *
- * v5 has no phase list on the persona: a phase dispatches a persona when its
- * skill (`phases.json → skill`) names `morph-{personaId}` on a dispatch line
- * (morph-uiux → ui-designer, morph-plan → scout, morph-review → evaluator).
- * A skill that dispatches the generic `morph-{id}` runs every implementer —
- * the same `isImplementer` the validator and the installer use.
- *
  * Only dispatch lines count: morph-plan cites `morph-dotnet-senior` as a
  * spelling example of the `agent` field, which dispatches nobody.
- *
- * @param {string} frameworkDir
- * @param {Record<string, object>} agents - agents.json `agents` map
- * @returns {Map<string, string[]>} personaId → phase ids, in phase order
  */
 export function personaPhases(frameworkDir, agents) {
   const result = new Map(Object.keys(agents).map((id) => [id, []]));
@@ -46,10 +32,6 @@ export function personaPhases(frameworkDir, agents) {
   return result;
 }
 
-/**
- * Scan agents.json (v5) — flat domain personas, no tiers.
- * Returns the list shaped for the dashboard inspector.
- */
 export function scanAgents(frameworkDir) {
   const agentsJsonPath = join(frameworkDir, 'agents.json');
   if (!existsSync(agentsJsonPath)) {
@@ -58,9 +40,7 @@ export function scanAgents(frameworkDir) {
   const agentsJson = JSON.parse(readFileSync(agentsJsonPath, 'utf8'));
   const phasesOf = personaPhases(frameworkDir, agentsJson.agents);
   const knownMcpIds = loadKnownMcpIds(frameworkDir);
-  // The exact `.claude/agents/morph-{id}.md` the installer writes: the system
-  // prompt the sub-agent actually runs with. A persona whose data the renderer
-  // refuses shows the refusal instead of hiding the persona.
+  // A persona whose data the renderer refuses shows the refusal instead of hiding the persona.
   const promptOf = (id, agent) => {
     try { return renderAgentMd({ id, ...agent }, knownMcpIds); } catch (err) { return `<!-- não renderizou: ${err.message} -->`; }
   };
@@ -71,8 +51,6 @@ export function scanAgents(frameworkDir) {
     color: agent.color || null,
     domains: agent.domains || [],
     keywords: agent.keywords || [],
-    // Every standard the persona can cite, surfaces included — the same
-    // reading the installer and the validator use.
     standards: personaStandardIds(agent),
     surfaces: agent.surfaces || null,
     stack: agent.stack || ['*'],

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

@@ -1,8 +1,3 @@
-/**
- * The reading material of the framework — the charter, the runtime
- * instructions, the CLI reference and the Gate 3 evaluator checklist — for the
- * dashboard's Guide page.
- */
 import { readFileSync } from 'fs';
 import { join } from 'path';
 
@@ -10,7 +5,6 @@ function read(path) {
   try { return readFileSync(path, 'utf8'); } catch { return null; }
 }
 
-/** `## Heading` lines, the table of contents a long document is read by. */
 export function headingsOf(content) {
   const out = [];
   let inFence = false;
@@ -27,7 +21,7 @@ const GUIDE = [
   { id: 'morph', path: 'MORPH.md', title: 'Carta do harness (MORPH.md)', summary: 'Como o Claude trabalha: papéis, fases, gates, sub-agents. É a fonte única do comportamento.' },
   { id: 'runtime', path: 'CLAUDE.md', title: 'Instruções de runtime (CLAUDE.md)', summary: 'O que é injetado no CLAUDE.md do projeto: como começar cada sessão, regras críticas, comandos.' },
   { id: 'cli', path: 'docs/CLI.md', title: 'Referência do CLI', summary: 'Todos os comandos morph-spec: gates, verify, worktrees, grafo, telemetria.' },
-  { id: 'review-checklist', path: 'evals/review-checklist.md', title: 'Checklist do avaliador (Gate 3)', summary: 'O que o avaliador independente procura antes do ship: veredito SHIP/FIX e bloqueador com evidência.' },
+  { id: 'review-checklist', path: 'evals/review-checklist.md', title: 'Checklist do Gate 3', summary: 'O que verificador, revisor e segurança procuram antes do ship: veredito SHIP/FIX e bloqueador com evidência.' },
 ];
 
 export function scanDocs(frameworkDir) {

package/src/dashboard/scanner/feature-status.js

@@ -1,9 +1,6 @@
 /**
- * When a feature counts as finished — the one rule the portfolio (server) and
- * the feature list (client) share. Pure, no node imports: the client bundles it.
- *
- * A feature in `.morph/archive/` is closed whatever its status says: legacy
- * archives keep `draft` or `in_progress` from before `finish` set the status.
+ * Pure, no node imports: the client bundles it. An archived feature is closed
+ * whatever its legacy status says.
  */
 export function isFinished(f) {
   return f?.status === 'completed' || f?.status === 'abandoned' || f?.location === 'archive';