sinapse-ai 7.7.4 → 7.7.6

package/.sinapse-ai/data/registry-update-log.jsonl

@@ -567,3 +567,9 @@
 {"timestamp":"2026-04-02T23:48:52.333Z","action":"add","path":".sinapse-ai/infrastructure/scripts/validate-codex-sync.js","trigger":"watcher"}
 {"timestamp":"2026-04-02T23:48:52.333Z","action":"change","path":".sinapse-ai/infrastructure/scripts/validate-parity.js","trigger":"watcher"}
 {"timestamp":"2026-04-02T23:48:52.333Z","action":"change","path":".sinapse-ai/infrastructure/scripts/validate-paths.js","trigger":"watcher"}
+{"timestamp":"2026-04-03T00:26:52.858Z","action":"change","path":".sinapse-ai/infrastructure/scripts/validate-codex-command-registry.js","trigger":"watcher"}
+{"timestamp":"2026-04-03T00:26:52.860Z","action":"add","path":".sinapse-ai/infrastructure/scripts/validate-codex-delegation.js","trigger":"watcher"}
+{"timestamp":"2026-04-03T00:26:52.860Z","action":"change","path":".sinapse-ai/infrastructure/scripts/validate-codex-sync.js","trigger":"watcher"}
+{"timestamp":"2026-04-03T02:10:30.504Z","action":"change","path":".sinapse-ai/core/doctor/checks/constitution-consistency.js","trigger":"watcher"}
+{"timestamp":"2026-04-03T02:10:30.505Z","action":"change","path":".sinapse-ai/core/health-check/checks/project/constitution-consistency.js","trigger":"watcher"}
+{"timestamp":"2026-04-03T02:10:30.506Z","action":"change","path":".sinapse-ai/product/templates/ide-rules/claude-rules.md","trigger":"watcher"}

