@polymorphism-tech/morph-spec 8.47.0 → 9.1.0

package/framework/hooks/shared/claim-registry.js

@@ -1,44 +1,13 @@
-/**
- * claim-registry.js — advisory feature ownership across parallel sessions.
- *
- * Two Claude Code sessions worked the SAME feature at the same time without
- * seeing each other: one finished it and removed the worktree out from under
- * the other's running sub-agent. A complete recap.md was discarded, a sub-agent
- * wasted, and a decision taken on state that was already obsolete. There was no
- * lock, no claim, no heartbeat — not even a warning.
- *
- * DELIBERATELY ADVISORY. This is not a lock: nothing here ever blocks a
- * command. The framework is fail-open by principle, and a strong lock left
- * behind by a crashed session would strand a feature for no gain. Being
- * VISIBLE is the whole fix.
- *
- * Location: `<git-common-dir>/morph-spec/claims.json`, beside the fleet's
- * env-registry, for the same three reasons — it can never dirty the `git
- * status` the finish gates read, it survives `git clean -fdx`, and the COMMON
- * dir is the one place every linked worktree of the repo shares. That last one
- * is decisive here: in the observed incident one session sat inside the
- * worktree and the other in the primary root, so a claim written to the
- * branch-local `feature.json` would have been invisible to exactly the session
- * that needed to read it.
- *
- * Writes are tmp+rename (torn file impossible); a corrupt registry reads as
- * empty — the cost is a lost warning, never a crash.
- */
+// ADVISORY, never a lock: a lock left by a crashed session would strand a feature.
+// Lives in the git COMMON dir, the one place every worktree of the repo shares.
 
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'fs';
 import { dirname, join } from 'path';
 
-/**
- * A claim with no heartbeat for this long is considered dead. The heartbeat
- * fires on tool activity, so this is really "how long a session may sit idle
- * before its claim stops warning others".
- */
 export const CLAIM_TTL_MS = 30 * 60 * 1000;
 
-/** Minimum gap between heartbeat WRITES. The heartbeat runs on every tool call. */
 export const HEARTBEAT_THROTTLE_MS = 60 * 1000;
 
-/** Claim file path for a repo's common git dir. */
 export function claimsPath(gitCommonDir) {
   return join(gitCommonDir, 'morph-spec', 'claims.json');
 }
@@ -60,23 +29,13 @@ function writeRegistry(gitCommonDir, registry) {
   renameSync(tmp, path);
 }
 
-/** Is this claim still within its TTL? A missing/unparseable heartbeat is dead. */
 export function isLive(claim, now = Date.now()) {
   const beat = Date.parse(claim?.heartbeatAt ?? '');
   return Number.isFinite(beat) && now - beat < CLAIM_TTL_MS;
 }
 
