@polymorphism-tech/morph-spec 9.8.0 → 10.1.1

package/src/lib/scout/scout-check.js

@@ -1,293 +0,0 @@
-import { execFileSync } from 'child_process';
-import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
-import { join, relative, resolve } from 'path';
-import { workTreeTop } from '../../../framework/hooks/shared/git-paths.js';
-
-export const LINE_TOLERANCE = 2;
-
-const SPAN = /`([^`\n]+)`/g;
-const SPAN_CITATION = /^(.+\.[A-Za-z0-9]+):(\d+)(?:-(\d+))?$/;
-const BARE_CITATION = /(?<![\w.:\\/-])(?:[A-Za-z]:)?[\w.\\/-]*\w\.[A-Za-z0-9]+:(\d+)(?:-(\d+))?\b/g;
-const GREP_LINE = /^((?:[A-Za-z]:)?[^\s:]+\.[A-Za-z0-9]+)(?::(\d+):|-(\d+)-)(.*)$/;
-const FENCE = /^\s*(```|~~~)/;
-const HEADING = /^\s{0,3}#{1,6}\s+(.*)$/;
-const INFERENCE_HEADING = /inferid|hip[óo]tese|inferred|hypothes/i;
-const INFERENCE_MARKER = /\b(INFERIDO|hip[óo]tese)\b/i;
-const COMMAND_SPAN = /^(rg|grep|git\s+grep|morph-spec\s+graph|findstr|Select-String|sls)\b/;
-const COUNT = /(?:→|->|=>)\s*\d+|\b\d+\s+(?:ocorr[êe]ncias?|arquivos?|linhas?|hits?|resultados?|matches?|files?|lines?)\b/i;
-const PATH_SPAN = /^(?:[\w.-]*[\\/])+[\w.-]+$|^[\w.-]+\.(?:cs|csproj|fs|vb|razor|js|mjs|cjs|ts|tsx|jsx|json|md|py|go|java|sql|ya?ml|xml|props|targets|sln)$/i;
-
-const VERDICTS = [
-  /\b(?:VIVO|VIVA|MORTO|MORTA|ALIVE|DEAD)\b/,
-  /\b(?:c[óo]digo morto|dead code|unused)\b/i,
-  /\bsem (?:nenhum )?(?:consumidor|chamador|leitor|escritor|setter|uso|refer[êe]ncia|teste)s?\b/i,
-  /(?<!\b(?:execut|rod)\w*\s)\bnenhum[a]? (?:consumidor|chamador|leitor|escritor|setter|uso|refer[êe]ncia|teste|caller|call site)s?\b/i,
-  /\bningu[ée]m (?:chama|usa|l[êe]|escreve|grava|consome|referencia)\b/i,
-  /\bn[ãa]o (?:é|est[áa]) (?:usad|chamad|lid|referenciad|escrit)/i,
-  /\bnunca (?:é )?(?:usad|chamad|lid|escrit)/i,
-  /\bn[ãa]o h[áa] (?:consumidor|chamador|leitor|escritor|uso|teste|refer[êe]ncia)/i,
-  /\bno (?:callers?|consumers?|readers?|writers?|tests?|usages?)\b/i,
-];
-
-const WALK_SKIP = new Set(['node_modules', '.git', 'bin', 'obj', 'worktrees', '.worktrees']);
-
-function splitLines(text) {
-  const lines = text.replace(/^/, '').split(/\r?\n/);
-  if (lines.length > 1 && lines[lines.length - 1] === '') lines.pop();
-  return lines;
-}
-
-const squash = (s) => s.replace(/\s+/g, ' ').trim();
-
-function lineTokens(line) {
-  const tokens = [];
-  const masked = line.replace(SPAN, (whole, inner, index) => {
-    const cite = inner.trim().match(SPAN_CITATION);
-    if (cite) tokens.push({ index, cite: { raw: inner.trim(), path: cite[1], start: +cite[2], end: +(cite[3] ?? cite[2]) } });
-    else tokens.push({ index, quote: inner });
-    return ' '.repeat(whole.length);
-  });
-  for (const m of masked.matchAll(BARE_CITATION)) {
-    const cite = m[0].match(SPAN_CITATION);
-    if (cite) tokens.push({ index: m.index, cite: { raw: m[0], path: cite[1], start: +cite[2], end: +(cite[3] ?? cite[2]) } });
-  }
-  return tokens.sort((a, b) => a.index - b.index);
-}
-
-function citationsOf(line) {
-  const tokens = lineTokens(line);
-  const out = [];
-  tokens.forEach((t, i) => {
-    if (!t.cite) return;
-    let quote = null;
-    for (const next of tokens.slice(i + 1)) {
-      if (next.cite) break;
-      const q = next.quote.trim();
-      if (COMMAND_SPAN.test(q) || PATH_SPAN.test(q)) continue;
-      quote = next.quote;
-      break;
-    }
-    out.push({ ...t.cite, quote });
-  });
-  return out;
-}
-
-function makeFileLister(root) {
-  let files = null;
-  return () => {
-    if (files) return files;
-    try {
-      files = execFileSync('git', ['ls-files', '-z', '--cached', '--others', '--exclude-standard'], {
-        cwd: root, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true, maxBuffer: 64 * 1024 * 1024,
-      }).toString().split('\0').filter(Boolean);
-    } catch {
-      files = [];
-      const walk = (dir) => {
-        for (const entry of readdirSync(dir, { withFileTypes: true })) {
-          if (WALK_SKIP.has(entry.name)) continue;
-          const full = join(dir, entry.name);
-          if (entry.isDirectory()) walk(full);
-          else files.push(relative(root, full).replace(/\\/g, '/'));
-        }
-      };
-      walk(root);
-    }
-    return files;
-  };
-}
-
-const isFile = (p) => existsSync(p) && statSync(p).isFile();
-
-function resolveCitedPath(rawPath, root, listFiles) {
-  const p = rawPath.replace(/\\/g, '/').replace(/^\.\//, '');
-  if (/^[A-Za-z]:\//.test(p) || p.startsWith('/')) {
-    return isFile(p) ? { path: p } : { problem: 'missing-file' };
-  }
-  const direct = join(root, p);
-  if (isFile(direct)) return { path: direct };
-  const fold = process.platform === 'win32' ? (s) => s.toLowerCase() : (s) => s;
-  const suffix = fold(`/${p}`);
-  const candidates = listFiles().filter((f) => fold(`/${f}`).endsWith(suffix));
-  if (candidates.length === 1) return { path: join(root, candidates[0]) };
-  if (candidates.length > 1) return { problem: 'ambiguous-path', candidates };
-  return { problem: 'missing-file' };
-}
-
-function quoteAppears(quote, lines, start, end) {
-  const from = Math.max(0, start - 1 - LINE_TOLERANCE);
-  const to = Math.min(lines.length, end + LINE_TOLERANCE);
-  const window = squash(lines.slice(from, to).join(' '));
-  let at = 0;
-  for (const fragment of quote.split(/\.\.\.|…/).map(squash).filter(Boolean)) {
-    const found = window.indexOf(fragment, at);
-    if (found === -1) return false;
-    at = found + fragment.length;
-  }
-  return true;
-}
-
-function auditCitation(cite, root, listFiles, readCache) {
-  const where = resolveCitedPath(cite.path, root, listFiles);
-  if (where.problem === 'ambiguous-path') {
-    return { kind: 'ambiguous-path', detail: `${where.candidates.length} arquivos casam: ${where.candidates.slice(0, 5).join(', ')}` };
-  }
-  if (where.problem) return { kind: 'missing-file', detail: `${cite.path} não existe sob ${root}` };
-  if (!readCache.has(where.path)) readCache.set(where.path, splitLines(readFileSync(where.path, 'utf8')));
-  const lines = readCache.get(where.path);
-  cite.resolved = where.path;
-  if (cite.start < 1 || cite.end < cite.start || cite.end > lines.length) {
-    return { kind: 'line-out-of-range', detail: `o arquivo tem ${lines.length} linhas` };
-  }
-  const quotes = cite.quote != null ? [cite.quote] : cite.fence;
-  if (!quotes) {
-    return cite.listing ? null : { kind: 'missing-quote', detail: 'a citação não traz o trecho literal em crase depois dela' };
-  }
-  const missing = quotes.find((q) => !quoteAppears(q, lines, cite.start, cite.end));
-  if (missing != null) {
-    return {
-      kind: 'quote-mismatch',
-      detail: `trecho ausente nas linhas ${Math.max(1, cite.start - LINE_TOLERANCE)}-${Math.min(lines.length, cite.end + LINE_TOLERANCE)}; linha ${cite.start}: ${squash(lines[cite.start - 1])}`,
-    };
-  }
-  cite.verified = true;
-  return null;
-}
-
-const asMention = (line) => line.replace(SPAN, ' ').replace(/"[^"\n]*"|“[^”\n]*”/g, ' ');
-
-const isVerdict = (line) =>
-  VERDICTS[0].test(line.replace(SPAN, ' ')) || VERDICTS.slice(1).some((re) => re.test(asMention(line)));
-
-const hasSearchCommand = (line) => [...line.matchAll(SPAN)].some((m) => COMMAND_SPAN.test(m[1].trim()));
-
-function underSearchCommand(lines, i) {
-  for (let j = i - 1; j >= 0; j--) {
-    if (hasSearchCommand(lines[j])) return true;
-    if (HEADING.test(lines[j])) return false;
-  }
-  return false;
-}
-
-function auditVerdict(line, evidence, inInference) {
-  if (!inInference && !INFERENCE_MARKER.test(line)) {
-    return { kind: 'verdict-outside-inference', detail: 'veredito de ausência/vida fora da seção de hipóteses (Inferido)' };
-  }
-  const spans = [...evidence.matchAll(SPAN)].map((m) => m[1].trim());
-  if (!spans.some((s) => COMMAND_SPAN.test(s))) {
-    return { kind: 'verdict-without-command', detail: 'hipótese de ausência/vida sem o comando de busca usado, em crase' };
-  }
-  if (!COUNT.test(evidence)) return { kind: 'verdict-without-count', detail: 'hipótese de ausência/vida sem a contagem bruta do comando' };
-  return null;
-}
-
-function fenceAfter(lines, i) {
-  let j = i + 1;
-  while (j < lines.length && lines[j].trim() === '') j++;
-  if (j >= lines.length || !FENCE.test(lines[j])) return null;
-  const body = [];
-  for (let k = j + 1; k < lines.length && !FENCE.test(lines[k]); k++) {
-    const text = lines[k].replace(/^\s*:?\d+[:\s]\s*/, '').trim();
-    if (text) body.push(text);
-  }
-  return body.length ? body : null;
-}
-
-const indentOf = (line) => line.match(/^\s*/)[0].length;
-const BULLET = /^\s*([-*+]|\d+[.)])\s/;
-
-function itemStart(lines, i) {
-  let start = i;
-  for (let j = i - 1; j >= 0 && lines[j].trim() !== '' && !HEADING.test(lines[j]); j--) {
-    if (BULLET.test(lines[j]) && indentOf(lines[j]) < indentOf(lines[start])) start = j;
-  }
-  return start;
-}
-
-function continuationEnd(lines, i) {
-  const indent = indentOf(lines[i]);
-  let j = i + 1;
-  while (j < lines.length && lines[j].trim() !== '' && !HEADING.test(lines[j]) && !FENCE.test(lines[j])) {
-    if (indentOf(lines[j]) <= indent && BULLET.test(lines[j])) break;
-    j++;
-  }
-  return j;
-}
-
-export function resolveScoutRoot(root, cwd = process.cwd()) {
-  return root ? resolve(cwd, root) : (workTreeTop(cwd) ?? cwd);
-}
-
-export function checkScoutMap(text, { root }) {
-  const lines = splitLines(text);
-  const listFiles = makeFileLister(root);
-  const readCache = new Map();
-  const failures = [];
-  const citations = [];
-  let verdicts = 0;
-  let inFence = false;
-  let inferenceLevel = null;
-  let subsectionStart = null;
-
-  const audit = (cite, lineNo) => {
-    citations.push(cite);
-    const problem = auditCitation(cite, root, listFiles, readCache);
-    if (problem) failures.push({ line: lineNo, citation: cite.raw, cite, ...problem });
-  };
-  const subsectionText = (from) => {
-    let to = from + 1;
-    while (to < lines.length && !HEADING.test(lines[to])) to++;
-    return lines.slice(from, to).join('\n');
-  };
-
-  lines.forEach((line, i) => {
-    const lineNo = i + 1;
-    if (FENCE.test(line)) { inFence = !inFence; return; }
-    if (inFence) {
-      const grep = line.trim().match(GREP_LINE);
-      if (grep) {
-        const n = +(grep[2] ?? grep[3]);
-        audit({ raw: `${grep[1]}:${n}`, path: grep[1], start: n, end: n, quote: grep[4].trim() || null }, lineNo);
-      }
-      return;
-    }
-    const heading = line.match(HEADING);
-    if (heading) {
-      const level = line.trim().match(/^#+/)[0].length;
-      if (INFERENCE_HEADING.test(heading[1])) { inferenceLevel = level; subsectionStart = null; }
-      else if (inferenceLevel != null && level > inferenceLevel) subsectionStart = i;
-      else { inferenceLevel = null; subsectionStart = null; }
-    }
-
-    const cites = citationsOf(line);
-    const residue = cites.reduce((rest, c) => rest.split(c.raw).join(' '), line)
-      .replace(/[`*_|>()[\]\-+:;,.—–\s]|\d+[.)]/g, '');
-    for (const cite of cites) {
-      if (cite.quote == null) {
-        cite.fence = fenceAfter(lines, i);
-        cite.listing = residue === '' && underSearchCommand(lines, i);
-      }
-      audit(cite, lineNo);
-    }
-
-    if (!isVerdict(line)) return;
-    verdicts++;
-    const evidence = subsectionStart != null
-      ? subsectionText(subsectionStart)
-      : lines.slice(itemStart(lines, i), continuationEnd(lines, itemStart(lines, i))).join('\n');
-    const verdict = auditVerdict(line, evidence, inferenceLevel != null);
-    if (verdict) failures.push({ line: lineNo, text: squash(line), ...verdict });
-  });
-
-  const covered = (c) => citations.some((v) => v.verified && v.resolved === c.resolved && v.start <= c.start && c.end <= v.end);
-  const kept = failures.filter((f) => !(f.kind === 'missing-quote' && covered(f.cite)));
-  if (citations.length === 0) {
-    kept.push({ line: null, kind: 'no-citations', detail: 'o mapa não cita nenhum arquivo:linha — nada nele é verificável' });
-  }
-  return {
-    ok: kept.length === 0,
-    root,
-    citations: citations.map(({ raw, resolved, quote }) => ({ raw, resolved: resolved ?? null, quote })),
-    verdicts,
-    failures: kept.map(({ cite, ...f }) => f),
-  };
-}

package/src/lib/validators/traceability-check.js

@@ -1,103 +0,0 @@
-// Advisory: status is only 'pass' | 'warn' | 'skip', and runVerify() keeps it outside
-// `nodes` so it never flips the verify rollup.
-
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { readPlanChecks } from '../plan/checks.js';
-import { sliceProgress, sliceReportPath } from '../../../framework/hooks/shared/slice-progress.js';
-
-const FILES_BLOCK_RE = /\*\*Arquivos:\*\*([^\r\n]*)\r?\n?((?:^[ \t]*-[ \t].*\r?\n?)*)/gm;
-
-const BACKTICK_RE = /`([^`]+)`/g;
-
-// A later span without `/` is ambiguous shorthand and is skipped, not guessed: false
-// negatives are acceptable for advisory tooling, false positives are not.
-export function extractCitedFiles(reportText) {
-  const cited = new Set();
-  if (!reportText) return [];
-
-  FILES_BLOCK_RE.lastIndex = 0;
-  let blockMatch;
-  while ((blockMatch = FILES_BLOCK_RE.exec(reportText)) !== null) {
-    const bullets = blockMatch[2].split(/\r?\n/).filter((l) => /^[ \t]*-[ \t]/.test(l));
-    for (const line of [blockMatch[1], ...bullets]) {
-      const spans = [...line.matchAll(BACKTICK_RE)].map((m) => m[1].trim()).filter(Boolean);
-      spans.forEach((span, idx) => {
-        if (idx > 0 && !span.includes('/')) return;
-        if (span.includes('{') || span.includes('}')) return;
-        if (span.endsWith('/')) return;
-        cited.add(normalizePath(span));
-      });
-    }
-  }
-
-  return [...cited];
-}
-
-export function normalizePath(p) {
-  return String(p).replace(/\\/g, '/').replace(/^\.\//, '');
-}
-
-/** null when the plan has no readable extraction. */
-export function collectSliceFiles(projectPath, featureName) {
-  const checks = readPlanChecks(projectPath, featureName).checks;
-  if (!checks) return null;
-  return checks.slices.flatMap((slice) => (slice.files ?? [])
-    .filter((f) => typeof f === 'string' && f.trim())
-    .map(normalizePath));
-}
-
-function isCovered(file, declared) {
-  for (const entry of declared) {
-    if (entry === file) return true;
-    if (entry.endsWith('/') && file.startsWith(entry)) return true;
-  }
-  return false;
-}
-
-function readOrNull(path) {
-  try {
-    return existsSync(path) ? readFileSync(path, 'utf8') : null;
-  } catch {
-    return null;
-  }
-}
-
-export function checkOutputsTraceability(projectPath, featureName) {
-  const featureDir = join(projectPath, '.morph', 'features', featureName);
-  const progress = sliceProgress(featureDir);
-  const reports = (progress?.slices ?? [])
-    .map((slice) => ({ id: slice.id, text: readOrNull(sliceReportPath(featureDir, slice.id)) }))
-    .filter((r) => r.text !== null);
-  if (reports.length === 0) {
-    return { status: 'skip', warnings: [], reason: 'no slice reports', citedCount: 0 };
-  }
-
-  const citedBy = new Map();
-  for (const { id, text } of reports) {
-    for (const file of extractCitedFiles(text)) {
-      if (!citedBy.has(file)) citedBy.set(file, []);
-      citedBy.get(file).push(id);
-    }
-  }
-  if (citedBy.size === 0) {
-    return { status: 'skip', warnings: [], reason: 'no Arquivos: entries found in the slice reports', citedCount: 0 };
-  }
-
-  const declared = collectSliceFiles(projectPath, featureName);
-  if (declared === null) {
-    return { status: 'skip', warnings: [], reason: 'no checks.json', citedCount: citedBy.size };
-  }
-
-  const warnings = [...citedBy.keys()]
-    .filter((file) => !isCovered(file, declared))
-    .sort()
-    .map((file) => `${file} — cited in reports/${citedBy.get(file).join(', ')} but declared in no slice's arquivos:`);
-
-  return {
-    status: warnings.length > 0 ? 'warn' : 'pass',
-    warnings,
-    reason: null,
-    citedCount: citedBy.size,
-  };
-}

package/src/lib/worktree/agent-reaper.js

@@ -1,247 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import {
-  closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, statSync, unlinkSync, writeFileSync,
-} from 'node:fs';
-import { basename, join, resolve } from 'node:path';
-import {
-  cwdIsInsideWorktree, isGitRepo, parseWorktreeList, resolvePrimaryRoot, runWorktreeRemove,
-  sessionAnchoredInWorktree,
-} from '../../commands/project/worktree.js';
-import { containerDirs, isUnder } from '../../../framework/hooks/shared/worktree-root.js';
-import { withoutLeftoverIgnore } from '../../../framework/hooks/shared/graph-freshness.js';
-import { resolveGitCommonDir } from '../../../framework/hooks/shared/git-paths.js';
-import { pidAlive } from '../../../framework/hooks/shared/process-alive.js';
-import { readProjectConfig } from '../../../framework/hooks/shared/heavy-config.js';
-
-export const DEFAULT_GRACE_MINUTES = 30;
-
-const AGENT_DIR = /^agent-([0-9a-f]+)$/;
-const AGENT_BRANCH = /^morph-task\/agent-([0-9a-f]+)$/;
-const AGENT_REF = /^refs\/heads\/morph-task\/agent-[0-9a-f]+$/;
-const TAIL_BYTES = 64 * 1024;
-const LOCK_MAX_AGE_MS = 15 * 60_000;
-const SAMPLE = 5;
-
-const norm = (p) => resolve(p).replace(/\\/g, '/');
-const gitOut = (cwd, args, input) => execFileSync('git', args, {
-  cwd, stdio: ['pipe', 'pipe', 'pipe'], encoding: 'utf8', input,
-});
-const sample = (list) => `${list.slice(0, SAMPLE).join(', ')}${list.length > SAMPLE ? `, +${list.length - SAMPLE}` : ''}`;
-
-export function resolveGraceMinutes(root, override) {
-  const valid = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0;
-  if (valid(override)) return override;
-  const configured = readProjectConfig(root)?.worktree?.reap?.graceMinutes;
-  return valid(configured) ? configured : DEFAULT_GRACE_MINUTES;
-}
-
-/**
- * Commits reachable from `tip` and from no other branch, remote or tag; agent branches are left out
- * of the comparison, and `--all` is not used (the agent's own HEAD would protect it). `null` = unmeasured.
- */
-export function exclusiveCommitCount(root, tip) {
-  if (!tip) return null;
-  try {
-    const refs = gitOut(root, ['for-each-ref', '--format=%(refname)', 'refs/heads', 'refs/remotes', 'refs/tags'])
-      .split(/\r?\n/).filter((r) => r && !AGENT_REF.test(r));
-    const input = `${[tip, ...refs.map((r) => `^${r}`)].join('\n')}\n`;
-    const count = Number.parseInt(gitOut(root, ['rev-list', '--count', '--stdin'], input).trim(), 10);
-    return Number.isInteger(count) ? count : null;
-  } catch {
-    return null;
-  }
-}
-
-function tailOfEvents(file) {
-  const fd = openSync(file, 'r');
-  try {
-    const { size, mtimeMs } = fstatSync(fd);
-    const len = Math.min(size, TAIL_BYTES);
-    const buf = Buffer.alloc(len);
-    readSync(fd, buf, 0, len, size - len);
-    const lines = buf.toString('utf8').split(/\r?\n/).filter((l) => l.trim());
-    if (size > len) lines.shift();
-    return { last: lines.at(-1) ?? null, mtimeMs };
-  } finally {
-    closeSync(fd);
-  }
-}
-
-/** `stopped` only when the tree's last event is this agent's own `AgentUsage`. */
-export function readAgentStop(worktreePath, hex) {
-  const file = join(worktreePath, '.morph', 'logs', 'events.jsonl');
-  if (!existsSync(file)) return { status: 'unknown', detail: 'sem .morph/logs/events.jsonl na árvore' };
-  let tail;
-  try { tail = tailOfEvents(file); } catch { return { status: 'unknown', detail: 'events.jsonl ilegível' }; }
-  let event = null;
-  try { event = tail.last ? JSON.parse(tail.last) : null; } catch { event = null; }
-  if (!event || typeof event !== 'object') return { status: 'unknown', detail: 'último evento ilegível' };
-  if (event.event !== 'AgentUsage') return { status: 'active', detail: `último evento: ${event.event ?? '?'}` };
-  if (String(event.agentId ?? '').toLowerCase() !== hex) return { status: 'unknown', detail: 'AgentUsage de outro agente' };
-  return { status: 'stopped', mtimeMs: tail.mtimeMs };
-}
-
-function dirtOf(worktreePath) {
-  try {
-    const lines = gitOut(worktreePath, ['status', '--porcelain', '--untracked-files=all']).split(/\r?\n/).filter((l) => l.trim());
-    return withoutLeftoverIgnore(worktreePath, lines).map((l) => (l.startsWith('??') ? `untracked ${l.slice(3)}` : l.slice(3)));
-  } catch {
-    return null;
-  }
-}
-
-function agentBranches(root) {
-  try {
-    return gitOut(root, ['for-each-ref', '--format=%(refname:short) %(objectname)', 'refs/heads/morph-task/'])
-      .split(/\r?\n/).filter(Boolean)
-      .map((line) => { const [name, sha] = line.split(' '); return { name, sha, hex: AGENT_BRANCH.exec(name)?.[1] }; })
-      .filter((b) => b.hex);
-  } catch {
-    return [];
-  }
-}
-
-function branchTouchedMs(root, branch) {
-  const common = resolveGitCommonDir(root);
-  if (!common) return null;
-  try { return statSync(join(common, 'logs', 'refs', 'heads', ...branch.split('/'))).mtimeMs; } catch { return null; }
-}
-
-function agentWorktrees(root) {
-  const rootNorm = norm(root);
-  const containers = containerDirs(root);
-  return parseWorktreeList(root).flatMap((e) => {
-    const path = norm(e.path);
-    const hex = AGENT_DIR.exec(basename(path))?.[1];
-    if (!hex || path === rootNorm) return [];
-    if (!isUnder(containers, path)) return [];
-    const branch = e.branch ? e.branch.replace(/^refs\/heads\//, '') : null;
-    if (branch && branch !== `morph-task/agent-${hex}`) return [];
-    return [{ path, hex, branch, tip: e.head, locked: e.locked }];
-  });
-}
-
-function judgeWorktree(item, ctx) {
-  const keep = (state, reason, detail) => ({ ...item, state, reason, detail });
-  if (!existsSync(item.path)) return keep('preserved', 'directory-missing', 'o diretório sumiu; `morph-spec doctor --worktrees --prune` limpa o registro');
-  if (cwdIsInsideWorktree(ctx.cwd, item.path) || sessionAnchoredInWorktree(item.path, ctx.env)) return keep('active', 'anchored');
-  if (item.locked) return keep('preserved', 'locked', '`git worktree unlock` libera, se o lock já não vale');
-
-  const stop = readAgentStop(item.path, item.hex);
-  if (stop.status === 'active') return keep('active', 'agent-active', stop.detail);
-  if (stop.status !== 'stopped') return keep('preserved', 'no-usage-event', stop.detail);
-  const idleMin = (ctx.now - stop.mtimeMs) / 60_000;
-  if (idleMin < ctx.graceMinutes) return keep('pending', 'within-grace', `parou há ${Math.floor(idleMin)} min (graça de ${ctx.graceMinutes} min)`);
-
-  const dirt = dirtOf(item.path);
-  if (dirt === null) return keep('preserved', 'unknown', 'git status falhou');
-  if (dirt.length) return keep('preserved', 'dirty', sample(dirt));
-
-  const exclusive = exclusiveCommitCount(ctx.root, item.tip);
-  if (exclusive === null) return keep('preserved', 'unknown', 'não foi possível contar os commits exclusivos');
-  if (exclusive > 0) return keep('preserved', 'exclusive-commits', `${exclusive} commit(s) só nesta branch`);
-  return keep('reapable', 'stopped-clean');
-}
-
-function judgeOrphanBranch(branch, ctx) {
-  const item = { path: null, hex: branch.hex, branch: branch.name, tip: branch.sha };
-  const keep = (state, reason, detail) => ({ ...item, state, reason, detail });
-  const exclusive = exclusiveCommitCount(ctx.root, branch.sha);
-  if (exclusive === null) return keep('preserved', 'unknown', 'não foi possível contar os commits exclusivos');
-  if (exclusive > 0) return keep('preserved', 'exclusive-commits', `${exclusive} commit(s) só nesta branch`);
-  const touched = branchTouchedMs(ctx.root, branch.name);
-  if (touched === null) return keep('preserved', 'unknown', 'sem reflog para medir a idade da branch');
-  const idleMin = (ctx.now - touched) / 60_000;
-  if (idleMin < ctx.graceMinutes) return keep('pending', 'within-grace', `branch tocada há ${Math.floor(idleMin)} min (graça de ${ctx.graceMinutes} min)`);
-  return keep('reapable', 'orphan-branch');
-}
-
-/** Read-only: every agent tree and orphan agent branch with its verdict. */
-export function planAgentReap(root, { cwd = root, now = Date.now(), graceMinutes, env = process.env } = {}) {
-  const ctx = { root, cwd, now, env, graceMinutes: resolveGraceMinutes(root, graceMinutes) };
-  const trees = agentWorktrees(root);
-  const withTree = new Set(trees.map((t) => t.branch).filter(Boolean));
-  const orphans = agentBranches(root).filter((b) => !withTree.has(b.name));
-  const items = [...trees.map((t) => judgeWorktree(t, ctx)), ...orphans.map((b) => judgeOrphanBranch(b, ctx))];
-  return { graceMinutes: ctx.graceMinutes, items };
-}
-
-function acquireReapLock(root, now) {
-  const common = resolveGitCommonDir(root);
-  if (!common) return null;
-  const dir = join(common, 'morph-spec');
-  const file = join(dir, 'agent-reap.lock');
-  try { mkdirSync(dir, { recursive: true }); } catch { return null; }
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    try {
-      writeFileSync(file, JSON.stringify({ pid: process.pid, since: now }), { flag: 'wx' });
-      return () => { try { unlinkSync(file); } catch { /* already gone */ } };
-    } catch (err) {
-      if (err.code !== 'EEXIST') return null;
-    }
-    let holder = null;
-    try { holder = JSON.parse(readFileSync(file, 'utf8')); } catch { holder = null; }
-    const stale = !holder || !pidAlive(holder.pid) || now - Number(holder.since) > LOCK_MAX_AGE_MS;
-    if (!stale) return null;
-    try { unlinkSync(file); } catch { return null; }
-  }
-  return null;
-}
-
-function deleteAgentBranch(root, branch, sha) {
-  if (exclusiveCommitCount(root, sha) !== 0) return false;
-  try { gitOut(root, ['branch', '-D', branch]); return true; } catch { return false; }
-}
-
-const brief = ({ path, branch, hex }) => ({ path, branch, hex });
-const why = ({ path, branch, hex, reason, detail }) => ({ path, branch, hex, reason, ...(detail ? { detail } : {}) });
-
-/**
- * Removes the worktrees and branches of stopped, clean agents that hold no commit only they have;
- * everything else is listed with the reason and left alone.
- */
-export async function reapAgentWorktrees(cwd = process.cwd(), {
-  dryRun = false, graceMinutes, now = Date.now, env = process.env, remove = runWorktreeRemove,
-} = {}) {
-  if (!isGitRepo(cwd)) return { ok: false, error: 'not-a-git-repo', dryRun };
-  const root = resolvePrimaryRoot(cwd);
-  const summarize = (plan, extra = {}) => {
-    const of = (state) => plan.items.filter((i) => i.state === state);
-    return {
-      ok: true, dryRun, graceMinutes: plan.graceMinutes,
-      reaped: [], branchesDeleted: [],
-      ...(dryRun ? { wouldReap: of('reapable').map(brief) } : {}),
-      preserved: [...of('preserved'), ...of('pending')].map(why),
-      active: of('active').length,
-      ...extra,
-    };
-  };
-
-  if (dryRun) return summarize(planAgentReap(root, { cwd, now: now(), graceMinutes, env }));
-
-  const release = acquireReapLock(root, now());
-  if (!release) return { ...summarize({ graceMinutes: resolveGraceMinutes(root, graceMinutes), items: [] }), busy: true };
-  try {
-    const plan = planAgentReap(root, { cwd, now: now(), graceMinutes, env });
-    const out = summarize(plan);
-    for (const item of plan.items.filter((i) => i.state === 'reapable')) {
-      if (item.path) {
-        const { out: removal } = await remove(null, { target: item.path, ifClean: true, relinkOnFailure: true, cwd: root });
-        if (!removal.removed) {
-          out.preserved.push(why({ ...item, reason: 'remove-failed', detail: removal.hint || removal.error }));
-          continue;
-        }
-        out.reaped.push({ ...brief(item), ...(removal.ignoredBackup ? { backup: removal.ignoredBackup } : {}) });
-        if (item.branch && deleteAgentBranch(root, item.branch, item.tip)) out.branchesDeleted.push(item.branch);
-      } else if (deleteAgentBranch(root, item.branch, item.tip)) {
-        out.branchesDeleted.push(item.branch);
-        out.reaped.push(brief(item));
-      } else {
-        out.preserved.push(why({ ...item, reason: 'unknown', detail: 'a branch mudou antes de ser apagada' }));
-      }
-    }
-    return out;
-  } finally {
-    release();
-  }
-}