package/.sinapse-ai/infrastructure/scripts/validate-codex-delegation.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const Ajv2020 = require('ajv/dist/2020');
+const {
+  buildHandoffPacket,
+  loadDelegationMatrix,
+} = require(
+  path.join(__dirname, '..', '..', '..', '.codex', 'scripts', 'resolve-codex-delegation-parity'),
+);
+const {
+  loadRegistry: loadCommandRegistryFile,
+} = require('./validate-codex-command-registry');
+
+const REQUIRED_ORCHESTRATORS = Object.freeze([
+  'sinapse-orqx',
+  'brand-orqx',
+  'commercial-orqx',
+  'content-orqx',
+  'copy-orqx',
+  'animations-orqx',
+  'design-orqx',
+  'finance-orqx',
+  'growth-orqx',
+  'paidmedia-orqx',
+  'product-orqx',
+  'research-orqx',
+  'claude-orqx',
+  'council-orqx',
+  'storytelling-orqx',
+  'cyber-orqx',
+  'cloning-orqx',
+  'courses-orqx',
+  'swarm-orqx',
+]);
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const args = new Set(argv);
+  return {
+    quiet: args.has('--quiet') || args.has('-q'),
+    json: args.has('--json'),
+  };
+}
+
+function validateCodexDelegation(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const errors = [];
+  const warnings = [];
+  const requiredOrchestrators =
+    options.requiredOrchestrators === false
+      ? null
+      : options.requiredOrchestrators || REQUIRED_ORCHESTRATORS;
+
+  let matrix;
+  try {
+    matrix = loadDelegationMatrix(projectRoot);
+  } catch (error) {
+    errors.push(`Unable to load Codex delegation matrix: ${error.message}`);
+    return {
+      ok: false,
+      errors,
+      warnings,
+      metrics: { orchestrators: 0, routes: 0 },
+    };
+  }
+
+  const matrixPath = path.join(projectRoot, '.codex', 'delegation-parity.json');
+  const schemaPath = path.join(projectRoot, matrix.handoffSchema || '.codex/handoff-packet.parity.schema.json');
+  if (!fs.existsSync(schemaPath)) {
+    errors.push(`Missing handoff schema ${path.relative(projectRoot, schemaPath)}`);
+  }
+
+  let schema = null;
+  if (fs.existsSync(schemaPath)) {
+    try {
+      schema = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
+    } catch (error) {
+      errors.push(`Unable to parse handoff schema: ${error.message}`);
+    }
+  }
+
+  const { registry: commandRegistry, error: commandRegistryError } = loadCommandRegistryFile(projectRoot);
+  if (commandRegistryError) {
+    errors.push(commandRegistryError);
+  }
+
+  const orchestrators = matrix.orchestrators || {};
+  const frameworkAgents = matrix.frameworkAgents || {};
+  const routes = matrix.routes || {};
+
+  if (requiredOrchestrators) {
+    for (const orchestratorId of requiredOrchestrators) {
+      if (!orchestrators[orchestratorId]) {
+        errors.push(`missing required orchestrator coverage: ${orchestratorId}`);
+      }
+    }
+  }
+
+  for (const [orchestratorId, orchestratorSpec] of Object.entries(orchestrators)) {
+    const sourceOfTruth = path.join(projectRoot, orchestratorSpec.sourceOfTruth || '');
+    if (!fs.existsSync(sourceOfTruth)) {
+      errors.push(`${orchestratorId}: missing source of truth ${path.relative(projectRoot, sourceOfTruth)}`);
+    }
+
+    if (orchestratorSpec.squadDir) {
+      const squadDir = path.join(projectRoot, orchestratorSpec.squadDir);
+      if (!fs.existsSync(squadDir)) {
+        errors.push(`${orchestratorId}: missing squad dir ${path.relative(projectRoot, squadDir)}`);
+      }
+    }
+
+    if (orchestratorSpec.tasksDir) {
+      const tasksDir = path.join(projectRoot, orchestratorSpec.tasksDir);
+      if (!fs.existsSync(tasksDir)) {
+        errors.push(`${orchestratorId}: missing tasks dir ${path.relative(projectRoot, tasksDir)}`);
+      }
+    }
+
+    for (const routeId of orchestratorSpec.approvedRoutes || []) {
+      if (!routes[routeId]) {
+        errors.push(`${orchestratorId}: missing approved route ${routeId}`);
+      }
+    }
+  }
+
+  const routeAliases = new Map();
+  const ajv = schema ? new Ajv2020({ allErrors: true, strict: false }) : null;
+  const validatePacket = schema ? ajv.compile(schema) : null;
+  let routeCount = 0;
+  let validatorBackedCount = 0;
+  let shimCount = 0;
+  let exploratoryCount = 0;
+
+  for (const [routeId, routeSpec] of Object.entries(routes)) {
+    routeCount += 1;
+    if (routeSpec.classification === 'validator-backed') validatorBackedCount += 1;
+    if (routeSpec.classification === 'codex-only-shim') shimCount += 1;
+    if (routeSpec.classification === 'exploratory') exploratoryCount += 1;
+
+    if (!orchestrators[routeSpec.owner]) {
+      errors.push(`${routeId}: unknown route owner ${routeSpec.owner}`);
+    }
+
+    if (!(matrix.routingClasses || []).includes(routeSpec.classification)) {
+      errors.push(`${routeId}: invalid classification ${routeSpec.classification}`);
+    }
+
+    if (!(matrix.requestTypes || []).includes(routeSpec.requestType)) {
+      errors.push(`${routeId}: invalid request type ${routeSpec.requestType}`);
+    }
+
+    for (const alias of [routeId, ...(routeSpec.aliases || [])]) {
+      const normalized = String(alias || '').trim().toLowerCase();
+      const owner = routeAliases.get(normalized);
+      if (owner && owner !== routeId) {
+        errors.push(`duplicate delegation route alias "${normalized}" claimed by ${owner} and ${routeId}`);
+      } else {
+        routeAliases.set(normalized, routeId);
+      }
+    }
+
+    for (const resource of routeSpec.resources || []) {
+      const resourcePath = path.join(projectRoot, resource);
+      if (!fs.existsSync(resourcePath)) {
+        errors.push(`${routeId}: missing resource ${path.relative(projectRoot, resourcePath)}`);
+      }
+    }
+
+    if (!Array.isArray(routeSpec.delegationChain) || routeSpec.delegationChain.length === 0) {
+      errors.push(`${routeId}: missing delegation chain`);
+      continue;
+    }
+
+    if (routeSpec.delegationChain[0].from !== routeSpec.owner) {
+      errors.push(`${routeId}: first delegation step must start from the route owner`);
+    }
+
+    for (const [index, step] of routeSpec.delegationChain.entries()) {
+      const stepLabel = `${routeId}.step${index + 1}`;
+
+      if (step.fromType === 'orqx' && !orchestrators[step.from]) {
+        errors.push(`${stepLabel}: unknown from orchestrator ${step.from}`);
+      }
+      if (step.fromType === 'framework-agent' && !frameworkAgents[step.from]) {
+        errors.push(`${stepLabel}: unknown from framework agent ${step.from}`);
+      }
+
+      if (step.toType === 'orqx') {
+        if (!orchestrators[step.to]) {
+          errors.push(`${stepLabel}: unknown target orchestrator ${step.to}`);
+        }
+      } else if (step.toType === 'framework-agent') {
+        if (!frameworkAgents[step.to]) {
+          errors.push(`${stepLabel}: unknown target framework agent ${step.to}`);
+        }
+        if (step.resolver !== 'command-registry') {
+          errors.push(`${stepLabel}: framework-agent steps must use resolver "command-registry"`);
+        }
+        const registryAgent = commandRegistry?.agents?.[frameworkAgents[step.to]?.registryAgentId || step.to];
+        if (!registryAgent) {
+          errors.push(`${stepLabel}: missing command registry entry for ${step.to}`);
+        } else if (!registryAgent.commands?.[step.command]) {
+          errors.push(`${stepLabel}: missing command registry command ${step.to}.${step.command}`);
+        }
+      } else if (step.toType === 'specialist') {
+        const specialistPath = step.path
+          ? path.join(projectRoot, step.path)
+          : path.join(projectRoot, '.codex', 'agents', `${step.to}.md`);
+        if (!fs.existsSync(specialistPath)) {
+          errors.push(`${stepLabel}: missing specialist path ${path.relative(projectRoot, specialistPath)}`);
+        }
+      }
+
+      if (step.path) {
+        const stepPath = path.join(projectRoot, step.path);
+        if (!fs.existsSync(stepPath)) {
+          errors.push(`${stepLabel}: missing path ${path.relative(projectRoot, stepPath)}`);
+        }
+      }
+
+      if (step.task) {
+        const taskPath = path.join(projectRoot, step.task);
+        if (!fs.existsSync(taskPath)) {
+          errors.push(`${stepLabel}: missing task ${path.relative(projectRoot, taskPath)}`);
+        }
+      }
+    }
+
+    if (validatePacket) {
+      const packet = buildHandoffPacket(routeId, projectRoot, matrix);
+      const valid = validatePacket(packet);
+      if (!valid) {
+        errors.push(
+          `${routeId}: handoff packet failed schema validation ${ajv.errorsText(validatePacket.errors, { separator: '; ' })}`,
+        );
+      }
+    }
+  }
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    warnings,
+    metrics: {
+      matrixPath: path.relative(projectRoot, matrixPath),
+      orchestrators: Object.keys(orchestrators).length,
+      routes: routeCount,
+      validatorBackedRoutes: validatorBackedCount,
+      codexOnlyShimRoutes: shimCount,
+      exploratoryRoutes: exploratoryCount,
+    },
+  };
+}
+
+function formatHumanReport(result) {
+  if (result.ok) {
+    return `OK Codex delegation validation passed (orchestrators: ${result.metrics.orchestrators}, routes: ${result.metrics.routes})`;
+  }
+
+  return [
+    `X Codex delegation validation failed (${result.errors.length} issue(s))`,
+    ...result.errors.map((error) => `- ${error}`),
+  ].join('\n');
+}
+
+function main() {
+  const args = parseArgs();
+  const result = validateCodexDelegation(args);
+
+  if (!args.quiet) {
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(formatHumanReport(result));
+    }
+  }
+
+  if (!result.ok) {
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  parseArgs,
+  validateCodexDelegation,
+  formatHumanReport,
+  REQUIRED_ORCHESTRATORS,
+};

