@polymorphism-tech/morph-spec 8.20.0 → 8.21.0

package/src/lib/risk-detector.js

@@ -8,7 +8,9 @@
  * Signals checked (in order):
  *   - designSystemDivergence: boolean — conflicting design sources detected
  *   - standardsViolations: string[]   — violations of mandate.md proibições
- *   - verificationStatus: string      — último `morph-spec verify` ('fail' pausa)
+ *   - verificationStatus: string      — último `morph-spec verify` ('fail' pausa, qualquer gate)
+ *   - verificationStale + gate: bool/str — stamp com sha != HEAD pausa SÓ no
+ *     ship (gate 'review') — código mudou depois do último verify
  *   - evalScore: number               — morph-eval score (pause if < 9)
  *   - taskCount: number               — total tasks (pause if > 20)
  */
@@ -64,6 +66,20 @@ export function shouldPauseGate(config, signals) {
     };
   }
 
+  // Furo 2: no gate de SHIP (review) apenas, um stamp de verification cujo
+  // sha diverge do HEAD atual significa que código mudou depois do último
+  // `morph-spec verify` — o resultado carimbado não cobre mais o que está
+  // prestes a ser aprovado. Pausa só aqui, nunca em plan/uiux/proposal: essa
+  // é uma regra de ship, não uma regra geral de gate. Stamp AUSENTE não entra
+  // aqui (verificationStale é fail-open para `false` em collectSignals
+  // quando não há stamp) — features legadas sem stamp continuam liberadas.
+  if (signals.gate === 'review' && signals.verificationStale === true) {
+    return {
+      pause: true,
+      reason: 'verification stamp desatualizado (sha difere do HEAD) — rode `morph-spec verify` de novo antes do ship',
+    };
+  }
+
   if (typeof signals.evalScore === 'number' && signals.evalScore < MIN_EVAL_SCORE) {
     return {
       pause: true,
@@ -93,6 +109,9 @@ export function getRiskSignals(signals) {
     out.push(`standards violations: ${signals.standardsViolations.join(', ')}`);
   }
   if (signals.verificationStatus === 'fail') out.push('verify vermelho');
+  if (signals.gate === 'review' && signals.verificationStale === true) {
+    out.push('verification stamp desatualizado (stale) no ship');
+  }
   if (typeof signals.evalScore === 'number' && signals.evalScore < MIN_EVAL_SCORE) {
     out.push(`eval score ${signals.evalScore}/10`);
   }

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

@@ -10,7 +10,8 @@
  */
 
 import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
+import { join, basename } from 'path';
+import { parseWorktreeList, resolvePrimaryRoot } from '../../commands/project/worktree.js';
 
 const EVENTS_FILE = join('.morph', 'logs', 'events.jsonl');
 
@@ -37,6 +38,45 @@ export function loadTelemetry(projectPath) {
   }
 }
 
+/**
+ * Enumerate every git worktree that has its OWN `.morph/logs/events.jsonl` —
+ * the data source for `cost --all-trees` (Furo 3). Reuses the SAME worktree
+ * enumeration `doctor --worktrees`/`fleet` already use (`parseWorktreeList` +
+ * `resolvePrimaryRoot` from commands/project/worktree.js — see
+ * src/lib/worktree/fleet-scanner.js and worktree-audit.js for the sibling
+ * consumers) instead of re-walking `git worktree list` here.
+ *
+ * `git worktree list --porcelain` always lists the PRIMARY worktree first —
+ * that entry is labeled `'root'`; every other entry is labeled by its
+ * directory basename (typically the feature slug, e.g. `worktrees/{f}` →
+ * `f`). Only trees whose events.jsonl actually exists are returned — a
+ * worktree that never ran the harness contributes nothing, silently.
+ *
+ * Fail-open, like `loadTelemetry`: outside a git repo (or on any git error)
+ * `resolvePrimaryRoot`/`parseWorktreeList` degrade to a single root entry —
+ * never throws.
+ *
+ * @param {string} [cwd]
+ * @returns {Array<{ tree: string, path: string, events: Object[] }>}
+ */
+export function loadTelemetryAllTrees(cwd = process.cwd()) {
+  const root = resolvePrimaryRoot(cwd);
+  const entries = parseWorktreeList(root);
+  const trees = entries.length ? entries : [{ path: root }];
+
+  const out = [];
+  for (const t of trees) {
+    const eventsPath = join(t.path, EVENTS_FILE);
+    if (!existsSync(eventsPath)) continue;
+    out.push({
+      tree: t.path === root ? 'root' : basename(t.path),
+      path: t.path,
+      events: loadTelemetry(t.path),
+    });
+  }
+  return out;
+}
+
 function rank(map) {
   return [...map.entries()]
     .map(([name, count]) => ({ name, count }))
@@ -211,6 +251,26 @@ function finalizeTask(state) {
  * check) — today only Read events carry `bytes`, but this stays correct if
  * that widens rather than reporting a silent 0.
  *
+ * 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 events (`{ event: 'SessionUsage', inputTokens, outputTokens,
+ * cacheReadTokens, cacheCreationTokens }`) are a session-level rollup, not a
+ * per-tool event — they don't touch toolCounts/bytesByKind/dispatches, only
+ * sum into `sessionUsage` (real, hook-observed token counts — NOT the bytes
+ * proxy). They participate in the `--feature` filter exactly like every
+ * other event (via `scoped`, computed once at the top): a rollup with no
+ * `feature` field is silently excluded by a feature-scoped call, same as any
+ * other feature-less event would be — no special-casing. `sessionUsage` is
+ * `null` when the stream carries none (nothing to show), never a zeroed
+ * object, so a caller can tell "observed, all zero" apart from "never
+ * observed" the same way `evalScore` does in gate-check's signals.
+ *
  * @param {Object[]} events - raw events (from loadTelemetry)
  * @param {{ feature?: string }} [opts] - optional feature filter
  * @returns {{
@@ -220,11 +280,14 @@ function finalizeTask(state) {
  *   bytesByKind: Object<string, number>,
  *   bytesTotal: number,
  *   dispatches: {count:number, promptChars:number},
+ *   sessionUsage: {inputTokens:number, outputTokens:number, cacheReadTokens:number, cacheCreationTokens:number, sessions:number}|null,
  *   tools: Array<{name:string,count:number}>,
  *   tasks: Array<Object>,
  *   phases: Array<{phase:string, bytesByKind:Object<string,number>, bytesTotal:number}>,
  * }}
  */
+const SESSION_USAGE_KEYS = ['inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheCreationTokens'];
+
 export function aggregateCost(events, opts = {}) {
   const scoped = opts.feature
     ? (events || []).filter(e => e.feature === opts.feature)
@@ -237,6 +300,8 @@ export function aggregateCost(events, opts = {}) {
   const phaseBytes = new Map(); // phase -> Map(kind -> bytes)
   const activeByFeature = new Map(); // featureKey -> open task state
   const tasks = [];
+  const sessionUsageTotals = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0 };
+  let sessionUsageCount = 0;
 
   for (const e of scoped) {
     if (!e || typeof e !== 'object') continue;
@@ -260,6 +325,14 @@ export function aggregateCost(events, opts = {}) {
       continue;
     }
 
+    if (e.event === 'SessionUsage') {
+      sessionUsageCount += 1;
+      for (const key of SESSION_USAGE_KEYS) {
+        if (typeof e[key] === 'number' && Number.isFinite(e[key])) sessionUsageTotals[key] += e[key];
+      }
+      continue;
+    }
+
     if (e.tool) toolCounts.set(e.tool, (toolCounts.get(e.tool) || 0) + 1);
     const active = activeByFeature.get(featureKey(e));
     if (active && e.tool) {
@@ -277,12 +350,14 @@ export function aggregateCost(events, opts = {}) {
       }
     }
 
-    if ((e.tool === 'Agent' || e.tool === 'Task') && typeof e.prompt === 'string' && e.prompt) {
+    const hasPromptChars = typeof e.promptChars === 'number' && Number.isFinite(e.promptChars);
+    if ((e.tool === 'Agent' || e.tool === 'Task') && (hasPromptChars || (typeof e.prompt === 'string' && e.prompt))) {
+      const chars = hasPromptChars ? e.promptChars : e.prompt.length;
       dispatches.count += 1;
-      dispatches.promptChars += e.prompt.length;
+      dispatches.promptChars += chars;
       if (active) {
         active.dispatches.count += 1;
-        active.dispatches.promptChars += e.prompt.length;
+        active.dispatches.promptChars += chars;
       }
     }
   }
@@ -309,6 +384,7 @@ export function aggregateCost(events, opts = {}) {
     bytesByKind: mapToObj(bytesByKindGlobal),
     bytesTotal: sumValues(bytesByKindGlobal),
     dispatches,
+    sessionUsage: sessionUsageCount > 0 ? { ...sessionUsageTotals, sessions: sessionUsageCount } : null,
     tools: rank(toolCounts),
     tasks,
     phases,

package/src/scripts/setup-infra.js

@@ -27,11 +27,12 @@ import {
 } from '../utils/file-copier.js';
 import { parseStacks, getProjectTags, shouldInstall } from '../lib/stack-filter.js';
 import { injectMorphImport } from '../utils/claude-md-injector.js';
-import { saveProjectMorphVersion, getInstalledCLIVersion } from '../utils/version-checker.js';
+import { saveProjectMorphVersion, getInstalledCLIVersion, getProjectMorphVersion } from '../utils/version-checker.js';
 import { installClaudeHooks, installGlobalStatusline } from '../utils/claude-settings-manager.js';
 import { installSkills } from '../utils/skills-installer.js';
 import { installAgents, installDomainAgents } from '../utils/agents-installer.js';
 import { resolvePrimaryRoot } from '../commands/project/worktree.js';
+import { reconcileLegacyTemplatesCopy } from '../lib/installers/templates-reconcile.js';
 
 const FRAMEWORK_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'framework');
 
@@ -275,12 +276,29 @@ export async function setupInfra(targetPath, { _exec = execSync, reinstall = fal
   // byte-for-byte redundant 348KB copy on every install/update.
   log('Step 5: Skipping framework templates copy (resolved from package; local override still supported)...');
   // Cópia legada de instalação pré-R3: se existir, ela SOMBREIA os templates
-  // do pacote (override-first). O `morph-spec update` reconcilia (remove cópia
-  // stale por fronteira de versão); aqui só avisamos — init não conhece a
-  // versão anterior do projeto para decidir com segurança.
+  // do pacote (override-first). `update` sempre reconcilia porque
+  // checkProjectOutdated() já leu a versão anterior do projeto antes de
+  // chamar update. Aqui (init/setup-infra) fazemos o mesmo QUANDO a mesma
+  // fonte está disponível: getProjectMorphVersion() lê .morph/.morphversion
+  // — o MESMO arquivo/campo que checkProjectOutdated().current usa — e essa
+  // leitura acontece ANTES do Passo 17 (saveProjectMorphVersion) sobrescrever
+  // esse arquivo com a versão atual, então "versão anterior" aqui é real, não
+  // a que este próprio run está prestes a gravar. Sem esse registro (projeto
+  // nunca rastreado antes, ou greenfield), não há fonte segura — mantém o
+  // aviso como fallback, igual ao comportamento anterior.
   const legacyTemplatesDir = join(frameworkDestDir, 'templates');
   if (await pathExists(legacyTemplatesDir)) {
-    log('  ⚠ .morph/framework/templates/ existe (instalação antiga) e tem precedência sobre os templates do pacote — rode `morph-spec update` para reconciliar, ou apague se não for customização sua.');
+    const priorVersionInfo = await getProjectMorphVersion(targetPath);
+    if (priorVersionInfo) {
+      const result = reconcileLegacyTemplatesCopy(legacyTemplatesDir, priorVersionInfo.morphVersion);
+      if (result === 'removed-legacy') {
+        log('  ✓ .morph/framework/templates/ (cópia legada de instalação antiga removida — resolvida do pacote)');
+      } else {
+        log('  ⚠ .morph/framework/templates/ (override local presente, versão anterior pós-R3 — preservado, não reconciliado)');
+      }
+    } else {
+      log('  ⚠ .morph/framework/templates/ existe (instalação antiga) e tem precedência sobre os templates do pacote — sem versão anterior registrada em .morph/.morphversion para decidir com segurança; rode `morph-spec update` para reconciliar, ou apague se não for customização sua.');
+    }
   }
 
   // --- 6. Copy framework/standards → .morph/framework/standards ---