@polymorphism-tech/morph-spec 8.37.1 → 8.38.0

package/framework/hooks/claude-code/core/validate-completion.js

@@ -21,7 +21,7 @@
  * Fail-open: exits 0 on any error.
  */
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync, statSync } from 'fs';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { createHash } from 'crypto';
 import { runBuildCheck } from '../../shared/build-check.js';
@@ -31,6 +31,7 @@ import {
 import { contextResult, runStandalone } from '../../shared/hook-response.js';
 import { logHookActivity, logEvent } from '../../shared/activity-logger.js';
 import { appendTelemetryEvent } from '../../shared/telemetry-logger.js';
+import { readTranscriptUsage, usageDelta } from '../../shared/transcript-usage.js';
 
 /**
  * Audit recap.md against tasks.json + standard-citation rule.
@@ -122,80 +123,6 @@ function auditRecapAndTasks(featurePath) {
   return warnings;
 }
 
-// Safety valve for a pathological outlier transcript — NOT needed for the
-// normal case: a real 45 MB / ~16k-line transcript (inspected directly while
-// building this) parses+sums in ~350ms locally, well inside a Stop hook's
-// budget. Above this, skip rather than risk an unbounded read.
-const MAX_TRANSCRIPT_BYTES = 50 * 1024 * 1024; // 50 MB
-
-/**
- * Sum real token usage from a Claude Code session transcript (JSONL, the
- * `transcript_path` the Stop payload carries).
- *
- * Each assistant TURN is written to the transcript as MULTIPLE JSONL lines —
- * one per content block (thinking/text/tool_use) — every one of them
- * repeating the exact SAME turn-level `message.usage` object under the same
- * `message.id`. Verified against a real transcript: 5982 assistant lines but
- * only 3315 unique message ids, with byte-identical usage across duplicates
- * of the same id — summing every line naively double/triple-counts (measured
- * ~2x on output_tokens on that file). This is why a per-line sum is wrong and
- * a dedup-by-id sum is required; there is no running/cumulative total field
- * to lean on instead — each turn's `usage` is that turn's own cost.
- *
- * Tolerant to shape: any missing usage field reads as 0. A corrupt/truncated
- * line is skipped, not fatal — same discipline as telemetry-logger's reader.
- *
- * @param {string} [transcriptPath]
- * @returns {{inputTokens:number,outputTokens:number,cacheReadTokens:number,cacheCreationTokens:number}|null}
- *   null when there is nothing to report (no path, missing/oversized/
- *   unreadable file, or zero assistant messages carrying usage).
- */
-function computeSessionUsage(transcriptPath) {
-  if (!transcriptPath || typeof transcriptPath !== 'string') return null;
-  try {
-    if (!existsSync(transcriptPath)) return null;
-    if (statSync(transcriptPath).size > MAX_TRANSCRIPT_BYTES) return null;
-
-    const raw = readFileSync(transcriptPath, 'utf-8');
-    let inputTokens = 0, outputTokens = 0, cacheReadTokens = 0, cacheCreationTokens = 0;
-    const seenMessageIds = new Set();
-    let sawAny = false;
-
-    for (const line of raw.split('\n')) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      let entry;
-      try {
-        entry = JSON.parse(trimmed);
-      } catch {
-        continue; // one corrupt/truncated line must not lose the whole transcript
-      }
-      if (entry?.type !== 'assistant') continue;
-      const usage = entry?.message?.usage;
-      if (!usage || typeof usage !== 'object') continue;
-
-      // Dedup by message.id (fallback to the line's own uuid when a message
-      // carries none) — first occurrence wins, duplicates carry identical
-      // values so which one wins never matters.
-      const dedupKey = entry?.message?.id || entry?.uuid;
-      if (dedupKey) {
-        if (seenMessageIds.has(dedupKey)) continue;
-        seenMessageIds.add(dedupKey);
-      }
-
-      sawAny = true;
-      inputTokens += Number(usage.input_tokens) || 0;
-      outputTokens += Number(usage.output_tokens) || 0;
-      cacheReadTokens += Number(usage.cache_read_input_tokens) || 0;
-      cacheCreationTokens += Number(usage.cache_creation_input_tokens) || 0;
-    }
-
-    return sawAny ? { inputTokens, outputTokens, cacheReadTokens, cacheCreationTokens } : null;
-  } catch {
-    return null; // fail-open
-  }
-}
-
 // Phases where compaction is strongly recommended before starting
 const COMPACT_TRIGGER_PHASES = new Set(['implement']);
 