-/**
- * Claim a feature for this session, or refresh an existing claim of ours.
- *
- * A claim held by ANOTHER session is TAKEN OVER, not refused — advisory by
- * design, and the caller has already been warned via `foreignClaim`. The
- * takeover is recorded in `previousSessionId` so it is never silent.
- *
- * @param {string} feature
- * @param {{ gitCommonDir: string, sessionId: string, pid?: number, path?: string }} opts
- * @returns {object} the stored claim
- */
+// Another session's claim is TAKEN OVER, not refused; `previousSessionId` keeps
+// the takeover visible.
 export function acquireClaim(feature, { gitCommonDir, sessionId, pid = process.pid, path = null }) {
   const registry = readRegistry(gitCommonDir);
   const previous = registry.claims[feature];
@@ -95,17 +54,7 @@ export function acquireClaim(feature, { gitCommonDir, sessionId, pid = process.p
   return claim;
 }
 
-/**
- * Refresh our own claim's heartbeat. Throttled — this runs on every tool call,
- * and a write per call would be pure I/O waste.
- *
- * Never touches a claim owned by another session: a heartbeat is proof of life,
- * and forging someone else's would defeat the TTL.
- *
- * @param {string} feature
- * @param {{ gitCommonDir: string, sessionId: string }} opts
- * @returns {boolean} true when a write actually happened
- */
+// Never another session's claim: forging its heartbeat would defeat the TTL.
 export function heartbeatClaim(feature, { gitCommonDir, sessionId }) {
   const registry = readRegistry(gitCommonDir);
   const claim = registry.claims[feature];
@@ -119,45 +68,13 @@ export function heartbeatClaim(feature, { gitCommonDir, sessionId }) {
   return true;
 }
 
-/** Local, git-independent heartbeat pre-check marker — see `shouldHeartbeat`. */
 function heartbeatMarkPath(cwd) {
   return join(cwd, '.morph', 'logs', '.heartbeat-check.json');
 }
 
-/**
- * Cheap, git-independent pre-check for whether a heartbeat is even worth
- * ATTEMPTING. `heartbeatClaim` already throttles the WRITE to `claims.json`,
- * but that registry lives under the git COMMON dir — resolving it (even via
- * the pure-FS `git-paths.js`, never mind the old `execSync('git rev-parse
- * --git-common-dir')`) is work `telemetry-log.js` pays on every tool call.
- * This answers "is it due" from a tiny marker colocated with the CALLER's own
- * `.morph/logs/` (already known, no git lookup of any kind) so that on ~99%
- * of calls NOTHING git-related happens at all — not the subprocess, not even
- * the FS walk.
- *
- * Side effect: when it returns `true` (heartbeat IS due), it immediately
- * stamps the marker — mirroring `heartbeatClaim`'s own check-and-write
- * pattern — so the NEXT call within the throttle window short-circuits here
- * even if the caller's subsequent git resolution then fails (not actually a
- * git repo, say): a failed attempt should not be retried on every single tool
- * call either.
- *
- * This is a SEPARATE, LOCAL throttle from `claims.json`'s own authoritative
- * `heartbeatAt` (keyed by git-common-dir, enforced inside `heartbeatClaim`) —
- * the two can drift by up to one throttle window with no consequence: a
- * missed local pre-check only costs a claim heartbeat that gets written on
- * the very next call, and claims are advisory to begin with.
- *
- * Fail-open: any read/write error is treated as "due" — a broken marker must
- * never permanently suppress the actual (authoritative) heartbeat. Not
- * tmp+rename like `claims.json` — this file is low-stakes (worst case from a
- * torn write is corrupt JSON, which just reads back as "due" next time) and
- * shared by nobody outside this one project tree.
- *
- * @param {string} feature
- * @param {{ cwd: string, sessionId: string, now?: number }} opts
- * @returns {boolean}
- */
+// Local pre-check so most tool calls skip resolving the git common dir. Stamps
+// the marker when due, so a failed attempt is not retried on every call; an
+// unreadable marker counts as due.
 export function shouldHeartbeat(feature, { cwd, sessionId, now = Date.now() }) {
   const markPath = heartbeatMarkPath(cwd);
   try {
@@ -167,27 +84,16 @@ export function shouldHeartbeat(feature, { cwd, sessionId, now = Date.now() }) {
       if (Number.isFinite(at) && now - at < HEARTBEAT_THROTTLE_MS) return false;
     }
   } catch {
-    // missing/corrupt marker — treat as due
   }
 
   try {
     mkdirSync(dirname(markPath), { recursive: true });
     writeFileSync(markPath, JSON.stringify({ feature, sessionId, at: new Date(now).toISOString() }));
   } catch {
-    // best-effort — a failed stamp only costs a repeated attempt next call
   }
   return true;
 }
 
-/**
- * The LIVE claim on this feature held by a session that is not us — the thing
- * worth warning about. Returns null when the feature is unclaimed, claimed by
- * us, or claimed by a session whose heartbeat went stale.
- *
- * @param {string} feature
- * @param {{ gitCommonDir: string, sessionId?: string }} opts
- * @returns {object|null}
- */
 export function foreignClaim(feature, { gitCommonDir, sessionId }) {
   const claim = readRegistry(gitCommonDir).claims[feature];
   if (!claim) return null;
@@ -195,14 +101,6 @@ export function foreignClaim(feature, { gitCommonDir, sessionId }) {
   return isLive(claim) ? claim : null;
 }
 
-/**
- * Drop a feature's claim. Called by the manual `morph-spec claim <f> --release`
- * (recovering from a session that died without releasing) and by `finish`.
- *
- * @param {string} feature
- * @param {{ gitCommonDir: string }} opts
- * @returns {boolean} false when there was nothing to release
- */
 export function releaseClaim(feature, { gitCommonDir }) {
   const registry = readRegistry(gitCommonDir);
   if (!registry.claims[feature]) return false;
@@ -211,14 +109,7 @@ export function releaseClaim(feature, { gitCommonDir }) {
   return true;
 }
 
-/**
- * Every claim on record, live and stale, newest heartbeat first. `live` is
- * computed, never stored — a stored flag would go wrong the moment nobody
- * rewrites the file.
- *
- * @param {string} gitCommonDir
- * @returns {object[]}
- */
+// `live` is computed, never stored: a stored flag goes wrong once nobody rewrites the file.
 export function listClaims(gitCommonDir) {
   const now = Date.now();
   return Object.values(readRegistry(gitCommonDir).claims)
@@ -226,7 +117,6 @@ export function listClaims(gitCommonDir) {
     .sort((a, b) => String(b.heartbeatAt).localeCompare(String(a.heartbeatAt)));
 }
 
-/** Human-readable age of a claim's last heartbeat ("3 min", "2 h", "—"). */
 export function claimAge(claim, now = Date.now()) {
   const beat = Date.parse(claim?.heartbeatAt ?? '');
   if (!Number.isFinite(beat)) return '—';

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

@@ -1,19 +1,6 @@
-/**
- * command-tokens.js — shell-ish tokenizer shared by the PreToolUse Bash guards.
- *
- * Lives in shared/ (not inside a hook) on purpose: every core hook ends in a
- * standalone tail that reads stdin and exits, so a hook importing a sibling
- * hook for a helper would fire THAT tail in its own process — consuming the
- * payload and exiting before the importer ever ran. block-raw-worktree-add
- * and block-destructive-worktree-removal both read paths off these tokens,
- * so they agree on what a quoted path is.
- */
-
-/**
- * Split a shell-ish command into tokens, honoring single and double quotes.
- * @param {string} command
- * @returns {string[]}
- */
+// Lives in shared/: a hook importing a sibling hook would fire that hook's
+// stdin-reading tail in its own process.
+
 export function tokenize(command) {
   const tokens = [];
   const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
@@ -22,7 +9,6 @@ export function tokenize(command) {
   return tokens;
 }
 
-/** Index of the first pipe (`|`, not `||` nor `>|`) outside quotes, or -1. */
 function firstUnquotedPipe(command) {
   const s = String(command || '');
   let quote = null;
@@ -43,24 +29,11 @@ function firstUnquotedPipe(command) {
   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}
- */
+/** The command without the pipe filter and stderr redirections that shape its output. */
 export function producerOf(command) {
   const s = String(command || '');
   const pipe = firstUnquotedPipe(s);
@@ -70,11 +43,6 @@ export function producerOf(command) {
     .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 = [];
@@ -102,14 +70,7 @@ function topLevelSegments(command) {
 
 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}
- */
+/** True when the shell reports something other than the work's exit code (`; echo`, `|| true`, pipe, `&`). */
 export function exitCodeMasked(command) {
   const { segments, background } = topLevelSegments(command);
   if (background) return true;
@@ -117,3 +78,166 @@ export function exitCodeMasked(command) {
   const last = segments[segments.length - 1] || '';
   return (segments.length > 1 && REPORTER.test(last)) || /\|\|/.test(last.replace(/"[^"]*"|'[^']*'/g, ''));
 }
+
+const WRITE_REDIRECT = /^(?:[1&])?>>?\|?/;
+
+function quotedTokens(text) {
+  const tokens = [];
+  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    tokens.push({ text: m[1] ?? m[2] ?? m[3], quoted: m[3] === undefined, single: m[2] !== undefined });
+  }
+  return tokens;
+}
+
+const CHAIN = /^(?:&&|\|\||\||\|&)$/;
+const ASSIGNMENT = /^([A-Za-z_]\w*)=(.*)$/;
+const REDIRECT = /^(?:\d|&)?[<>]/;
+const SCRIPT_RUNNER = /^(?:python[\d.]*|py|node|bun|deno)$/;
+
+function simpleCommands(head) {
+  const commands = [];
+  for (const segment of topLevelSegments(head).segments) {
+    let current = [];
+    for (const token of quotedTokens(segment)) {
+      if (!token.quoted && CHAIN.test(token.text)) { commands.push(current); current = []; } else current.push(token);
+    }
+    commands.push(current);
+  }
+  return commands.filter((c) => c.length > 0);
+}
+
+function positionals(args, takesValue) {
+  const out = [];
+  const values = [];
+  for (let i = 0; i < args.length; i++) {
+    const { text, quoted } = args[i];
+    if (!quoted && REDIRECT.test(text)) { if (/[<>]$/.test(text)) i++; continue; }
+    if (!quoted && text.startsWith('-') && text !== '-') {
+      if (takesValue(text) && i + 1 < args.length) values.push(args[++i].text);
+      continue;
+    }
+    out.push(text);
+  }
+  return { files: out, values };
+}
+
+function sedTargets(args) {
+  const inPlace = args.some(({ text, quoted }) => !quoted && (/^-[A-Za-z]*i/.test(text) || text.startsWith('--in-place')));
+  if (!inPlace) return [];
+  const { files, values } = positionals(args, (o) => /^-[A-Za-z]*[ef]$/.test(o) || o === '--expression' || o === '--file');
+  return values.length > 0 ? files : files.slice(1);
+}
+
+function perlTargets(args) {
+  if (!args.some(({ text, quoted }) => !quoted && /^-[A-Za-z]*i/.test(text))) return [];
+  const { files, values } = positionals(args, (o) => /^-[A-Za-z.]*[eE]$/.test(o));
+  return values.length > 0 ? files : files.slice(1);
+}
+
+function copyTargets(args) {
+  if (args.some(({ text }) => text === '-t' || text.startsWith('--target-directory'))) return [];
+  const { files } = positionals(args, () => false);
+  if (files.length < 2) return [];
+  const dest = files[files.length - 1];
+  if (!dest.endsWith('/')) return [dest];
+  return files.slice(0, -1).map((src) => dest + src.replace(/^.*\//, ''));
+}
+
+const PY_OPEN_WRITE = /\bopen\(\s*([^,()]+?)\s*,\s*(?:mode\s*=\s*)?(['"])([^'"]*)\2/g;
+const JS_WRITE = /\b(?:writeFileSync|writeFile|appendFileSync|appendFile)\(\s*([^,()]+?)\s*,/g;
+const PY_PATH_WRITE = /\.write_(?:text|bytes)\(/;
+const STRING_LITERAL = /(['"`])((?:(?!\1)[^\\\n]|\\.)*)\1/g;
+const PATH_LITERAL = /^[\w@./-]*[\w-]\.[A-Za-z]{1,5}$/;
+
+function literalOf(expr) {
+  const m = /^(['"`])([^'"`]*)\1$/.exec(expr.trim());
+  return m ? m[2] : null;
+}
+
+// A write call with a computed path (`open(p, "w")`) counts every path-shaped literal in the script.
+function scriptWrites(script) {
+  const literals = [];
+  let computed = PY_PATH_WRITE.test(script);
+  for (const m of script.matchAll(PY_OPEN_WRITE)) {
+    if (!/[wax+]/.test(m[3])) continue;
+    const lit = literalOf(m[1]);
+    if (lit === null) computed = true; else literals.push(lit);
+  }
+  for (const m of script.matchAll(JS_WRITE)) {
+    const lit = literalOf(m[1]);
+    if (lit === null) computed = true; else literals.push(lit);
+  }
+  if (!computed) return literals;
+  const mentioned = [...script.matchAll(STRING_LITERAL)].map((m) => m[2]).filter((s) => PATH_LITERAL.test(s));
+  return [...new Set([...literals, ...mentioned])];
+}
+
+function runnerScript(args, body) {
+  for (let i = 0; i < args.length; i++) {
+    if (['-c', '-e', '-p', '--eval', '--print'].includes(args[i].text) && !args[i].quoted) return args[i + 1]?.text ?? null;
+  }
+  const { files } = positionals(args, () => false);
+  return (files.length === 0 || files[0] === '-') ? body : null;
+}
+
+function heredocBody(lines, at) {
+  if (at < 0) return null;
+  const delim = /<<-?\s*(['"]?)([\w.-]+)\1/.exec(lines[at])?.[2];
+  if (!delim) return null;
+  const end = lines.findIndex((line, i) => i > at && line.trim() === delim);
+  return lines.slice(at + 1, end < 0 ? undefined : end).join('\n');
+}
+
+function commandWriteTargets(head, body) {
+  const vars = new Map();
+  const expand = ({ text, single }) => (single ? text : text.replace(/\$\{?([A-Za-z_]\w*)\}?/g, (all, name) => vars.get(name) ?? all));
+  const targets = [];
+  for (const tokens of simpleCommands(head)) {
+    let i = 0;
+    for (; i < tokens.length && !tokens[i].quoted && ASSIGNMENT.test(tokens[i].text); i++) {
+      const [, name, value] = ASSIGNMENT.exec(tokens[i].text);
+      vars.set(name, value);
+    }
+    if (i >= tokens.length) continue;
+    const word = tokens[i].text.replace(/^.*[\\/]/, '').replace(/\.exe$/i, '');
+    const args = tokens.slice(i + 1).map((t) => ({ ...t, text: expand(t) }));
+    if (word === 'sed') targets.push(...sedTargets(args));
+    else if (word === 'perl') targets.push(...perlTargets(args));
+    else if (word === 'cp' || word === 'mv') targets.push(...copyTargets(args));
+    else if (SCRIPT_RUNNER.test(word)) {
+      const script = runnerScript(args, body);
+      if (script) targets.push(...scriptWrites(script));
+    }
+  }
+  return targets;
+}
+
+// The redirect scan stops at the heredoc line: the body is data, and an
+// apostrophe in it would derail the quote-aware split.
+export function writeTargets(command) {
+  const lines = String(command || '').split('\n');
+  const heredocAt = lines.findIndex((line) => line.includes('<<'));
+  const head = (heredocAt >= 0 ? lines.slice(0, heredocAt + 1) : lines).join('\n');
+  const tokens = quotedTokens(head);
+
+  const targets = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const { text, quoted } = tokens[i];
+    if (quoted) continue;
+    const op = text.match(WRITE_REDIRECT);
+    if (op) {
+      const rest = text.slice(op[0].length);
+      const target = rest || tokens[i + 1]?.text;
+      if (target && !target.startsWith('&')) targets.push(target);
+      continue;
+    }
+    if (text.replace(/^.*[\/]/, '') === 'tee') {
+      for (let j = i + 1; j < tokens.length && !/^[;&|]/.test(tokens[j].text); j++) {
+        if (!tokens[j].text.startsWith('-')) targets.push(tokens[j].text);
+      }
+    }
+  }
+  return [...new Set([...targets, ...commandWriteTargets(head, heredocBody(lines, heredocAt))])];
+}

package/framework/hooks/shared/comment-rules.js

@@ -1,11 +1,5 @@
-/**
- * The comment shapes the `architecture-code-comments` standard forbids in
- * every case, judged only on the comments an edit ADDED. Whether a short
- * comment restates the code is not decidable here; that stays with the
- * Gate 3 evaluator and the `code-budget` density.
- *
- * @module comment-rules
- */
+// Judges only the comments an edit ADDED, and only their shape: whether a
+// comment restates the code is not decidable here.
 
 import { existsSync, readdirSync, readFileSync } from 'fs';
 import { dirname, join } from 'path';
@@ -58,13 +52,7 @@ function nearest(startDir, test) {
   }
 }
 
-/**
- * Doc-comments are allowed only on a package consumed outside the repo. When
- * that cannot be read from the nearest project file, the rule stays quiet.
- *
- * @param {string} file - absolute path of the edited file
- * @returns {boolean}
- */
+/** Doc-comments are allowed only on a package consumed outside the repo; unreadable = quiet. */
 export function docCommentsForbidden(file) {
   const dir = dirname(file);
   if (/\.cs$/i.test(file)) {
@@ -85,7 +73,7 @@ export function docCommentsForbidden(file) {
   return JSON.parse(readFileSync(pkg, 'utf8')).private === true;
 }
 
-/** Lines of `after` whose comment is not one `before` already had (moved comments do not count). */
+// Moved comments do not count as added.
 function addedCommentLines(before, after, file) {
   const remaining = new Map();
   for (const text of commentLines(before, file).values()) {
@@ -115,10 +103,7 @@ function addedRegionLines(before, after) {
   return out;
 }
 
-/**
- * @param {{ file: string, before: string, after: string, docCommentsForbidden?: boolean }} input
- * @returns {Array<{ line: number, rule: 'process'|'banner'|'doc-comment'|'long-block', text: string }>}
- */
+/** @returns {Array<{ line: number, rule: 'process'|'banner'|'doc-comment'|'long-block', text: string }>} */
 export function commentFindings({ file, before, after, docCommentsForbidden: docForbidden = false }) {
   const isCs = /\.cs$/i.test(file);
   const all = commentLines(after, file);

package/framework/hooks/shared/comment-scanner.js

@@ -1,58 +1,27 @@
-/**
- * Linhas de comentário de um arquivo e se elas contam história de processo.
- *
- * O comentário é o que `stripComments` apaga: o mesmo varredor que já separa
- * comentário de string para o `doctor --ai`, com a sintaxe de TS/JS ligada
- * fora do C#. Um regex por linha confundiria `https://` com comentário.
- *
- * @module comment-scanner
- */
+// Comentário é o que `stripComments` apaga: um regex por linha confundiria
+// `https://` com comentário.
 
 import { stripComments } from './comment-stripper.js';
 
-/** Vocabulário de processo do morph-spec, fora o id de task (abaixo). */
+// A mesma grafia de `C{n}`/`F{n}` é tecla, métrica, célula ou o modelo C-quatro:
+// esses vizinhos não contam.
+const PLAN_ID = new RegExp(String.raw`(?<!\b(?:key|tecla|press|aperte|cell|c[eé]lula|column|coluna)\s+)(?<![\w.#$/-])[CF]\d{1,2}(?![\w.(-]|\s+(?:key|tecla|score|model|modelo|diagram|diagrama)\b)`, 'i');
+
 const PROCESS_CITATION = [
   /\bUC[-\s]?\d+/,
   /\bADR[-\s]?\d+/,
   /\bFR[-\s]?\d+/,
   /\bgate\s?[1-3]\b/i,
-  /\bspec\.md\b/i,
+  /\bplan\.md\b/i,
+  /\bchecks\.json\b/i,
   /\bmockups?\b/i,
 ];
 
-/**
- * `T{n}` também é nome de parâmetro genérico. Não casa depois de `template`/
- * `typename`/`generic`, nem colado a letra ou dígito (a hora ISO `24T10`).
- */
-const TASK_ID = /(?<!\b(?:[Tt]emplate|[Tt]ypename|[Gg]eneric)\s+)(?<![\w"])T\d{1,3}\b(?!")/;
-
-/** Lista de tipos `<…>` e `{…}` (`Func<T1, T2>`, `cref="Func{T1,T2}"`, XML doc), de dentro para fora. */
-const TYPE_LIST = /<[^<>]*>|\{[^{}]*\}/g;
-
-function withoutTypeLists(text) {
-  let previous;
-  let current = text;
-  do {
-    previous = current;
-    current = current.replace(TYPE_LIST, ' ');
-  } while (current !== previous);
-  return current;
-}
-
-/**
- * @param {string} commentText
- * @returns {boolean} o comentário usa o vocabulário de processo acima
- */
 export function citesProcess(commentText) {
-  return PROCESS_CITATION.some((re) => re.test(commentText))
-    || TASK_ID.test(withoutTypeLists(commentText));
+  return PROCESS_CITATION.some((re) => re.test(commentText)) || PLAN_ID.test(commentText);
 }
 
-/**
- * @param {string} content - conteúdo do arquivo
- * @param {string} file - path, só para escolher a sintaxe
- * @returns {Map<number, string>} nº da linha (1-based) → texto do comentário nela
- */
+/** @returns {Map<number, string>} linha 1-based → texto do comentário; `file` só escolhe a sintaxe */
 export function commentLines(content, file) {
   const text = String(content || '');
   const stripped = stripComments(text, { js: !/\.cs$/i.test(file) });
@@ -66,8 +35,7 @@ export function commentLines(content, file) {
       if (first < 0) first = k;
       last = k;
     }
-    // O espaço dentro do comentário não muda ao ser apagado; o trecho vai do
-    // primeiro ao último caractere apagado.
+    // Espaço dentro do comentário não muda ao ser apagado.
     if (first >= 0) out.set(index + 1, row.slice(first, last + 1).trim());
     start += row.length + 1;
   });