@polymorphism-tech/morph-spec 8.47.0 → 9.1.0

package/framework/hooks/claude-code/core/telemetry-log.js

@@ -1,41 +1,5 @@
 #!/usr/bin/env node
 
-/**
- * Telemetry Hook: harness execution-path capture
- *
- * Events: PostToolUse + PostToolUseFailure (all tools), PostToolBatch,
- * SubagentStop, UserPromptSubmit
- *
- * morph-spec is a Natural Language Harness: there is no central runtime to
- * instrument — Claude Code executes the skills and sub-agents. The only
- * vantage points are hooks. This one is the generic capture point: every tool
- * call and every user prompt is appended (one JSON line) to
- * .morph/logs/events.jsonl, from which `morph-spec telemetry` and
- * `morph-spec cost` reconstruct the path and measure it.
- *
- * Correlation is by an EXPLICIT key (feature + phase) written into each event,
- * not by ambient span context — hooks fire as separate node processes with no
- * shared trace context. `sessionId` and `agentId` (present only inside a
- * sub-agent) separate the orchestrator from the sub-agents it dispatched.
- *
- * PostToolUse fires only when a tool SUCCEEDS; a Bash command that exits
- * non-zero fires PostToolUseFailure instead. Only the exit code parsed from
- * its `error` first line is kept — the rest of `error` is the command's
- * output, where a secret value can appear with no name beside it.
- *
- * SINK RESOLUTION: the event is appended to the `.morph/` tree that OWNS the
- * tool's target file — the tree of its `.morph/features/` segment
- * (`resolveMorphRoot`), else the nearest morph tree above the file; tools with
- * no file path sink on the nearest morph tree above the payload's `cwd`, so a
- * sub-agent working in a worktree logs its Bash calls next to its Reads and
- * Writes. The feature is the tree's BINDING (`morph/<f>` branch, then
- * `MORPH_FEATURE` in `.morph/worktree.env`) before its most recent active
- * feature; a bound feature with no `feature.json` in that tree keeps phase null.
- *
- * SILENT: never blocks, never injects context — only appends. Fail-open on any
- * error (exit 0). Only active inside a morph project (stateExists gate).
- */
-
 import { statSync, readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 import { dirname, join } from 'path';
 import { stateExists, getActiveFeature, derivePhaseForFeature } from '../../shared/state-reader.js';
@@ -51,10 +15,7 @@ function normalize(p) {
   return (p || '').replace(/\\/g, '/');
 }
 
-// A multi-KB prompt or command written verbatim on every call dominates the
-// per-line cost. The ORIGINAL length travels in a sibling `<field>Chars` key,
-// which `morph-spec cost` prefers over the truncated string's own length —
-// a contract with the telemetry reader: do not rename either half.
+// The original length travels in a sibling `<field>Chars` key that `morph-spec cost` prefers: do not rename either half.
 const MAX_FIELD_CHARS = 2000;
 const TRUNCATE_SUFFIX = '…[truncado]';
 
@@ -64,13 +25,7 @@ const DEFAULT_READ_LINES = 2000;
 const MAX_SLICE_BYTES = 10 * 1024 * 1024;
 const BINARY_READ = /\.(png|jpe?g|gif|webp|bmp|ico|pdf)$/i;
 
-/**
- * Redact, then cap a free-text field, reporting its original length. Redacting
- * first keeps a token cut at the cap from surviving as a recognizable prefix.
- *
- * @param {string} value
- * @returns {{ value: string, chars: number }}
- */
+// Redact before capping: a token cut at the cap would survive as a recognizable prefix.
 function capField(value) {
   const str = typeof value === 'string' ? value : '';
   const clean = redactSecrets(str);
@@ -78,15 +33,11 @@ function capField(value) {
   return { value: clean.slice(0, MAX_FIELD_CHARS) + TRUNCATE_SUFFIX, chars: str.length };
 }
 
-/**
- * Classify a Read target into the telemetry `kind` taxonomy — a contract with
- * src/lib/telemetry/telemetry-reader.js, so these values are pinned. Specific
- * categories first, 'code' last.
- */
+// The `kind` values are a contract with src/lib/telemetry/telemetry-reader.js.
 function classifyReadKind(target) {
   const t = (target || '').toLowerCase();
 
-  if (t.includes('evals/review-checklist')) return 'rubric';
+  if (t.includes('evals/review-checklist')) return 'checklist';
   if (t.includes('standards/')) return 'standard';
   if (t.endsWith('skill.md') || t.includes('/skills/')) return 'skill';
   if (t.split('/').pop() === 'agents.json') return 'agents';
@@ -95,11 +46,11 @@ function classifyReadKind(target) {
   if (inFeature) {
     const rel = inFeature[1];
     const PLAN_ARTIFACT_BASENAMES = new Set([
-      'proposal.md', 'spec.md', 'tasks.json',
-      'decisions.md', 'recap.md', 'handoff.md',
+      'plan.md', 'checks.json',
+      'handoff.md',
     ]);
     const base = rel.split('/').pop();
-    if (PLAN_ARTIFACT_BASENAMES.has(base) || rel.includes('usecases/') || rel.includes('reports/')) {
+    if (PLAN_ARTIFACT_BASENAMES.has(base) || rel.includes('reports/')) {
       return 'plan-artifact';
     }
   }
@@ -107,7 +58,6 @@ function classifyReadKind(target) {
   return 'code';
 }
 
-/** Nearest directory at or above `dir` that is a morph project; `fallback` when none. */
 function morphRootAbove(dir, fallback) {
   if (!dir) return fallback;
   let current = normalize(dir);
@@ -122,12 +72,7 @@ function morphRootAbove(dir, fallback) {
 
 const FEATURE_NAME = /^[A-Za-z0-9._-]+$/;
 
-/**
- * The feature the TREE is bound to, before any guess from its state: the
- * branch `morph/<f>` checked out there, then `MORPH_FEATURE` in its
- * `.morph/worktree.env` (a task worktree sits on `morph-task/<n>`). Without
- * it, a sub-agent's worktree reported the root's most recent active feature.
- */
+// Branch binding before state: otherwise a sub-agent's worktree reports the root's most recent active feature.
 async function boundFeature(root) {
   const fromBranch = morphBranchFeature(root);
   if (fromBranch) return fromBranch;
@@ -143,10 +88,6 @@ function featureFromPath(target) {
   return m ? m[1] : null;
 }
 
-/**
- * What a Read actually put in context: the requested line window, not the
- * whole file. Binary reads (images, PDFs) go in whole.
- */
 function readSliceBytes(absPath, input, size) {
   if (BINARY_READ.test(absPath)) return size;
   if (size > MAX_SLICE_BYTES) return undefined;
@@ -157,7 +98,7 @@ function readSliceBytes(absPath, input, size) {
   return Buffer.byteLength(lines.slice(offset - 1, offset - 1 + limit).join('\n'), 'utf-8');
 }
 
-/** Exit code and outcome of a finished tool call, without keeping its output. */
+// Only the exit code is kept: the rest of `error` is command output, where a secret can appear with no name beside it.
 function outcomeOf(payload, input) {
   if (payload.hook_event_name === 'PostToolUseFailure') {
     const firstLine = String(payload.error ?? '').split('\n', 1)[0];
@@ -181,11 +122,7 @@ function countByName(calls) {
   return out;
 }
 
-/**
- * Sub-agent tokens live in their own transcript; each stop emits the delta.
- * One file per agent: two sub-agents stopping together never share a
- * read-modify-write, and one agent never stops twice at once.
- */
+// One store file per agent, so two sub-agents stopping together never share a read-modify-write.
 function agentUsageEvent(payload, cwd) {
   const usage = readTranscriptUsage(payload.agent_transcript_path);
   if (!usage || !payload.agent_id) return null;
@@ -204,11 +141,6 @@ function agentUsageEvent(payload, cwd) {
   return { event: 'AgentUsage', ...usage, delta };
 }
 
-/**
- * @param {object} payload - parsed hook payload (PostToolUse, PostToolUseFailure,
- *   PostToolBatch, SubagentStop or UserPromptSubmit)
- * @returns {Promise<null>} always null — pure side effect (append + claim heartbeat)
- */
 export async function run(payload) {
   try {
     if (!payload) return null;
@@ -222,8 +154,6 @@ export async function run(payload) {
 
     if (!stateExists(cwd)) return null;
 
-    // getActiveFeature → loadState hydrates every feature.json: O(active
-    // features) per call, fine while archive keeps that set small.
     let feature = null;
     let phase = null;
     try {
@@ -237,14 +167,9 @@ export async function run(payload) {
         feature = active?.name ?? featureFromPath(targetFilePath);
         if (feature) phase = active?.feature?.phase || derivePhaseForFeature(feature, cwd);
       }
-    } catch {
-      // enrichment is best-effort — a missing feature never blocks capture
-    }
+    } catch {}
 
-    // Claim heartbeat: this hook fires on every tool call, so it is the proof
-    // of life for the advisory feature claim. shouldHeartbeat() is a local,
-    // git-free pre-check that says no on ~99% of calls; only then is the git
-    // common dir resolved (pure filesystem, no subprocess).
+    // Claim heartbeat: shouldHeartbeat is a git-free pre-check that says no on ~99% of calls.
     if (feature && payload.session_id) {
       try {
         const { shouldHeartbeat, heartbeatClaim } = await import('../../shared/claim-registry.js');
@@ -253,7 +178,7 @@ export async function run(payload) {
           const common = resolveGitCommonDir(cwd);
           if (common) heartbeatClaim(feature, { gitCommonDir: common, sessionId: payload.session_id });
         }
-      } catch { /* fail-open — a missed heartbeat only shortens a claim's life */ }
+      } catch {}
     }
 
     const hookEvent = payload.hook_event_name;
@@ -290,17 +215,14 @@ export async function run(payload) {
         event.kind = classifyReadKind(event.target);
         if (Number.isInteger(input.offset)) event.offset = input.offset;
         if (Number.isInteger(input.limit)) event.limit = input.limit;
-        // A failed Read ingested nothing. A stat/read race with a file deleted
-        // between the Read and this hook omits the numbers rather than fail.
+        // A failed Read ingested nothing; a file deleted before this hook just omits the numbers.
         if (hookEvent !== 'PostToolUseFailure') {
           try {
             const abs = targetAbs || resolveTargetPath(event.target, projectDir);
             event.bytes = statSync(abs).size;
             const read = readSliceBytes(abs, input, event.bytes);
             if (read !== undefined) event.bytesRead = read;
-          } catch {
-            // omit bytes
-          }
+          } catch {}
         }
       } else if (tool === 'Bash' || tool === 'PowerShell') {
         const command = capField(input.command || '');
@@ -311,8 +233,6 @@ export async function run(payload) {
       } else if (tool === 'Write' || tool === 'Edit') {
         event.target = normalize(input.file_path || input.path);
       } else {
-        // Every other tool still counts toward "the whole path" — a compact
-        // target keeps Grep/Glob/WebFetch bursts distinguishable.
         const target = input.file_path || input.path || input.pattern || input.query || input.url || '';
         if (target) event.target = normalize(String(target));
       }
@@ -333,7 +253,6 @@ export async function run(payload) {
     appendTelemetryEvent(event, cwd);
     return null;
   } catch {
-    // Fail-open
     return null;
   }
 }

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

@@ -1,14 +1,5 @@
 #!/usr/bin/env node
 
-/**
- * Stop Hook: phase-transition alert, recap/tasks audit, session usage.
- *
- * Phase transition tracking: stores last-seen phase per feature in
- * .morph/memory/phase-watch.json so the alert fires exactly once.
- *
- * Fail-open: exits 0 on any error.
- */
-
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
 import { createHash } from 'crypto';
@@ -19,121 +10,40 @@ 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';
+import { sliceProgress, sliceReportPath, inspectReport } from '../../shared/slice-progress.js';
 
-/**
- * Audit recap.md against tasks.json + standard-citation rule.
- *
- * Returns an array of human-readable warnings. Empty array = audit clean.
- *
- * Two checks:
- *   1. Task IDs that appear as a "## T<n>" heading in recap.md but still
- *      carry status != 'done' in tasks.json — claim/state divergence.
- *   2. Task headings without a "**Standard:**" line nearby (within 10 lines
- *      after the heading) — no standard citation = unauditable decision.
- */
-function auditRecapAndTasks(featurePath) {
+// Advisory: the same rule `report-check` applies when the orchestrator resumes control.
+function auditSliceReports(featurePath) {
+  const progress = sliceProgress(featurePath);
+  if (!progress) return [];
   const warnings = [];
-  const recapPath = join(featurePath, '3-implement', 'recap.md');
-  const tasksJsonPath = join(featurePath, '2-plan', 'tasks.json');
-  if (!existsSync(recapPath) || !existsSync(tasksJsonPath)) return warnings;
-
-  let recap, tasksJson;
-  try {
-    recap = readFileSync(recapPath, 'utf-8');
-    tasksJson = JSON.parse(readFileSync(tasksJsonPath, 'utf-8'));
-  } catch {
-    return warnings;
-  }
-
-  const tasks = Array.isArray(tasksJson.tasks) ? tasksJson.tasks : [];
-  if (tasks.length === 0) return warnings;
-
-  // Index recap by task ID — collect line numbers where each task is mentioned
-  // as completed. Supports two formats agents commonly use:
-  //   (a) "## T<n>"           — heading style (per the SKILL.md template)
-  //   (b) "| T<n> | ... done" — markdown table row with done in same row
-  const lines = recap.split('\n');
-  const recapMentions = new Map(); // id → starting line index
-  const headingRe = /^##\s+(T\d+)\b/;
-  const tableRowRe = /^\|\s*(T\d+)\s*\|.*\bdone\b/i;
-  lines.forEach((ln, i) => {
-    const heading = ln.match(headingRe);
-    if (heading && !recapMentions.has(heading[1])) {
-      recapMentions.set(heading[1], i);
-      return;
-    }
-    const tableRow = ln.match(tableRowRe);
-    if (tableRow && !recapMentions.has(tableRow[1])) {
-      recapMentions.set(tableRow[1], i);
-    }
-  });
-
-  // Check 1: status drift — task mentioned as done in recap but tasks.json
-  // still shows it as pending/in_progress.
-  for (const t of tasks) {
-    if (recapMentions.has(t.id) && t.status !== 'done') {
-      warnings.push(
-        `tasks.json drift: ${t.id} appears as done in recap.md but tasks.json shows status="${t.status}". Run writeTasksJson to sync.`
-      );
+  for (const slice of progress.slices) {
+    if (slice.status !== 'feito') continue;
+    const { missing } = inspectReport(sliceReportPath(featurePath, slice.id), { covers: slice.covers });
+    if (missing.length) {
+      const hints = missing.map((id) => MISSING_HINT[id] ?? `cite ${id} pelo id`);
+      warnings.push(`relatório de ${slice.id} sem: ${missing.join(', ')} — ${hints.join('; ')} (formato na skill morph-apply; morph-spec report-check)`);
     }
   }
-
-  // Check 2: missing Standard citation per task mention. Skip pure
-  // table-row mentions (they're a summary, the heading-style block
-  // is where the standard belongs) — only flag when the agent did
-  // not produce a heading block at all for a task that is also marked
-  // done in tasks.json.
-  const standardRe = /\*\*Standard:\*\*|\bStandard\s*consulted\b|\bstandards?\s+used\b/i;
-  const headingMentions = new Map();
-  lines.forEach((ln, i) => {
-    const m = ln.match(headingRe);
-    if (m && !headingMentions.has(m[1])) headingMentions.set(m[1], i);
-  });
-  for (const t of tasks) {
-    if (t.status !== 'done') continue;
-    const lineIdx = headingMentions.get(t.id);
-    if (lineIdx === undefined) {
-      // Task is done but has no heading block at all — recap is summary-only.
-      warnings.push(
-        `recap.md task ${t.id} (status=done in tasks.json) has no detailed "## ${t.id}" block. Per morph-implement SKILL.md, each done task needs a heading block with a "**Standard:** ..." citation so the reviewer can audit the decision.`
-      );
-      continue;
-    }
-    const window = lines.slice(lineIdx, lineIdx + 12).join('\n');
-    if (!standardRe.test(window)) {
-      warnings.push(
-        `recap.md task ${t.id} is missing a "**Standard:** ..." citation within 12 lines of its heading. Cite which standard from STANDARDS.json justified the implementation (or "ad-hoc (see decisions.md ADR-N)" if intentional).`
-      );
-    }
-  }
-
   return warnings;
 }
 
-// Phases where compaction is strongly recommended before starting
+const MISSING_HINT = {
+  what: '2-3 frases do que foi feito e como foi provado',
+  files: 'linha **Arquivos:** com todo arquivo criado ou modificado',
+  partial: '1ª linha PARCIAL: a fatia não terminou',
+};
+
 const COMPACT_TRIGGER_PHASES = new Set(['implement']);
 
-// Phases where compaction is suggested when arriving (heavy spec phases)
 const HEAVY_SOURCE_PHASES = new Set(['plan', 'uiux']);
 
-/**
- * @param {object} payload - parsed Stop stdin payload. Most of this hook's
- *   logic reads its own state from disk rather than the payload, EXCEPT the
- *   session-usage capture below, which needs `payload.transcript_path` (and
- *   `payload.session_id` for the throttle key) — the one thing only the
- *   payload carries.
- * @returns {Promise<object|null>} a hookSpecificOutput advisory (phase
- *   transition / build failure / recap drift), or null (pass/silent).
- */
 export async function run(payload) {
   try {
-    // Prevent infinite loop
     if (process.env.MORPH_STOP_HOOK_ACTIVE === '1') return null;
 
     if (!stateExists()) return null;
 
-    // getActiveFeature() only returns in_progress/draft features.
-    // Fall back to the most recently updated feature when all features are 'done'.
     let active = getActiveFeature() || getMostRecentFeature();
     if (!active) return null;
 
@@ -142,9 +52,8 @@ export async function run(payload) {
     const warnings = [];
 
     const memDir = join(cwd, '.morph', 'memory');
-    try { mkdirSync(memDir, { recursive: true }); } catch { /* non-blocking */ }
+    try { mkdirSync(memDir, { recursive: true }); } catch {}
 
-    // ── Phase transition detection ────────────────────────────────────────────
     const currentPhase = feature.phase || derivePhaseForFeature(name, cwd);
 
     const watchPath = join(memDir, 'phase-watch.json');
@@ -155,13 +64,12 @@ export async function run(payload) {
 
     const lastPhase = phaseWatch[name];
 
-    // Update stored phase (always, so the alert only fires once per transition)
+    // Always stored, so the alert fires once per transition.
     try {
       phaseWatch[name] = currentPhase;
       writeFileSync(watchPath, JSON.stringify(phaseWatch, null, 2), 'utf-8');
-    } catch { /* non-blocking */ }
+    } catch {}
 
-    // Alert when entering implement from a heavy spec phase
     const isPhaseTransition = lastPhase && lastPhase !== currentPhase;
     const enteringImplement = COMPACT_TRIGGER_PHASES.has(currentPhase);
     const comingFromHeavyPhase = HEAVY_SOURCE_PHASES.has(lastPhase);
@@ -171,7 +79,7 @@ export async function run(payload) {
         `⚡ Phase advanced: ${lastPhase} → implement`,
         ``,
         `💡 Recommended before starting implementation:`,
-        `   Run /compact to free up context — spec.md and tasks.json`,
+        `   Run /compact to free up context — plan.md and the design`,
         `   loaded during planning take significant space. A compact now gives`,
         `   Claude a clean slate focused on writing code.`,
         ``,
@@ -179,18 +87,10 @@ export async function run(payload) {
       );
     }
 
-    // ── Recap + tasks.json audit ──────────────────────────────────────────────
-    // Surface drift between recap.md and tasks.json, plus missing standard
-    // citations. Advisory warnings only — Stop hook never blocks.
-    //
-    // The same audit re-runs every Stop; without dedup it re-injects the same
-    // ~500-token block turn after turn even when nothing changed. Hash-gate it:
-    // only inject when the warning SET differs from the last one actually
-    // surfaced for this feature. Resolved (no more warnings) clears the stored
-    // hash, so a later recurrence — even an identical one — is reported fresh.
+    // Hash-gated: the audit re-runs every Stop, so only a changed warning set is injected; resolving clears the hash.
     try {
       const featurePath = join(cwd, '.morph', 'features', name);
-      const recapWarnings = auditRecapAndTasks(featurePath);
+      const reportWarnings = auditSliceReports(featurePath);
 
       const warnedHashesPath = join(memDir, 'warned-hashes.json');
       let warnedHashes = {};
@@ -198,28 +98,21 @@ export async function run(payload) {
         if (existsSync(warnedHashesPath)) warnedHashes = JSON.parse(readFileSync(warnedHashesPath, 'utf-8'));
       } catch { /* corrupt file — start fresh */ }
 
-      if (recapWarnings.length > 0) {
-        const hash = createHash('sha1').update(recapWarnings.join('\n')).digest('hex');
-        if (warnedHashes[name]?.recap !== hash) {
-          warnings.push('📋 Recap audit:');
-          for (const w of recapWarnings) warnings.push(`  • ${w}`);
-          warnedHashes[name] = { ...warnedHashes[name], recap: hash };
-          try { writeFileSync(warnedHashesPath, JSON.stringify(warnedHashes, null, 2), 'utf-8'); } catch { /* non-blocking */ }
+      if (reportWarnings.length > 0) {
+        const hash = createHash('sha1').update(reportWarnings.join('\n')).digest('hex');
+        if (warnedHashes[name]?.reports !== hash) {
+          warnings.push('📋 Relatórios de fatia:');
+          for (const w of reportWarnings) warnings.push(`  • ${w}`);
+          warnedHashes[name] = { ...warnedHashes[name], reports: hash };
+          try { writeFileSync(warnedHashesPath, JSON.stringify(warnedHashes, null, 2), 'utf-8'); } catch {}
         }
-        // same hash as last time it fired → already surfaced, stay silent
-      } else if (warnedHashes[name]?.recap) {
-        delete warnedHashes[name].recap;
-        try { writeFileSync(warnedHashesPath, JSON.stringify(warnedHashes, null, 2), 'utf-8'); } catch { /* non-blocking */ }
+      } else if (warnedHashes[name]?.reports) {
+        delete warnedHashes[name].reports;
+        try { writeFileSync(warnedHashesPath, JSON.stringify(warnedHashes, null, 2), 'utf-8'); } catch {}
       }
-    } catch {
-      // Fail-open — audit must never block Stop
-    }
-    // ────────────────────────────────────────────────────────────────────────
+    } catch {}
 
-    // ── Session usage (real tokens, from the transcript) ──────────────────────
-    // 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.
+    // The transcript total is cumulative: summing the per-session `delta` is the only sum that does not double-count.
     try {
       const usage = readTranscriptUsage(payload?.transcript_path);
       if (usage) {
@@ -241,13 +134,10 @@ export async function run(payload) {
             delta,
           }, cwd);
           stored[sessionKey] = usage;
-          try { writeFileSync(usagePath, JSON.stringify(stored, null, 2), 'utf-8'); } catch { /* non-blocking */ }
+          try { writeFileSync(usagePath, JSON.stringify(stored, null, 2), 'utf-8'); } catch {}
         }
       }
-    } catch {
-      // Fail-open — usage capture must never block Stop
-    }
-    // ────────────────────────────────────────────────────────────────────────
+    } catch {}
 
     if (warnings.length === 0) return null;
 

package/framework/hooks/claude-code/core/warn-bash-source-write.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+// Warn only: a source file written by the shell skips every Write/Edit guard. The command still runs.
+import { contextResult, runStandalone } from '../../shared/hook-response.js';
+import { stateExists } from '../../shared/state-reader.js';
+import { writeTargets } from '../../shared/command-tokens.js';
+import { isProjectSource } from '../../shared/source-files.js';
+
+export async function run(payload) {
+  try {
+    if (!stateExists()) return null;
+    const sources = writeTargets(payload?.tool_input?.command || '').filter(isProjectSource);
+    if (!sources.length) return null;
+    return contextResult(
+      `⚠️ Código do projeto escrito pelo Bash (${sources.join(', ')}): os guards de escrita (fase, arquivo protegido, comment-guard) ` +
+        'só enxergam Write/Edit. Reescreva esse arquivo por Write/Edit.',
+      'PreToolUse',
+    );
+  } catch {
+    return null;
+  }
+}
+
+await runStandalone(run);