@polymorphism-tech/morph-spec 8.47.0 → 9.1.0

package/src/utils/skills-installer.js

@@ -1,19 +1,3 @@
-/**
- * Skills Installer
- *
- * Copies framework skills to .claude/skills/ during morph-spec init.
- * Installs only the `core/` skill set — the canonical NLH skills referenced by
- * MORPH.md (morph-brainstorming, morph-stack-scan, morph-plan, morph-implement,
- * morph-review, morph-standards). The 3-tier system was collapsed
- * into a single source of truth in framework/skills/core/.
- *
- * Source skills are directory-based: framework/skills/core/{skill-name}/SKILL.md
- * (plus optional scripts/, references/, assets/ subdirectories).
- *
- * Directory-based skills have their entire directory copied so Claude Code can
- * execute scripts and load references on demand.
- */
-
 import { existsSync, readdirSync, statSync, readFileSync } from 'fs';
 import { basename, join } from 'path';
 import { fileURLToPath } from 'url';
@@ -23,59 +7,16 @@ import { realEffects } from '../lib/installers/effects.js';
 const __dirname = fileURLToPath(new URL('.', import.meta.url));
 const FRAMEWORK_SKILLS_DIR = join(__dirname, '..', '..', 'framework', 'skills');
 
-/**
- * Skill levels to install in .claude/skills/.
- * Only `core/` survives — single source of truth aligned with MORPH.md.
- */
 const SKILL_LEVELS_TO_INSTALL = ['core'];
 
-/**
- * Check if a skill should be installed based on its stacks: frontmatter.
- * @param {string} skillContent - Raw SKILL.md content
- * @param {string[]} projectTags - Stack tags from config
- * @returns {boolean}
- */
 export function shouldInstallSkill(skillContent, projectTags) {
   return shouldInstall(parseStacks(skillContent), projectTags);
 }
 
-/**
- * Copy a skill directory tree from src to dest, skipping README.md files.
- *
- * UM efeito por skill (não um por arquivo): é assim que o instalador pensa
- * ("instalar a skill X"), e é o que o relatório do `--dry-run` precisa dizer.
- *
- * @param {string} src - Source directory path
- * @param {string} dest - Destination directory path
- * @param {ReturnType<import('../lib/installers/effects.js').createEffects>} fx
- */
 function copySkillDirectory(src, dest, fx) {
   fx.copyDir(src, dest, { filter: (from) => basename(from) !== 'README.md' });
 }
 
