sinapse-ai 7.7.4 → 7.7.5

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

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+'use strict';
+
+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, MATRIX_PATH);
+  const raw = fs.readFileSync(matrixPath, 'utf8');
+  return JSON.parse(raw);
+}
+
+function normalizeRouteInput(value) {
+  return String(value || '')
+    .trim()
+    .replace(/^[@*]/, '')
+    .toLowerCase();
+}
+
+function normalizeActorInput(value) {
+  return String(value || '')
+    .trim()
+    .replace(/^@/, '')
+    .toLowerCase();
+}
+
+function collectRouteAliases(routeId, routeSpec) {
+  return [routeId, ...(routeSpec.aliases || [])]
+    .map((alias) => normalizeRouteInput(alias))
+    .filter(Boolean);
+}
+
+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 route "${routeInput}"`);
+  }
+
+  if (matches.length === 0) {
+    throw new Error(`Unknown Codex delegation route "${routeInput}"`);
+  }
+
+  const [routeId, routeSpec] = matches[0];
+  return { routeId, routeSpec };
+}
+
+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;
+  }
+
+  return resolveDelegationRoute(routeInput, projectRoot, matrix);
+}
+
+function routeMentionsSource(routeSpec, sourceInput) {
+  const normalizedSource = normalizeActorInput(sourceInput);
+  if (!normalizedSource) {
+    return true;
+  }
+
+  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 nextStep = routeSpec.delegationChain?.[0] || null;
+
+  return {
+    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: routeSpec.delegationChain || [],
+    resources: routeSpec.resources || [],
+    notes: routeSpec.notes || [],
+  };
+}
+
+function resolveCodexDelegation(routeInput, projectRoot = PROJECT_ROOT, options = {}) {
+  const matrix = options.matrix || loadDelegationMatrix(projectRoot);
+  const { routeId, routeSpec } = resolveDelegationRoute(routeInput, projectRoot, matrix);
+
+  if (options.source && !routeMentionsSource(routeSpec, options.source)) {
+    throw new Error(
+      `Codex delegation route "${routeId}" is not available from source "${options.source}"`,
+    );
+  }
+
+  return {
+    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 flags = new Set(argv.filter((arg) => arg.startsWith('--')));
+  const args = argv.filter((arg) => !arg.startsWith('--'));
+
+  return {
+    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 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}`,
+    `Next Handoff: ${nextHandoff}`,
+    `Delegation Chain: ${delegationPath || 'n/a'}`,
+  ].join('\n');
+}
+
+function main() {
+  const args = parseArgs();
+  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.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));
+    }
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  MATRIX_PATH,
+  loadDelegationMatrix,
+  normalizeRouteInput,
+  resolveDelegationRoute,
+  buildHandoffPacket,
+  resolveCodexDelegation,
+  parseArgs,
+  formatHumanResult,
+};

package/.codex/tasks/route-sinapse-request.md

@@ -11,19 +11,21 @@ Diagnose a request and choose the smallest correct Codex routing path.
 ## Steps
 
 1. Read `.codex/catalog.json`.
-2. Classify the request as one of:
+2. Read `.codex/delegation-matrix.json`.
+3. Classify the request as one of:
    - simple + single-domain
    - complex + single-domain
    - complex + multi-domain
    - framework/development workflow
-3. Prefer the smallest correct path:
+4. Prefer the smallest correct path:
    - simple + single-domain -> relevant `*-orqx` or validated framework agent
    - complex + single-domain -> relevant `*-orqx`
    - complex + multi-domain -> `sinapse-orqx` orchestration plan
    - framework/development workflow -> `sinapse-pm`, `sinapse-po`, `sinapse-sm`, `sinapse-dev`, or `sinapse-qa`
-4. If the request depends on a starred command, resolve it through `.codex/command-registry.json`.
-5. Only recommend direct specialist routing from `.codex/agents` when it is an exploratory fallback rather than a validator-backed path.
-6. Return the recommended route with rationale and next action.
+5. When the request matches an approved handoff route, resolve it through `.codex/delegation-matrix.json`.
+6. If the request depends on a starred command, resolve it through `.codex/command-registry.json`.
+7. Only recommend direct specialist routing from `.codex/agents` when the delegation matrix marks it as `exploratory`.
+8. Return the recommended route with rationale, classification, and next action.
 
 ## Output Contract