sinapse-ai 1.8.0 → 1.9.1

package/.codex/scripts/resolve-codex-command.js

@@ -4,6 +4,11 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+  resolveCodexAgent,
+  resolveCodexAgentCommand,
+} = require('./resolve-codex-agent');
+
 const PROJECT_ROOT = path.resolve(__dirname, '..', '..');
 const REGISTRY_PATH = path.join(PROJECT_ROOT, '.codex', 'command-registry.json');
 
@@ -62,23 +67,80 @@ function resolveCommand(agentSpec, commandInput) {
 function resolveCodexCommand(agentInput, commandInput, projectRoot = PROJECT_ROOT) {
   const registry = loadCommandRegistry(projectRoot);
   const agent = resolveAgent(registry, agentInput);
-  if (!agent) {
-    throw new Error(`Unknown Codex agent "${agentInput}"`);
+
+  // Tier 1 — curated registry (the SDC core agents with explicit command maps).
+  if (agent) {
+    const command = resolveCommand(agent.agentSpec, commandInput);
+    if (command) {
+      return {
+        agentId: agent.agentId,
+        skillId: agent.agentSpec.skillId,
+        commandId: command.commandId,
+        kind: command.commandSpec.kind,
+        target: command.commandSpec.target,
+        resources: command.commandSpec.resources || [],
+        sourceOfTruth: agent.agentSpec.sourceOfTruth,
+        resolvedBy: 'registry',
+      };
+    }
+    // Agent is in the registry but the command isn't — fall through to the
+    // parametric activator (the agent may own squad/dev tasks beyond its
+    // curated commands).
   }
 
-  const command = resolveCommand(agent.agentSpec, commandInput);
-  if (!command) {
-    throw new Error(`Unknown Codex command "${commandInput}" for agent "${agent.agentId}"`);
+  // Tier 2 — parametric activator: resolves ANY of the ~172 agents and the
+  // tasks they actually own from source, with on-disk pointer verification.
+  try {
+    const parametric = resolveCodexAgentCommand(agentInput, commandInput, projectRoot);
+    return {
+      agentId: parametric.agentId,
+      skillId: null,
+      squad: parametric.squad,
+      commandId: parametric.commandId,
+      kind: parametric.kind,
+      target: parametric.target,
+      resources: [],
+      sourceOfTruth: parametric.sourceOfTruth,
+      resolvedBy: 'activator',
+    };
+  } catch (err) {
+    // If the agent existed in the curated registry but neither tier knew the
+    // command, report a command error (not an agent error).
+    if (agent && /Unknown Codex agent/.test(err.message)) {
+      throw new Error(
+        `Unknown Codex command "${commandInput}" for agent "${agent.agentId}"`,
+      );
+    }
+    throw err;
   }
+}
 
+/**
+ * Resolve an agent (without a specific command) across BOTH tiers. Returns the
+ * curated registry entry when present, otherwise the parametric activator view.
+ * Guarantees every one of the ~172 agents resolves — never "Unknown Codex agent".
+ */
+function resolveCodexAgentEntry(agentInput, projectRoot = PROJECT_ROOT) {
+  const registry = loadCommandRegistry(projectRoot);
+  const agent = resolveAgent(registry, agentInput);
+  if (agent) {
+    return {
+      agentId: agent.agentId,
+      skillId: agent.agentSpec.skillId,
+      sourceOfTruth: agent.agentSpec.sourceOfTruth,
+      commands: Object.keys(agent.agentSpec.commands || {}),
+      resolvedBy: 'registry',
+    };
+  }
+  const parametric = resolveCodexAgent(agentInput, projectRoot);
   return {
-    agentId: agent.agentId,
-    skillId: agent.agentSpec.skillId,
-    commandId: command.commandId,
-    kind: command.commandSpec.kind,
-    target: command.commandSpec.target,
-    resources: command.commandSpec.resources || [],
-    sourceOfTruth: agent.agentSpec.sourceOfTruth,
+    agentId: parametric.agentId,
+    skillId: null,
+    squad: parametric.squad,
+    sourceOfTruth: parametric.sourceOfTruth,
+    taskCount: parametric.taskCount,
+    commands: parametric.tasks.map((t) => t.command),
+    resolvedBy: 'activator',
   };
 }
 
@@ -142,6 +204,7 @@ module.exports = {
   resolveAgent,
   resolveCommand,
   resolveCodexCommand,
+  resolveCodexAgentEntry,
   parseArgs,
   formatHumanResult,
 };

package/.codex/scripts/resolve-codex-delegation.js

@@ -5,151 +5,187 @@ const fs = require('fs');
 const path = require('path');
 
 const PROJECT_ROOT = path.resolve(__dirname, '..', '..');
+const MATRIX_PATH = path.join('.codex', 'delegation-matrix.json');
 
 function loadDelegationMatrix(projectRoot = PROJECT_ROOT) {
-  const matrixPath = path.join(projectRoot, '.codex', 'delegation-matrix.json');
+  const matrixPath = path.join(projectRoot, MATRIX_PATH);
   const raw = fs.readFileSync(matrixPath, 'utf8');
   return JSON.parse(raw);
 }
 
-function normalizeAgentInput(value) {
-  return String(value || '').trim().replace(/^@/, '').toLowerCase();
+function normalizeRouteInput(value) {
+  return String(value || '')
+    .trim()
+    .replace(/^[@*]/, '')
+    .toLowerCase();
 }
 
-function normalizeRouteInput(value) {
-  return String(value || '').trim().replace(/^\*/, '').toLowerCase();
+function normalizeActorInput(value) {
+  return String(value || '')
+    .trim()
+    .replace(/^@/, '')
+    .toLowerCase();
 }
 
-function collectAliases(routeId, routeSpec) {
+function collectRouteAliases(routeId, routeSpec) {
   return [routeId, ...(routeSpec.aliases || [])]
     .map((alias) => normalizeRouteInput(alias))
     .filter(Boolean);
 }
 
-function getSourceAgentConfig(matrix, agentInput) {
-  const normalized = normalizeAgentInput(agentInput);
-
-  if (['sinapse-orqx', 'imperator'].includes(normalized)) {
-    return {
-      sourceAgent: 'sinapse-orqx',
-      routes: {
-        ...(matrix.masterRoutes || {}),
-        ...(matrix.orqxRoutes || {}),
-      },
-    };
-  }
-
-  const matches = Object.entries(matrix.specialistRoutes || {})
-    .filter(([sourceAgentId, sourceSpec]) => {
-      const aliases = [sourceAgentId, ...(sourceSpec.aliases || [])]
-        .map((alias) => normalizeAgentInput(alias))
-        .filter(Boolean);
-      return aliases.includes(normalized);
-    });
+function resolveDelegationRoute(routeInput, projectRoot = PROJECT_ROOT, matrix = loadDelegationMatrix(projectRoot)) {
+  const normalized = normalizeRouteInput(routeInput);
+  const matches = Object.entries(matrix.routes || {}).filter(([routeId, routeSpec]) =>
+    collectRouteAliases(routeId, routeSpec).includes(normalized),
+  );
 
   if (matches.length > 1) {
-    throw new Error(`Ambiguous Codex delegation source "${agentInput}"`);
+    throw new Error(`Ambiguous Codex delegation route "${routeInput}"`);
   }
 
-  if (matches.length === 1) {
-    return {
-      sourceAgent: matches[0][0],
-      routes: matches[0][1].routes || {},
-    };
+  if (matches.length === 0) {
+    throw new Error(`Unknown Codex delegation route "${routeInput}"`);
   }
 
-  return null;
+  const [routeId, routeSpec] = matches[0];
+  return { routeId, routeSpec };
 }
 
-function resolveRoute(routes, routeInput) {
-  const normalized = normalizeRouteInput(routeInput);
-  const matches = Object.entries(routes || {})
-    .filter(([routeId, routeSpec]) => collectAliases(routeId, routeSpec).includes(normalized));
+function resolveRouteRecord(routeInput, projectRoot = PROJECT_ROOT, matrix = loadDelegationMatrix(projectRoot)) {
+  if (
+    routeInput &&
+    typeof routeInput === 'object' &&
+    typeof routeInput.routeId === 'string' &&
+    routeInput.routeSpec &&
+    typeof routeInput.routeSpec === 'object'
+  ) {
+    return routeInput;
+  }
 
-  if (matches.length > 1) {
-    throw new Error(`Ambiguous Codex delegation route "${routeInput}"`);
+  return resolveDelegationRoute(routeInput, projectRoot, matrix);
+}
+
+function routeMentionsSource(routeSpec, sourceInput) {
+  const normalizedSource = normalizeActorInput(sourceInput);
+  if (!normalizedSource) {
+    return true;
   }
 
-  if (matches.length === 0) {
-    return null;
+  if (normalizeActorInput(routeSpec.owner) === normalizedSource) {
+    return true;
   }
 
+  return (routeSpec.delegationChain || []).some(
+    (step) =>
+      normalizeActorInput(step.from) === normalizedSource ||
+      normalizeActorInput(step.to) === normalizedSource,
+  );
+}
+
+function buildHandoffPacket(routeInput, projectRoot = PROJECT_ROOT, matrix = loadDelegationMatrix(projectRoot)) {
+  const { routeId, routeSpec } = resolveRouteRecord(routeInput, projectRoot, matrix);
+  const chain = routeSpec.delegationChain || [];
+  // The next handoff is the immediate next actor the owner hands the work to,
+  // i.e. the target of the first delegation step.
+  const nextStep = chain[0] || null;
+
   return {
-    routeId: matches[0][0],
-    routeSpec: matches[0][1],
+    routeId,
+    mission: routeSpec.mission,
+    phase: matrix.phase || 'W5 / Delegation Matrix Parity',
+    owner: routeSpec.owner,
+    classification: routeSpec.classification,
+    summary: routeSpec.summary || '',
+    inputs: routeSpec.inputs || [],
+    outputs: routeSpec.outputs || [],
+    validators: routeSpec.validators || [],
+    sharedSurfaceRisk: routeSpec.sharedSurfaceRisk || 'low',
+    nextHandoff: {
+      to: nextStep?.to || routeSpec.owner,
+      artifact: routeSpec.outputs?.[0] || 'handoff-packet',
+    },
+    delegationChain: chain,
+    resources: routeSpec.resources || [],
+    notes: routeSpec.notes || [],
   };
 }
 
-function resolveCodexDelegation(agentInput, routeInput, projectRoot = PROJECT_ROOT) {
-  const matrix = loadDelegationMatrix(projectRoot);
-  const source = getSourceAgentConfig(matrix, agentInput);
-  if (!source) {
-    throw new Error(`Unknown Codex delegation source "${agentInput}"`);
-  }
+function resolveCodexDelegation(routeInput, projectRoot = PROJECT_ROOT, options = {}) {
+  const matrix = options.matrix || loadDelegationMatrix(projectRoot);
+  const { routeId, routeSpec } = resolveDelegationRoute(routeInput, projectRoot, matrix);
 
-  const route = resolveRoute(source.routes, routeInput);
-  if (!route) {
-    throw new Error(`Unknown Codex delegation route "${routeInput}" for source "${source.sourceAgent}"`);
+  if (options.source && !routeMentionsSource(routeSpec, options.source)) {
+    throw new Error(
+      `Codex delegation route "${routeId}" is not available from source "${options.source}"`,
+    );
   }
 
   return {
-    sourceAgent: source.sourceAgent,
-    routeId: route.routeId,
-    classification: route.routeSpec.classification,
-    target: route.routeSpec.target,
-    handoff: route.routeSpec.handoff || null,
-    sourceDocs: route.routeSpec.sourceDocs || [],
-    handoffSchemaPath: matrix.handoffSchemaPath,
-    handoffTemplatePath: matrix.handoffTemplatePath,
+    routeId,
+    owner: routeSpec.owner,
+    requestType: routeSpec.requestType,
+    classification: routeSpec.classification,
+    mission: routeSpec.mission,
+    summary: routeSpec.summary || '',
+    inputs: routeSpec.inputs || [],
+    outputs: routeSpec.outputs || [],
+    validators: routeSpec.validators || [],
+    sharedSurfaceRisk: routeSpec.sharedSurfaceRisk || 'low',
+    resources: routeSpec.resources || [],
+    delegationChain: routeSpec.delegationChain || [],
+    handoffPacket: buildHandoffPacket({ routeId, routeSpec }, projectRoot, matrix),
   };
 }
 
 function parseArgs(argv = process.argv.slice(2)) {
-  const args = argv.filter((arg) => !arg.startsWith('--'));
   const flags = new Set(argv.filter((arg) => arg.startsWith('--')));
+  const args = argv.filter((arg) => !arg.startsWith('--'));
+
   return {
-    agent: args[0],
-    route: args[1],
+    // Route is always the last positional. An optional leading positional is a
+    // source-agent filter, kept for backward compatibility with the legacy
+    // `<source> <route>` CLI shape.
+    source: args.length > 1 ? args[0] : null,
+    route: args.length > 1 ? args[1] : args[0],
     json: flags.has('--json'),
+    packet: flags.has('--packet'),
   };
 }
 
 function formatHumanResult(result) {
-  const lines = [
-    `Source: ${result.sourceAgent}`,
+  const nextHandoff = result.handoffPacket?.nextHandoff?.to || 'n/a';
+  const delegationPath = (result.delegationChain || [])
+    .map((step) => `${step.from} -> ${step.to}`)
+    .join(' | ');
+
+  return [
     `Route: ${result.routeId}`,
+    `Owner: ${result.owner}`,
+    `Request Type: ${result.requestType}`,
     `Classification: ${result.classification}`,
-    `Target Type: ${result.target.type}`,
-    `Target Agent: ${result.target.agentId}`,
-  ];
-
-  if (result.target.commandId) {
-    lines.push(`Target Command: ${result.target.commandId}`);
-  }
-  if (result.target.docPath) {
-    lines.push(`Target Doc: ${result.target.docPath}`);
-  }
-  if (result.target.taskPath) {
-    lines.push(`Target Task: ${result.target.taskPath}`);
-  }
-  if (result.handoff) {
-    lines.push(`Next Handoff: ${result.handoff.nextHandoff}`);
-  }
-
-  return lines.join('\n');
+    `Next Handoff: ${nextHandoff}`,
+    `Delegation Chain: ${delegationPath || 'n/a'}`,
+  ].join('\n');
 }
 
 function main() {
   const args = parseArgs();
-  if (!args.agent || !args.route) {
-    console.error('Usage: node .codex/scripts/resolve-codex-delegation.js <source-agent> <route> [--json]');
+  if (!args.route) {
+    console.error(
+      'Usage: node .codex/scripts/resolve-codex-delegation.js <route> [--json] [--packet]\n' +
+        '   or: node .codex/scripts/resolve-codex-delegation.js <source-agent> <route> [--json] [--packet]',
+    );
     process.exit(1);
   }
 
   try {
-    const result = resolveCodexDelegation(args.agent, args.route);
-    if (args.json) {
-      console.log(JSON.stringify(result, null, 2));
+    const result = resolveCodexDelegation(args.route, PROJECT_ROOT, {
+      source: args.source,
+    });
+    const payload = args.packet ? result.handoffPacket : result;
+
+    if (args.json || args.packet) {
+      console.log(JSON.stringify(payload, null, 2));
     } else {
       console.log(formatHumanResult(result));
     }
@@ -164,12 +200,15 @@ if (require.main === module) {
 }
 
 module.exports = {
+  MATRIX_PATH,
   loadDelegationMatrix,
-  normalizeAgentInput,
   normalizeRouteInput,
-  collectAliases,
-  getSourceAgentConfig,
-  resolveRoute,
+  normalizeActorInput,
+  collectRouteAliases,
+  resolveDelegationRoute,
+  resolveRouteRecord,
+  routeMentionsSource,
+  buildHandoffPacket,
   resolveCodexDelegation,
   parseArgs,
   formatHumanResult,

package/.codex/skills/sinapse-claude/SKILL.md

@@ -9,8 +9,8 @@ description: Claude Code, MCP, hooks, skills, integracao avancada
 Claude Code, MCP, hooks, skills, integracao avancada
 
 ## Activation Protocol
-1. Load `squads/squad-claude/agents/claude-orqx.md` as source of truth (fallback: `.codex/agents/claude-orqx.md`).
-2. Load squad knowledge base from `squads/squad-claude/knowledge-base/`.
+1. Load `squads/claude-code-mastery/agents/swarm-orqx.md` as source of truth (fallback: `.codex/agents/swarm-orqx.md`).
+2. Load squad knowledge base from `squads/claude-code-mastery/knowledge-base/`.
 3. Adopt the orqx persona and command system.
 4. Stay in this persona until the user asks to switch or exit.
 
@@ -24,5 +24,5 @@ Claude Code, MCP, hooks, skills, integracao avancada
 ## Non-Negotiables
 - Follow `.sinapse-ai/constitution.md`.
 - Load squad KB before executing any task.
-- Execute tasks only from `squads/squad-claude/tasks/`.
+- Execute tasks only from `squads/claude-code-mastery/tasks/`.
 - Output quality: 5.0/5.0 minimum.

package/.codex/skills/sinapse-po/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: sinapse-po
-description: Product Owner (Pax). Use for backlog management, story refinement, acceptance criteria, sprint planning, and prioritization decisions
+description: Product Owner (Axis). Use for backlog management, story refinement, acceptance criteria, sprint planning, and prioritization decisions
 ---
 
 # SINAPSE Product Owner Activator

package/.codex/tasks/resolve-sinapse-conflict.md

@@ -10,7 +10,7 @@ Resolve cross-squad conflicts or domain overlap without relying on shared-runtim
 
 ## Steps
 
-1. Read `.codex/catalog.json`, `.codex/agents/sinapse-orqx.md`, and `docs/codex-parity-program.md`.
+1. Read `.codex/catalog.json`, `.codex/agents/snps-orqx.md`, and `docs/framework/codex-parity/codex-parity-program.md`.
 2. Identify the squads, agents, or workflow surfaces in conflict.
 3. Separate the problem into:
    - ownership conflict

package/.sinapse-ai/constitution.md

@@ -148,12 +148,12 @@ Métricas do ecossistema (contagem de squads, agentes, tasks, orqx) DEVEM ser es
 **Números canônicos atuais:**
 
 <!-- BEGIN AUTO-GENERATED COUNTS (sync via `npm run sync:counts`) -->
-- **18 squads** (diretórios em `squads/`)
-- **189 agentes** (177 em squads + 12 framework agents)
-- **21 comandos orqx** (20 squad orqx + 1 master sinapse-orqx)
-- **1213 tasks** (em `squads/*/tasks/`)
+- **17 squads** (diretórios em `squads/`)
+- **172 agentes** (160 em squads + 12 framework agents)
+- **18 comandos orqx** (17 squad orqx + 1 master sinapse-orqx)
+- **1200 tasks** (em `squads/*/tasks/`)
 
-*Last synced: 2026-05-08T23:25:53.040Z*
+*Last synced: 2026-06-18T04:58:21.153Z*
 <!-- END AUTO-GENERATED COUNTS -->