@@ -343,13 +270,11 @@ export async function run(payload) {
     // ────────────────────────────────────────────────────────────────────────
 
     // ── Session usage (real tokens, from the transcript) ──────────────────────
-    // Silent side effect — never contributes to `warnings`/additionalContext,
-    // same as telemetry-log.js's capture. Throttled: only re-emitted when the
-    // computed totals actually changed since the last SessionUsage recorded
-    // for this session_id, so an unchanged transcript across consecutive
-    // Stops (no new assistant turn) does not re-append an identical event.
+    // Silent side effect. The transcript total is cumulative, so each event
+    // also carries the `delta` since the previous sample of the same session:
+    // summing deltas per sessionId is the only sum that does not double-count.
     try {
-      const usage = computeSessionUsage(payload?.transcript_path);
+      const usage = readTranscriptUsage(payload?.transcript_path);
       if (usage) {
         const usagePath = join(memDir, 'session-usage.json');
         let stored = {};
@@ -358,15 +283,16 @@ export async function run(payload) {
         } catch { /* corrupt file — start fresh */ }
 
         const sessionKey = payload?.session_id || 'default';
-        const last = stored[sessionKey];
-        const unchanged = last
-          && last.inputTokens === usage.inputTokens
-          && last.outputTokens === usage.outputTokens
-          && last.cacheReadTokens === usage.cacheReadTokens
-          && last.cacheCreationTokens === usage.cacheCreationTokens;
-
-        if (!unchanged) {
-          appendTelemetryEvent({ event: 'SessionUsage', ...usage }, cwd);
+        const { delta, changed } = usageDelta(stored[sessionKey], usage);
+        if (changed) {
+          appendTelemetryEvent({
+            event: 'SessionUsage',
+            sessionId: payload?.session_id ?? null,
+            feature: name,
+            phase: currentPhase,
+            ...usage,
+            delta,
+          }, cwd);
           stored[sessionKey] = usage;
           try { writeFileSync(usagePath, JSON.stringify(stored, null, 2), 'utf-8'); } catch { /* non-blocking */ }
         }

package/framework/hooks/claude-code/core/worktree-context.js

@@ -50,6 +50,7 @@ import { contextResult, runStandalone } from '../../shared/hook-response.js';
 import { acquireClaim, foreignClaim, claimAge } from '../../shared/claim-registry.js';
 import { rotateActivityLogIfLarge } from '../../shared/activity-logger.js';
 import { rotateEventsLogIfLarge } from '../../shared/telemetry-logger.js';
+import { kickGraphRefresh, seedFromPrimary } from '../../shared/graph-refresh.js';
 
 function projectDir() {
   return process.env.CLAUDE_PROJECT_DIR || process.cwd();
@@ -293,6 +294,15 @@ export async function run(payload) {
     // helpers are themselves fail-open (return false on any error).
     try { rotateActivityLogIfLarge(dir); } catch { /* non-blocking */ }
     try { rotateEventsLogIfLarge(dir); } catch { /* non-blocking */ }
+    // Between sessions is where commits made outside the agent (a terminal, an
+    // IDE, a `git pull`) are caught: the detached refresh brings the ROOT's
+    // graph to HEAD — never a worktree's (a detached process holding a
+    // worktree directory made `finish` fail on win32). A worktree that has no
+    // graph yet (created before seeding existed) gets the root's copy here;
+    // from then on it is refreshed by hand (`morph-spec graph refresh`).
+    // Returns immediately — nothing here waits on graphify.
+    try { seedFromPrimary(dir); } catch { /* non-blocking — a no-op on the root */ }
+    try { kickGraphRefresh(dir); } catch { /* non-blocking */ }
 
     if (isSecondaryWorktree(dir)) {
       const task = taskFromBranch(dir);

package/framework/hooks/shared/command-tokens.js

@@ -21,3 +21,99 @@ export function tokenize(command) {
   while ((m = re.exec(String(command || ''))) !== null) tokens.push(m[1] ?? m[2] ?? m[3]);
   return tokens;
 }
+
+/** Index of the first pipe (`|`, not `||` nor `>|`) outside quotes, or -1. */
+function firstUnquotedPipe(command) {
+  const s = String(command || '');
+  let quote = null;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+      else if (ch === '\\' && quote === '"') i++;
+      continue;
+    }
+    if (ch === '\\') { i++; continue; }
+    if (ch === '"' || ch === "'") { quote = ch; continue; }
+    if (ch !== '|') continue;
+    if (s[i + 1] === '|') { i++; continue; }
+    if (s[i - 1] === '>') continue;
+    return i;
+  }
+  return -1;
+}
+
+/**
+ * Does the command pipe one process into another outside quotes? Without
+ * `pipefail` the shell reports the LAST command's status, so the exit code of
+ * `dotnet test … | grep …` is grep's, not the test run's.
+ * @param {string} command
+ * @returns {boolean}
+ */
+export function hasUnquotedPipe(command) {
+  return firstUnquotedPipe(command) >= 0;
+}
+
+/**
+ * The work a command does, without the filter that shapes its output:
+ * `dotnet test 2>&1 | tail -25` and `dotnet test | tail -20` run the same
+ * tests. Whitespace collapsed, stderr redirections dropped.
+ * @param {string} command
+ * @returns {string}
+ */
+export function producerOf(command) {
+  const s = String(command || '');
+  const pipe = firstUnquotedPipe(s);
+  return (pipe >= 0 ? s.slice(0, pipe) : s)
+    .replace(/\s2>(&1|\/dev\/null|nul)\b/gi, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+/**
+ * The command split at `;`, newline and background `&` outside quotes, plus
+ * whether a background `&` was seen. `&&`, `||` and `>&`/`&>` redirections
+ * stay inside their segment.
+ */
+function topLevelSegments(command) {
+  const s = String(command || '');
+  const segments = [];
+  let start = 0;
+  let background = false;
+  let quote = null;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+      else if (ch === '\\' && quote === '"') i++;
+      continue;
+    }
+    if (ch === '\\') { i++; continue; }
+    if (ch === '"' || ch === "'") { quote = ch; continue; }
+    const isAmp = ch === '&' && s[i + 1] !== '&' && s[i - 1] !== '&' && s[i - 1] !== '>' && s[i + 1] !== '>';
+    if (ch !== ';' && ch !== '\n' && !isAmp) continue;
+    if (isAmp) background = true;
+    segments.push(s.slice(start, i));
+    start = i + 1;
+  }
+  segments.push(s.slice(start));
+  return { segments: segments.map((x) => x.trim()).filter(Boolean), background };
+}
+
+const REPORTER = /^(?:echo|printf|true|:|exit\s+0)\b/;
+
+/**
+ * Is the exit code of this command the exit code of the work it ran? The
+ * shell reports the last segment of a `;` sequence: `dotnet test > log;
+ * echo "exit=$?"` always exits 0, and so does `dotnet test || true`. A pipe
+ * without `pipefail` reports the filter, and a background `&` reports 0.
+ * @param {string} command
+ * @returns {boolean}
+ */
+export function exitCodeMasked(command) {
+  const { segments, background } = topLevelSegments(command);
+  if (background) return true;
+  if (hasUnquotedPipe(command) && !/\bpipefail\b/.test(String(command || ''))) return true;
+  const last = segments[segments.length - 1] || '';
+  return (segments.length > 1 && REPORTER.test(last)) || /\|\|/.test(last.replace(/"[^"]*"|'[^']*'/g, ''));
+}

package/framework/hooks/shared/git-exclude.js

@@ -0,0 +1,44 @@
+/**
+ * git-exclude.js — o escritor ÚNICO dos blocos que o morph-spec mantém no
+ * `info/exclude` do git.
+ *
+ * O arquivo lido é o do COMMON dir (`git rev-parse --git-common-dir`), nunca o
+ * `.git/worktrees/<id>/info/exclude`: o git não lê o deste para uma worktree
+ * vinculada, e o do common dir vale para toda árvore do repositório — inclusive
+ * a raiz primária. Cada chamador passa o seu marcador, e o bloco só ganha as
+ * linhas que ainda faltam.
+ *
+ * Idempotente e fail-open: um exclude que não pôde ser escrito custa um
+ * arquivo aparecendo como `??`, nunca um erro.
+ */
+
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { resolveGitCommonDir } from './git-paths.js';
+
+/**
+ * @param {string} cwd - qualquer diretório dentro do repositório
+ * @param {string[]} patterns - linhas prontas (já ancoradas, ex. `/graphify-out`)
+ * @param {string} marker - comentário que identifica o bloco do chamador
+ */
+export function ensureCommonExclude(cwd, patterns, marker) {
+  if (!patterns.length) return;
+  try {
+    // Pelo disco, sem subprocesso: um `git` gerado aqui abria uma janela de
+    // console no win32 quando o chamador era um processo destacado.
+    const common = resolveGitCommonDir(cwd);
+    if (!common) return;
+    const infoDir = join(common, 'info');
+    const excludePath = join(infoDir, 'exclude');
+    const current = existsSync(excludePath) ? readFileSync(excludePath, 'utf8') : '';
+    const present = new Set(current.split(/\r?\n/).map((l) => l.trim()));
+    const missing = patterns.filter((p) => !present.has(p));
+    if (!missing.length) return;
+    mkdirSync(infoDir, { recursive: true });
+    appendFileSync(excludePath, [
+      current && !current.endsWith('\n') ? '\n' : '',
+      present.has(marker) ? '' : `${marker}\n`,
+      `${missing.join('\n')}\n`,
+    ].join(''));
+  } catch { /* fail-open */ }
+}

package/framework/hooks/shared/git-paths.js

@@ -83,6 +83,23 @@ export function isSecondaryWorktree(startDir) {
   }
 }
 
+/**
+ * Top of the working tree that contains `startDir` — the directory holding the
+ * nearest `.git` (file or directory), which is what `git rev-parse
+ * --show-toplevel` answers, without the subprocess. `null` outside any repo.
+ *
+ * @param {string} startDir
+ * @returns {string|null}
+ */
+export function workTreeTop(startDir) {
+  try {
+    const found = findDotGit(startDir);
+    return found ? dirname(found.path) : null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Resolve the git COMMON dir for `startDir` — pure filesystem, no subprocess.
  * Always returns an absolute path (unlike `git rev-parse --git-common-dir`,
@@ -117,3 +134,38 @@ export function resolveGitCommonDir(startDir) {
     return null;
   }
 }
+
+const SHA = /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/;
+
+/**
+ * The commit HEAD points at in the PRIMARY checkout `root`, read from disk —
+ * `git rev-parse HEAD` without the subprocess: a detached SHA, or the branch's
+ * loose ref, then `packed-refs`. `null` for every shape it does not read (a
+ * linked worktree, reftable, a branch with no commit yet): the caller asks git.
+ *
+ * @param {string} root
+ * @returns {string|null}
+ */
+export function readPrimaryHead(root) {
+  try {
+    const gitDir = join(root, '.git');
+    if (!statSync(gitDir).isDirectory()) return null;
+    const head = readFileSync(join(gitDir, 'HEAD'), 'utf8').trim();
+    if (SHA.test(head)) return head;
+    const ref = /^ref:\s*(refs\/\S+)$/.exec(head)?.[1];
+    if (!ref) return null;
+    try {
+      const loose = readFileSync(join(gitDir, ref), 'utf8').trim();
+      if (SHA.test(loose)) return loose;
+    } catch {
+      // not loose — packed
+    }
+    for (const line of readFileSync(join(gitDir, 'packed-refs'), 'utf8').split(/\r?\n/)) {
+      const [sha, name] = line.split(' ');
+      if (name === ref && SHA.test(sha)) return sha;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}