sinapse-ai 7.7.4 → 7.7.5

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

@@ -567,3 +567,6 @@
 {"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"}

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

@@ -0,0 +1,292 @@
+#!/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'));
+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-matrix.json');
+  const schemaPath = path.join(projectRoot, matrix.handoffSchema || '.codex/handoff-packet.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.5
+generated_at: "2026-04-03T00:28:11.575Z"
 generator: scripts/generate-install-manifest.js
-file_count: 1117
+file_count: 1118
 files:
   - path: cli/commands/config/index.js
     hash: sha256:66f111eceef0f60fa0a8904add783b615d55b01d5fe36408623c3dd828e702f6
@@ -1237,9 +1237,9 @@ files:
     type: data
     size: 9586
   - path: data/entity-registry.yaml
-    hash: sha256:265b44f0e9c36e85375f05ba88dbf19ed9033244a6eea338f4b8e3a4e453dd12
+    hash: sha256:e3e57f3070134b76851762a0666b665228f061d3ff37ee513e7b6ae5dcef3b62
     type: data
-    size: 514885
+    size: 515807
   - 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:a71224ad31b3a28bcc26953f75bbd6387686b3b906404c833f52b8dfff306384
+    type: script
+    size: 9532
   - 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sinapse-ai",
-  "version": "7.7.4",
+  "version": "7.7.5",
   "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', () => {