sinapse-ai 7.7.5 → 7.7.6

package/.codex/handoff-packet.schema.json

@@ -1,25 +1,19 @@
 {
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "title": "Codex Delegation Handoff Packet",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Codex Handoff Packet",
   "type": "object",
   "additionalProperties": false,
   "required": [
     "mission",
     "phase",
     "owner",
-    "classification",
     "inputs",
     "outputs",
     "validators",
-    "sharedSurfaceRisk",
-    "nextHandoff",
-    "delegationChain"
+    "shared-surface-risk",
+    "next-handoff"
   ],
   "properties": {
-    "routeId": {
-      "type": "string",
-      "minLength": 1
-    },
     "mission": {
       "type": "string",
       "minLength": 1
@@ -32,15 +26,9 @@
       "type": "string",
       "minLength": 1
     },
-    "classification": {
-      "type": "string",
-      "enum": ["validator-backed", "codex-only-shim", "exploratory"]
-    },
-    "summary": {
-      "type": "string"
-    },
     "inputs": {
       "type": "array",
+      "minItems": 1,
       "items": {
         "type": "string",
         "minLength": 1
@@ -48,6 +36,7 @@
     },
     "outputs": {
       "type": "array",
+      "minItems": 1,
       "items": {
         "type": "string",
         "minLength": 1
@@ -55,93 +44,24 @@
     },
     "validators": {
       "type": "array",
+      "minItems": 1,
       "items": {
         "type": "string",
         "minLength": 1
       }
     },
-    "sharedSurfaceRisk": {
+    "shared-surface-risk": {
       "type": "string",
-      "enum": ["low", "medium", "high"]
-    },
-    "nextHandoff": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["to", "artifact"],
-      "properties": {
-        "to": {
-          "type": "string",
-          "minLength": 1
-        },
-        "artifact": {
-          "type": "string",
-          "minLength": 1
-        }
-      }
+      "enum": ["none", "codex-only", "shared-review-required"]
     },
-    "delegationChain": {
-      "type": "array",
-      "minItems": 1,
-      "items": {
-        "type": "object",
-        "additionalProperties": false,
-        "required": ["from", "fromType", "to", "toType", "handoff", "reason"],
-        "properties": {
-          "from": {
-            "type": "string",
-            "minLength": 1
-          },
-          "fromType": {
-            "type": "string",
-            "enum": ["orqx", "framework-agent", "specialist"]
-          },
-          "to": {
-            "type": "string",
-            "minLength": 1
-          },
-          "toType": {
-            "type": "string",
-            "enum": ["orqx", "framework-agent", "specialist"]
-          },
-          "path": {
-            "type": "string",
-            "minLength": 1
-          },
-          "task": {
-            "type": "string",
-            "minLength": 1
-          },
-          "resolver": {
-            "type": "string",
-            "minLength": 1
-          },
-          "command": {
-            "type": "string",
-            "minLength": 1
-          },
-          "handoff": {
-            "type": "string",
-            "minLength": 1
-          },
-          "reason": {
-            "type": "string",
-            "minLength": 1
-          }
-        }
-      }
-    },
-    "resources": {
-      "type": "array",
-      "items": {
-        "type": "string",
-        "minLength": 1
-      }
+    "next-handoff": {
+      "type": "string",
+      "minLength": 1
     },
     "notes": {
       "type": "array",
       "items": {
-        "type": "string",
-        "minLength": 1
+        "type": "string"
       }
     }
   }

package/.codex/scripts/resolve-codex-delegation-parity.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-parity.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-parity.js <route> [--json] [--packet]\n' +
+        '   or: node .codex/scripts/resolve-codex-delegation-parity.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/scripts/resolve-codex-delegation.js

@@ -5,181 +5,151 @@ 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 matrixPath = path.join(projectRoot, '.codex', 'delegation-matrix.json');
   const raw = fs.readFileSync(matrixPath, 'utf8');
   return JSON.parse(raw);
 }
 
-function normalizeRouteInput(value) {
-  return String(value || '')
-    .trim()
-    .replace(/^[@*]/, '')
-    .toLowerCase();
+function normalizeAgentInput(value) {
+  return String(value || '').trim().replace(/^@/, '').toLowerCase();
 }
 
-function normalizeActorInput(value) {
-  return String(value || '')
-    .trim()
-    .replace(/^@/, '')
-    .toLowerCase();
+function normalizeRouteInput(value) {
+  return String(value || '').trim().replace(/^\*/, '').toLowerCase();
 }
 
-function collectRouteAliases(routeId, routeSpec) {
+function collectAliases(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),
-  );
+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);
+    });
 
   if (matches.length > 1) {
-    throw new Error(`Ambiguous Codex delegation route "${routeInput}"`);
+    throw new Error(`Ambiguous Codex delegation source "${agentInput}"`);
   }
 
-  if (matches.length === 0) {
-    throw new Error(`Unknown Codex delegation route "${routeInput}"`);
+  if (matches.length === 1) {
+    return {
+      sourceAgent: matches[0][0],
+      routes: matches[0][1].routes || {},
+    };
   }
 
-  const [routeId, routeSpec] = matches[0];
-  return { routeId, routeSpec };
+  return null;
 }
 
-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 resolveRoute(routes, routeInput) {
+  const normalized = normalizeRouteInput(routeInput);
+  const matches = Object.entries(routes || {})
+    .filter(([routeId, routeSpec]) => collectAliases(routeId, routeSpec).includes(normalized));
 
-function routeMentionsSource(routeSpec, sourceInput) {
-  const normalizedSource = normalizeActorInput(sourceInput);
-  if (!normalizedSource) {
-    return true;
+  if (matches.length > 1) {
+    throw new Error(`Ambiguous Codex delegation route "${routeInput}"`);
   }
 
-  if (normalizeActorInput(routeSpec.owner) === normalizedSource) {
-    return true;
+  if (matches.length === 0) {
+    return null;
   }
 
-  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 || [],
+    routeId: matches[0][0],
+    routeSpec: matches[0][1],
   };
 }
 
-function resolveCodexDelegation(routeInput, projectRoot = PROJECT_ROOT, options = {}) {
-  const matrix = options.matrix || loadDelegationMatrix(projectRoot);
-  const { routeId, routeSpec } = resolveDelegationRoute(routeInput, projectRoot, matrix);
+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}"`);
+  }
 
-  if (options.source && !routeMentionsSource(routeSpec, options.source)) {
-    throw new Error(
-      `Codex delegation route "${routeId}" is not available from source "${options.source}"`,
-    );
+  const route = resolveRoute(source.routes, routeInput);
+  if (!route) {
+    throw new Error(`Unknown Codex delegation route "${routeInput}" for source "${source.sourceAgent}"`);
   }
 
   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),
+    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,
   };
 }
 
 function parseArgs(argv = process.argv.slice(2)) {
-  const flags = new Set(argv.filter((arg) => arg.startsWith('--')));
   const args = argv.filter((arg) => !arg.startsWith('--'));
-
+  const flags = new Set(argv.filter((arg) => arg.startsWith('--')));
   return {
-    source: args.length > 1 ? args[0] : null,
-    route: args.length > 1 ? args[1] : args[0],
+    agent: args[0],
+    route: args[1],
     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 [
+  const lines = [
+    `Source: ${result.sourceAgent}`,
     `Route: ${result.routeId}`,
-    `Owner: ${result.owner}`,
-    `Request Type: ${result.requestType}`,
     `Classification: ${result.classification}`,
-    `Next Handoff: ${nextHandoff}`,
-    `Delegation Chain: ${delegationPath || 'n/a'}`,
-  ].join('\n');
+    `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');
 }
 
 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]',
-    );
+  if (!args.agent || !args.route) {
+    console.error('Usage: node .codex/scripts/resolve-codex-delegation.js <source-agent> <route> [--json]');
     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));
+    const result = resolveCodexDelegation(args.agent, args.route);
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
     } else {
       console.log(formatHumanResult(result));
     }
@@ -194,11 +164,12 @@ if (require.main === module) {
 }
 
 module.exports = {
-  MATRIX_PATH,
   loadDelegationMatrix,
+  normalizeAgentInput,
   normalizeRouteInput,
-  resolveDelegationRoute,
-  buildHandoffPacket,
+  collectAliases,
+  getSourceAgentConfig,
+  resolveRoute,
   resolveCodexDelegation,
   parseArgs,
   formatHumanResult,

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

@@ -11,7 +11,7 @@ Diagnose a request and choose the smallest correct Codex routing path.
 ## Steps
 
 1. Read `.codex/catalog.json`.
-2. Read `.codex/delegation-matrix.json`.
+2. Read `.codex/delegation-parity.json`.
 3. Classify the request as one of:
    - simple + single-domain
    - complex + single-domain
@@ -22,7 +22,7 @@ Diagnose a request and choose the smallest correct Codex routing path.
    - 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`
-5. When the request matches an approved handoff route, resolve it through `.codex/delegation-matrix.json`.
+5. When the request matches an approved handoff route, resolve it through `.codex/delegation-parity.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.