-/**
- * Walk srcDir and install skills into destDir.
- *
- * Handles two source formats:
- *   1. Directory-based skill: srcDir/{skill-name}/SKILL.md
- *      → copies entire directory (SKILL.md + scripts/ + references/ + assets/)
- *      → destDir/{skill-name}/
- *
- *   2. Flat .md skill (legacy): srcDir/{skill-name}.md
- *      → destDir/{skill-name}/SKILL.md
- *
- * The `core/` level directory is traversed recursively. A directory is
- * recognized as a skill directory when it contains a SKILL.md file.
- *
- * @param {string} srcDir - Source directory to walk
- * @param {string} destDir - Destination base directory (.claude/skills/)
- * @param {string[]} projectTags - Stack tags from config
- * @param {Set<string>} installedNow - Accumulator: skill names this call
- *   actually (re)installed. NOT derived by re-scanning destDir afterwards —
- *   a disk scan can't distinguish "installed this run" from "leftover from a
- *   previous run with different projectTags", which is exactly the stale
- *   entry a stack change needs cleaned up.
- */
 function installSkillsFromDir(srcDir, destDir, projectTags, installedNow, fx) {
   const entries = readdirSync(srcDir);
   for (const entry of entries) {
@@ -85,20 +26,15 @@ function installSkillsFromDir(srcDir, destDir, projectTags, installedNow, fx) {
     if (stat.isDirectory()) {
       const skillMdPath = join(srcPath, 'SKILL.md');
       if (existsSync(skillMdPath)) {
-        // Directory-based skill — check stack filter before copying.
-        // O filtro é PURO e continua sendo o único: previsão e execução
-        // percorrem esta mesma linha.
         const content = readFileSync(skillMdPath, 'utf-8');
         if (!shouldInstallSkill(content, projectTags)) continue;
         const skillDestDir = join(destDir, entry);
         copySkillDirectory(srcPath, skillDestDir, fx);
         installedNow.add(entry);
       } else {
-        // Level/category directory — recurse
         installSkillsFromDir(srcPath, destDir, projectTags, installedNow, fx);
       }
     } else if (entry.endsWith('.md') && entry !== 'README.md') {
-      // Legacy flat .md skill — check stack filter before copying
       const content = readFileSync(srcPath, 'utf-8');
       if (!shouldInstallSkill(content, projectTags)) continue;
       const skillName = entry.slice(0, -3);
@@ -132,32 +68,12 @@ function collectNamesFromDir(dir, names) {
   }
 }
 
-/**
- * Install morph framework skills to .claude/skills/ in the target project.
- * Skills are copied into subdirectories as SKILL.md files so Claude Code can
- * discover them natively via /<skill-name> syntax (e.g., /phase-design,
- * /nextjs-expert). Directory-based skills also get their scripts/,
- * references/, and assets/ subdirectories copied for on-demand loading.
- *
- * Stack filtering: if projectTags is provided, only skills whose `stacks:`
- * frontmatter matches the project tags are installed. Skills without a
- * `stacks:` field are always installed (universal).
- *
- * @param {string} projectDir - Target project root directory
- * @param {Object} [options]
- * @param {string[]} [options.projectTags=[]] - Stack tags from config
- * @param {ReturnType<import('../lib/installers/effects.js').createEffects>} [options.fx]
- *   Coletor de efeitos; o default executa e registra numa lista descartada.
- */
 export async function installSkills(projectDir, { projectTags = [], fx = realEffects() } = {}) {
   const claudeSkillsDir = join(projectDir, '.claude', 'skills');
   fx.ensureDir(claudeSkillsDir);
 
-  // Skill names this call actually (re)installs, given projectTags. Tracked
-  // as we go (NOT by re-scanning claudeSkillsDir afterwards) — a disk scan
-  // can't tell "installed this run" apart from "leftover from a previous
-  // run with different projectTags", which is exactly the stale entry a
-  // stack change (or a re-run that narrows the stack) needs cleaned up.
+  // Tracked as we go: a disk scan can't tell this run's installs from leftovers
+  // of a run with other projectTags, which a stack change must clean up.
   const installedNow = new Set();
   for (const level of SKILL_LEVELS_TO_INSTALL) {
     const levelDir = join(FRAMEWORK_SKILLS_DIR, level);
@@ -165,22 +81,8 @@ export async function installSkills(projectDir, { projectTags = [], fx = realEff
     installSkillsFromDir(levelDir, claudeSkillsDir, projectTags, installedNow, fx);
   }
 
-  // Clean-slate: remove any skill dir that is a KNOWN framework skill (still
-  // present in framework/skills/core/) but did NOT get (re)installed this
-  // run — i.e. it was filtered out by a `stacks:` mismatch (project.stack
-  // changed, or a re-run narrowed the tags). Previously scoped to `morph-`
-  // prefixed names only, which silently exempted every non-`morph-` skill
-  // (the Umbraco pair) from ever being cleaned up: install once with
-  // `umbraco` in the stack, drop the stack later, and they'd survive every
-  // reinstall/update forever. Names outside allSourceSkills (user-added,
-  // non-framework skills) are never touched.
-  //
-  // Em `dryRun` este laço NÃO emite nada, e a razão está na D6: numa execução
-  // real do `update` ele sempre vê um diretório VAZIO, porque
-  // `cleanFrameworkDirs()` acabou de apagar `.claude/skills/` inteiro. Num dry
-  // ingênuo nada foi apagado, ele veria o diretório POPULADO, e o relatório
-  // preveria remoções que a execução real nunca faz — errado na direção que
-  // assusta o usuário. O clean subsome este laço, provadamente.
+  // Removes known framework skills not reinstalled this run; user skills are never touched.
+  // Silent in dryRun: the real update's cleanFrameworkDirs() already emptied the dir.
   if (!fx.dryRun) {
     const allSourceSkills = collectSourceSkillNames();
     for (const entry of readdirSync(claudeSkillsDir)) {

package/src/utils/version-checker.js

@@ -6,10 +6,6 @@ import { realEffects } from '../lib/installers/effects.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-/**
- * Get the current CLI version from package.json
- * @returns {string} Version string (e.g., "1.0.4")
- */
 export function getInstalledCLIVersion() {
   try {
     const pkgPath = join(__dirname, '..', '..', 'package.json');
@@ -20,11 +16,6 @@ export function getInstalledCLIVersion() {
   }
 }
 
-/**
- * Get the latest version from npm registry
- * @param {string} packageName - The package name (default: @polymorphism-tech/morph-spec)
- * @returns {Promise<string|null>} Latest version or null if failed
- */
 export async function getLatestNPMVersion(packageName = '@polymorphism-tech/morph-spec') {
   try {
     const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
@@ -36,11 +27,6 @@ export async function getLatestNPMVersion(packageName = '@polymorphism-tech/morp
   }
 }
 
-/**
- * Get the MORPH version installed in the project
- * @param {string} projectPath - Path to the project
- * @returns {Promise<object|null>} Version info object or null if not found
- */
 export async function getProjectMorphVersion(projectPath) {
   try {
     const versionPath = join(projectPath, '.morph', '.morphversion');
@@ -53,12 +39,6 @@ export async function getProjectMorphVersion(projectPath) {
   }
 }
 
-/**
- * Save the MORPH version to the project
- * @param {string} projectPath - Path to the project
- * @param {string} version - Version to save
- * @returns {Promise<void>}
- */
 export async function saveProjectMorphVersion(projectPath, version, fx = realEffects()) {
   const versionPath = join(projectPath, '.morph', '.morphversion');
   const versionInfo = {
@@ -69,12 +49,7 @@ export async function saveProjectMorphVersion(projectPath, version, fx = realEff
   fx.writeJson(versionPath, versionInfo);
 }
 
-/**
- * Compare two semver versions
- * @param {string} v1 - First version
- * @param {string} v2 - Second version
- * @returns {number} -1 if v1 < v2, 0 if equal, 1 if v1 > v2
- */
+/** @returns {number} -1 if v1 < v2, 0 if equal, 1 if v1 > v2 */
 export function compareVersions(v1, v2) {
   if (!v1 || !v2) return 0;
 
@@ -92,49 +67,17 @@ export function compareVersions(v1, v2) {
   return 0;
 }
 
-/**
- * Major de uma versão, ou `null` quando a string não permite decidir.
- *
- * Vive aqui, ao lado de `compareVersions`, de propósito: uma segunda
- * aritmética de versão noutro arquivo é exatamente como duas verdades sobre a
- * mesma versão nascem.
- *
- * @param {string|null|undefined} version
- * @returns {number|null}
- */
+/** @returns {number|null} `null` when the string does not determine a major */
 export function majorOf(version) {
   if (typeof version !== 'string') return null;
   const m = /^\s*v?(\d+)\./.exec(version) ?? /^\s*v?(\d+)\s*$/.exec(version);
   return m ? Number(m[1]) : null;
 }
 
-/**
- * Limiar do freio: um salto de DOIS majors ou mais recusa sem `--force`.
- *
- * O limiar não é "quantos majors dá para pular com segurança" — é "a partir de
- * onde o usuário merece ler o relatório antes". Medido: um projeto em 7.x indo
- * para 9.x recusa; um em 8.x atualiza sem atrito.
- */
 export const MAJOR_JUMP_LIMIT = 2;
 
-/**
- * Avalia o salto entre a versão instalada no projeto e a versão de destino.
- *
- * Três resultados, e a diferença entre eles é o que a mensagem tem de dizer:
- *
- * - `reason: 'unknown-installed'` — a versão instalada é indeterminável.
- *   Tratada como salto grande, com motivo PRÓPRIO: "não sei quão velho isto é"
- *   é precisamente quando sobrescrever às cegas é mais perigoso, e tratá-la
- *   como zero seria a única leitura que libera o pior caso.
- * - `reason: 'major-jump'` — salto medido de `jump` majors, >= ao limiar.
- * - `reason: null` — sem freio (mesmo major, um só major de diferença, ou
- *   destino não superior à instalada).
- *
- * @param {string|null} installedVersion
- * @param {string|null} targetVersion
- * @param {{ limit?: number }} [options]
- * @returns {{ refuse: boolean, reason: 'unknown-installed'|'major-jump'|null, jump: number|null }}
- */
+// An unreadable installed version refuses with its own reason: not knowing how old
+// the project is is when a blind overwrite is most dangerous.
 export function majorJump(installedVersion, targetVersion, { limit = MAJOR_JUMP_LIMIT } = {}) {
   const installedMajor = majorOf(installedVersion);
   const targetMajor = majorOf(targetVersion);
@@ -143,8 +86,6 @@ export function majorJump(installedVersion, targetVersion, { limit = MAJOR_JUMP_
     return { refuse: true, reason: 'unknown-installed', jump: null };
   }
   if (targetMajor === null) {
-    // Sem destino legível não há salto a medir — e inventar um seria decidir
-    // por um número que ninguém mantém.
     return { refuse: false, reason: null, jump: null };
   }
   if (compareVersions(installedVersion, targetVersion) >= 0) {
@@ -156,17 +97,11 @@ export function majorJump(installedVersion, targetVersion, { limit = MAJOR_JUMP_
   return { refuse: false, reason: null, jump };
 }
 
-/**
- * Detect how the CLI was installed
- * @returns {'global'|'npx'|'unknown'}
- */
 export function detectInstallMethod() {
-  // Check if running via npx
   if (process.env.npm_execpath && process.env.npm_execpath.includes('npx')) {
     return 'npx';
   }
 
-  // Check if installed globally
   const isGlobal = process.env.npm_config_global === 'true' ||
                    process.execPath.includes('node_modules');
 
@@ -177,11 +112,6 @@ export function detectInstallMethod() {
   return 'unknown';
 }
 
-/**
- * Get update instructions based on install method
- * @param {string} method - Install method ('global', 'npx', 'unknown')
- * @returns {string[]} Array of instruction strings
- */
 export function getUpdateInstructions(method) {
   switch (method) {
     case 'global':
@@ -198,10 +128,6 @@ export function getUpdateInstructions(method) {
   }
 }
 
-/**
- * Check if CLI version is outdated
- * @returns {Promise<{isOutdated: boolean, current: string, latest: string|null}>}
- */
 export async function checkCLIOutdated() {
   const current = getInstalledCLIVersion();
   const latest = await getLatestNPMVersion();
@@ -215,11 +141,6 @@ export async function checkCLIOutdated() {
   return { isOutdated, current, latest };
 }
 
-/**
- * Check if project MORPH version is outdated
- * @param {string} projectPath - Path to the project
- * @returns {Promise<{isOutdated: boolean, current: string|null, cliVersion: string}>}
- */
 export async function checkProjectOutdated(projectPath) {
   const cliVersion = getInstalledCLIVersion();
   const projectVersion = await getProjectMorphVersion(projectPath);

package/framework/commands/morph-proposal.md

@@ -1,57 +0,0 @@
----
-description: Inicia uma nova feature MORPH-SPEC. Roda morph-brainstorming para entender negócio + escanear stack, depois morph-plan para produzir use cases, spec e tasks. Pausa nos Gates 1 e 2.
-argument-hint: <feature-name>
-allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Agent, AskUserQuestion, Skill
----
-
-# /morph-proposal — NLH Pipeline
-
-Conduz a feature do request inicial até o Gate 2 (plano aprovado), sem intervenção do usuário entre os gates.
-
-**Implementação:** este slash command é um atalho. O agente deve invocar `Skill(morph-proposal)` com o nome da feature como argumento. A skill encadeia automaticamente `morph-brainstorming` → Gate 1 → `morph-plan` → Gate 2. Em `trust: "auto"` (default), gates auto-passam sem sinais de risco.
-
-## Argumentos
-
-`{feature-name}` — nome em kebab-case da feature.
-
-## Fluxo
-
-1. **Detecta contexto:** verifica se `.morph/features/{feature-name}/` já existe.
-   - Se existe e tem `0-proposal/proposal.md`: pular para passo 3.
-   - Se não existe: criar a estrutura e seguir o passo 2.
-
-2. **Invocar `morph-brainstorming`** (skill em `.claude/skills/morph-brainstorming/`):
-   - Varre o ambiente **antes** de qualquer pergunta (stack, contexto do projeto, acervo de use cases).
-   - Monta a árvore de decisões abertas — só o que a varredura não respondeu.
-   - Abre com a escolha de **modo de descoberta** (entrevista ou automático), recomendando um.
-   - Produz `proposal.md` em `.morph/features/{feature-name}/0-proposal/`.
-   - Apresenta o **Gate 1** (que pausa sempre no modo entrevista).
-
-3. **Aguardar aprovação do Gate 1.**
-   - Resposta válida (o que o hook `state-sync` reconhece): começa com "aprovado" ou contém "pode avançar", "pode implementar" ou "pode prosseguir". Outra frase não grava o gate.
-   - Se ajustes solicitados: aplicar e reapresentar o gate.
-
-4. **Após Gate 1, invocar `morph-plan`** (skill em `.claude/skills/morph-plan/`):
-   - Lê `proposal.md`.
-   - Produz use cases, `spec.md` e `tasks.json` em `.morph/features/{feature-name}/2-plan/`.
-   - Apresenta o **Gate 2** com template fixo (ver SKILL.md passo 5).
-
-5. **Aguardar aprovação do Gate 2.**
-   - Resposta válida: as mesmas do Gate 1 (ex.: "aprovado", "pode implementar").
-   - Se ajustes solicitados: aplicar e reapresentar o gate.
-
-6. **Após Gate 2:** sinalizar ao usuário que `/morph-apply {feature-name}` está pronto para iniciar a implementação.
-
-## Anti-padrões
-
-- Não pular o Gate 1 mesmo que o usuário pareça apressado — proposal.md é o contrato de escopo.
-- Não escrever código nesta fase. Apenas artefatos de planejamento.
-- Não perguntar sobre stack — o stack padrão é VSA + .NET 10 + MAF + Next.js + Neon.
-
-## Referências
-
-- `.morph/framework/MORPH.md` — charter completo
-- `.claude/skills/morph-brainstorming/SKILL.md`
-- `.claude/skills/morph-plan/SKILL.md`
-
-**Feature:** $ARGUMENTS

package/framework/evals/trace-schema.md

@@ -1,67 +0,0 @@
-# Trace Schema — morph-spec NLH
-
-## Local de armazenamento
-
-`.morph/traces/YYYY-MM-DD-{feature}-{phase}.json`
-
-Um arquivo por fase. Se a fase for executada em múltiplas sessões, o mesmo arquivo é atualizado incrementalmente.
-
-## Formato JSON
-
-```json
-{
-  "schema_version": "1.0",
-  "session_id": "YYYY-MM-DD-HH-MM-SS",
-  "feature": "nome-da-feature",
-  "phase": "implement | plan | review",
-  "started_at": "ISO 8601",
-  "completed_at": "ISO 8601",
-  "tasks": [
-    {
-      "id": "T1",
-      "title": "descrição da task",
-      "status": "completed | failed | skipped",
-      "standards_consulted": ["id-do-standard-1"],
-      "agent_persona": "dotnet-senior | nextjs-expert | etc",
-      "sub_agent_dispatched": false,
-      "files_modified": ["path/relativo/arquivo.cs"],
-      "duration_seconds": null
-    }
-  ],
-  "phase_summary": {
-    "tasks_completed": 3,
-    "tasks_failed": 0,
-    "standards_most_used": ["architecture-vertical-slice"],
-    "sub_agents_dispatched": 0
-  }
-}
-```
-
-## Como o trace é gerado (automático — não escreva à mão)
-
-O trace é **gerado pelo hook `trace-autogen`** (PostToolUse em Write|Edit) a cada
-write de `2-plan/tasks.json` — o último write da cerimônia de cada task. As skills
-(`morph-implement`, `morph-review`) **não escrevem o trace**.
-
-| Fonte | O que alimenta |
-|-------|----------------|
-| `tasks.json` | conjunto de tasks, `status` (done→completed, skipped→skipped, blocked→failed; pending/in_progress ficam fora), `outputs` → `files_modified` |
-| `recap.md` | `**Standard:**` → `standards_consulted`; `**Persona:**` → `agent_persona` + `sub_agent_dispatched` (`morph-{id}`/`general-purpose` = true) |
-
-`completed_at` e `phase_summary` são preenchidos quando nenhuma task resta
-`pending`/`in_progress`. O arquivo existente da mesma feature+fase é atualizado
-in place (`session_id`/`started_at` preservados entre sessões).
-
-**Se o trace parecer incompleto, corrija a FONTE** (um recap sem o bloco `## T{N}`), nunca o trace.
-
-## Regras de geração
-
-- Se um campo não tiver valor disponível, o hook usa `null` — nunca omite o campo.
-- Estrutura completa mantida para compatibilidade com análise de meta-harness.
-- `session_id` usa o formato `YYYY-MM-DD-HH-MM-SS` da primeira geração.
-- `standards_consulted` contém os `id`s do STANDARDS.json, não os paths.
-- `files_modified` usa paths relativos à raiz do repositório (vem de `outputs`).
-
-## Motivação
-
-Raw traces preservam o sinal completo de execução. Summaries comprimem informação e perdem sinais que o meta-harness usa para otimização. Regra: logar o trace completo — nunca substituir por resumo.

package/framework/hooks/claude-code/core/tasks-json-guard.js

@@ -1,83 +0,0 @@
-#!/usr/bin/env node
-/**
- * tasks-json-guard.js — PostToolUse hook (validate-and-warn, never block)
- *
- * Event: PostToolUse | Matcher: Write|Edit
- *
- * After any Write/Edit that touches a tasks.json under .morph/features/,
- * re-reads the file from disk and validates the schema (status enum, effort
- * enum). Invalid → injects a warning so the LLM fixes the file immediately;
- * valid → logs one activity line and stays silent.
- *
- * The production failure this guards: a leaf sub-agent wrote
- * status:"completed" (not in the enum — the schema accepts "done") into
- * tasks.json and nothing flagged it. The blocking pre-write validation for
- * post-Gate-2 edits lives in protect-spec-files.js (PreToolUse); this
- * PostToolUse pass also covers pre-gate authoring (morph-plan) and anything
- * that landed on disk regardless.
- *
- * Fail-open: exits 0 on any error.
- */
-
-import { readFileSync } from 'fs';
-import { isAbsolute, join } from 'path';
-import { stateExists } from '../../shared/state-reader.js';
-import { contextResult, runStandalone } from '../../shared/hook-response.js';
-import { logHookActivity } from '../../shared/activity-logger.js';
-import { getFilePath } from '../../shared/payload-utils.js';
-import { isFeaturePath, getBasename } from '../../shared/phase-utils.js';
-import { VALID_TASK_STATUS, validateTasksDoc } from '../../shared/tasks-validator.js';
-
-function projectDir() {
-  return process.env.CLAUDE_PROJECT_DIR || process.cwd();
-}
-
-/**
- * @param {object} payload - parsed PostToolUse stdin payload (Write|Edit)
- * @returns {Promise<object|null>} a hookSpecificOutput warning when tasks.json
- *   is unparseable or schema-invalid, or null (pass/silent).
- */
-export async function run(payload) {
-  try {
-    const cwd = projectDir();
-    if (!stateExists(cwd)) return null;
-
-    const filePath = getFilePath(payload);
-    if (!filePath) return null;
-    if (!isFeaturePath(filePath)) return null;
-    if (getBasename(filePath) !== 'tasks.json') return null;
-
-    const absPath = isAbsolute(filePath) ? filePath : join(cwd, filePath);
-
-    let doc;
-    try {
-      doc = JSON.parse(readFileSync(absPath, 'utf-8'));
-    } catch {
-      logHookActivity('tasks-json-guard', 'PostToolUse', 'invalid', cwd);
-      return contextResult(
-        '⚠️ [morph-spec] tasks.json INVÁLIDO — o arquivo gravado não parseia como JSON. ' +
-        'Corrija o arquivo antes de continuar.',
-        'PostToolUse'
-      );
-    }
-
-    const { valid, errors } = validateTasksDoc(doc);
-    if (!valid) {
-      logHookActivity('tasks-json-guard', 'PostToolUse', 'invalid', cwd);
-      return contextResult(
-        '⚠️ [morph-spec] tasks.json com schema inválido após o write:\n' +
-        errors.map(e => `  • ${e}`).join('\n') +
-        `\nStatus válidos: ${VALID_TASK_STATUS.join(', ')}. Corrija antes de marcar a task como done.`,
-        'PostToolUse'
-      );
-    }
-
-    logHookActivity('tasks-json-guard', 'PostToolUse', 'ok', cwd);
-    return null;
-  } catch {
-    // Fail-open
-    return null;
-  }
-}
-
-await runStandalone(run);