package/.sinapse-ai/infrastructure/scripts/validate-codex-sync.js

@@ -6,6 +6,7 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 const { loadCodexCatalogConfig } = require('./codex-parity/catalog');
 const { validateCodexCommandRegistry } = require('./validate-codex-command-registry');
+const { validateCodexDelegation } = require('./validate-codex-delegation');
 const { validateCodexIntegration } = require('./validate-codex-integration');
 const { validateCodexSkills } = require('./codex-skills-sync/validate');
 const { validatePaths } = require('./validate-paths');
@@ -59,6 +60,7 @@ function validateCodexSync(options = {}, deps = {}) {
   const config = loadCodexCatalogConfig(projectRoot);
   const runLegacyValidate = deps.runLegacyCodexValidate || runLegacyCodexValidate;
   const runCodexCommands = deps.validateCodexCommandRegistry || validateCodexCommandRegistry;
+  const runCodexDelegation = deps.validateCodexDelegation || validateCodexDelegation;
   const runCodexIntegration = deps.validateCodexIntegration || validateCodexIntegration;
   const runCodexSkills = deps.validateCodexSkills || validateCodexSkills;
   const runPaths = deps.validatePaths || validatePaths;
@@ -71,6 +73,7 @@ function validateCodexSync(options = {}, deps = {}) {
   const checks = [
     normalizeCheck('codex-integration', runCodexIntegration({ projectRoot, quiet: true })),
     normalizeCheck('codex-commands', runCodexCommands({ projectRoot, quiet: true })),
+    normalizeCheck('codex-delegation', runCodexDelegation({ projectRoot, quiet: true })),
     normalizeCheck('codex-skills', runCodexSkills({ projectRoot, strict: true, quiet: true })),
     normalizeCheck('paths', runPaths({ projectRoot, quiet: true })),
   ];

package/.sinapse-ai/install-manifest.yaml

@@ -7,10 +7,10 @@
 # - SHA256 hashes for change detection
 # - File types for categorization
 #
-version: 7.7.4
-generated_at: "2026-04-03T00:06:05.314Z"
+version: 7.7.6
+generated_at: "2026-04-03T02:11:41.779Z"
 generator: scripts/generate-install-manifest.js
-file_count: 1117
+file_count: 1118
 files:
   - path: cli/commands/config/index.js
     hash: sha256:66f111eceef0f60fa0a8904add783b615d55b01d5fe36408623c3dd828e702f6
@@ -313,9 +313,9 @@ files:
     type: core
     size: 1724
   - path: core/doctor/checks/constitution-consistency.js
-    hash: sha256:7d61a71fcc8eeaf139a9bea634dff99154441808e8411f4290ae5a34fa919951
+    hash: sha256:8da440ef623c8ba300a73f9833fb5b7c5f6e45e50694b488b7580c9738bfb1d8
     type: core
-    size: 3107
+    size: 3139
   - path: core/doctor/checks/core-config.js
     hash: sha256:5424528eefbc2f19213b30d00dcd96128acefdbb289c25712be844f0fbddb963
     type: core
@@ -581,9 +581,9 @@ files:
     type: core
     size: 4733
   - path: core/health-check/checks/project/constitution-consistency.js
-    hash: sha256:63f4aa67ac27b337d017c7b642b1e3554bd02554fa69e29b14ebb8922827b4b9
+    hash: sha256:e6d0320efb88db073f6f877bc63126a9825ce7a896f5629f81ac24394e96a3ec
     type: core
-    size: 5960
+    size: 6044
   - path: core/health-check/checks/project/dependencies.js
     hash: sha256:a8f4d9fcadf5dc3274d8ed0605af6f25d6554b1a9b0d3e66c63d8ea4569c95b9
     type: core
@@ -1237,9 +1237,9 @@ files:
     type: data
     size: 9586
   - path: data/entity-registry.yaml
-    hash: sha256:265b44f0e9c36e85375f05ba88dbf19ed9033244a6eea338f4b8e3a4e453dd12
+    hash: sha256:71b0007c07fe52099eacd433b0e9a40db6163a69cbd4b0687c9f284486afca8f
     type: data
-    size: 514885
+    size: 515685
   - path: data/learned-patterns.yaml
     hash: sha256:24ac0b160615583a0ff783d3da8af80b7f94191575d6db2054ec8e10a3f945dc
     type: data
@@ -3432,14 +3432,18 @@ files:
     hash: sha256:a37a4c5fc8a4c3a7ce7ba240aeea16abc0a75871751f66eeb84991604ff066bf
     type: script
     size: 7266
+  - path: infrastructure/scripts/validate-codex-delegation.js
+    hash: sha256:c084dff34fe7fbc82cb785219f6ed1f33d181fcc6fc9ee06c220ef2cbeaa99b5
+    type: script
+    size: 9551
   - path: infrastructure/scripts/validate-codex-integration.js
     hash: sha256:c553cc493ddbfecf41b865f8a1075df56b6500c3b2b315bae8b7e7bcec4db85a
     type: script
     size: 4742
   - path: infrastructure/scripts/validate-codex-sync.js
-    hash: sha256:f7f2963f995df0dc1fc0a4662146318aa4dba2699c8dbfc4fa748b3201b1db56
+    hash: sha256:31bcfc0cdf307e7c14064eaf0ddbf99a14344c21306937c9a7d9cc7ebba260f8
     type: script
-    size: 4427
+    size: 4679
   - path: infrastructure/scripts/validate-output-pattern.js
     hash: sha256:91111d656e8d7b38a20a1bda753e663b74318f75cdab2025c7e0b84c775fc83d
     type: script
@@ -3969,9 +3973,9 @@ files:
     type: template
     size: 3691
   - path: product/templates/ide-rules/claude-rules.md
-    hash: sha256:e82e8b6cc5c64791ba3a70ca728a920ce522d56e9a60dd0bb4ee76b9a150adf9
+    hash: sha256:819588040a8a7e0e90f49115c2ed4474db06cf6bba190671da6a67b15a4b0b88
     type: template
-    size: 13341
+    size: 13393
   - path: product/templates/ide-rules/codex-rules.md
     hash: sha256:601ffec5e24ff5e247c25e4d61728167503722acc817a1b30fbd695182bed1bc
     type: template

package/.sinapse-ai/product/templates/ide-rules/claude-rules.md

@@ -28,6 +28,7 @@ O SINAPSE possui uma **Constitution formal** com princípios inegociáveis e gat
 | VII | Ecosystem Metrics Accuracy | NON-NEGOTIABLE |
 | VIII | Mandatory Delegation | NON-NEGOTIABLE |
 | IX | Safe Collaboration | NON-NEGOTIABLE |
+| X | Security & Data Protection | NON-NEGOTIABLE |
 
 **Gates automáticos bloqueiam violações.** Consulte a Constitution para detalhes completos.
 <!-- SINAPSE-MANAGED-END: constitution -->

package/docs/codex-delegation-parity.md

@@ -0,0 +1,115 @@
+# Codex Delegation Parity
+
+## Purpose
+
+Codex delegation parity makes `sinapse-orqx -> squad orqx -> specialist` routing explicit, inspectable, and validator-backed without changing `.claude/**`.
+
+The contract lives in:
+
+- `.codex/delegation-parity.json`
+- `.codex/handoff-packet.parity.schema.json`
+- `.codex/scripts/resolve-codex-delegation-parity.js`
+- `.sinapse-ai/infrastructure/scripts/validate-codex-delegation.js`
+
+## Routing Classes
+
+- `validator-backed`: route is approved, resource-backed, and structurally validated
+- `codex-only-shim`: route is intentionally implemented as a Codex compatibility layer
+- `exploratory`: route is documented and discoverable, but not a guaranteed runtime-equivalent path
+
+## Current Contract
+
+The current Codex delegation matrix validates:
+
+- 19 orchestrators
+- 5 framework agents
+- 7 approved routes
+
+Approved route families:
+
+- single-domain squad delegation
+- framework workflow delegation
+- multi-domain launch orchestration
+- exploratory delegation with explicit shared-surface risk
+
+## Supported Routes
+
+### Validator-Backed
+
+- `brand-discovery`
+- `content-funnel-alignment`
+- `growth-seo-audit`
+- `claude-project-setup`
+- `framework-story-delivery`
+
+### Codex-Only Shim
+
+- `multi-domain-launch`
+
+### Exploratory
+
+- `research-competitor-positioning`
+
+## Handoff Packet
+
+Each route produces a normalized handoff packet with:
+
+- `mission`
+- `phase`
+- `owner`
+- `classification`
+- `inputs`
+- `outputs`
+- `validators`
+- `sharedSurfaceRisk`
+- `nextHandoff`
+- `delegationChain`
+
+This packet is the reviewable unit for Codex orchestration.
+
+## CLI Usage
+
+Inspect a route:
+
+```bash
+node .codex/scripts/resolve-codex-delegation-parity.js framework-story-delivery
+```
+
+Inspect JSON:
+
+```bash
+node .codex/scripts/resolve-codex-delegation-parity.js framework-story-delivery --json
+```
+
+Inspect only the handoff packet:
+
+```bash
+node .codex/scripts/resolve-codex-delegation-parity.js framework-story-delivery --packet
+```
+
+Legacy source-aware lookup is still accepted for compatibility:
+
+```bash
+node .codex/scripts/resolve-codex-delegation-parity.js sinapse-orqx framework-story-delivery --json
+```
+
+## Validation
+
+Primary checks:
+
+- `npm run validate:codex-delegation`
+- `npm run validate:codex-sync`
+
+Secondary checks:
+
+- `npm run validate:codex-commands`
+- `npm run validate:codex-integration`
+- `npm run validate:codex-skills`
+- `npm run validate:paths`
+
+## Guardrails
+
+- Do not treat exploratory routes as runtime guarantees
+- Do not change `.claude/**` to make a Codex-only route pass
+- Prefer extending the Codex matrix before altering shared framework behavior
+- Keep framework-agent delegation backed by `.codex/command-registry.json`

package/docs/codex-parity-program.md

@@ -261,6 +261,13 @@ Focus:
 
 Execution detail is now formalized in `docs/codex-total-parity-orchestration-plan.md`.
 
+Current state after Story `7.7.8`:
+
+- a Codex-only delegation parity contract now lives in `.codex/delegation-parity.json`
+- a parity handoff schema now validates delegation packets in `.codex/handoff-packet.parity.schema.json`
+- Codex has a delegation parity resolver CLI for route lookup and packet inspection
+- `validate:codex-delegation` now enforces the approved Codex routing contract
+
 Current recommended implementation story:
 
 - Story `7.7.8` - Codex delegation and handoff parity

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sinapse-ai",
-  "version": "7.7.4",
+  "version": "7.7.6",
   "description": "SINAPSE AI: Framework de orquestracao de IA — 18 squads, 175 agentes especializados",
   "bin": {
     "sinapse": "bin/sinapse.js",
@@ -22,6 +22,8 @@
     ".claude/hooks/",
     ".codex/catalog.json",
     ".codex/command-registry.json",
+    ".codex/delegation-matrix.json",
+    ".codex/handoff-packet.schema.json",
     ".codex/instructions.md",
     ".codex/agents/",
     ".codex/scripts/",
@@ -82,6 +84,7 @@
     "validate:codex-sync": "node .sinapse-ai/infrastructure/scripts/validate-codex-sync.js",
     "validate:codex-integration": "node .sinapse-ai/infrastructure/scripts/validate-codex-integration.js",
     "validate:codex-commands": "node .sinapse-ai/infrastructure/scripts/validate-codex-command-registry.js",
+    "validate:codex-delegation": "node .sinapse-ai/infrastructure/scripts/validate-codex-delegation.js",
     "sync:skills:codex": "node .sinapse-ai/infrastructure/scripts/codex-skills-sync/index.js",
     "sync:skills:codex:global": "node .sinapse-ai/infrastructure/scripts/codex-skills-sync/index.js --global --global-only",
     "validate:codex-skills": "node .sinapse-ai/infrastructure/scripts/codex-skills-sync/validate.js --strict",

package/packages/installer/tests/unit/artifact-copy-pipeline/artifact-copy-pipeline.test.js

@@ -193,12 +193,17 @@ describe('artifact-copy-pipeline (Story INS-4.3)', () => {
       expect(config.timeout).toBe(10);
     });
 
-    test('covers all 3 known hooks', () => {
+    test('covers all known hooks', () => {
       const keys = Object.keys(HOOK_EVENT_MAP);
-      expect(keys).toHaveLength(3);
+      expect(keys).toHaveLength(8);
       expect(keys).toContain('synapse-engine.cjs');
       expect(keys).toContain('code-intel-pretool.cjs');
       expect(keys).toContain('precompact-session-digest.cjs');
+      expect(keys).toContain('enforce-architecture-first.cjs');
+      expect(keys).toContain('enforce-story-gate.cjs');
+      expect(keys).toContain('write-path-validation.cjs');
+      expect(keys).toContain('enforce-delegation.cjs');
+      expect(keys).toContain('secret-scanning.cjs');
     });
 
     test('DEFAULT_HOOK_CONFIG falls back to UserPromptSubmit', () => {