sinapse-ai 1.24.0 → 1.25.1

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

@@ -113,11 +113,40 @@ const STATIC_ALIASES = {
   pm: 'project-lead',
   po: 'product-lead',
   sm: 'sprint-lead',
+  'sinapse-dev': 'developer',
+  'sinapse-qa': 'quality-gate',
+  'sinapse-pm': 'project-lead',
+  'sinapse-po': 'product-lead',
+  'sinapse-sm': 'sprint-lead',
+  'sinapse-architect': 'architect',
+  'sinapse-analyst': 'analyst',
+  'sinapse-data-engineer': 'data-engineer',
+  'sinapse-devops': 'devops',
+  'sinapse-squad-creator': 'squad-creator',
+  'sinapse-ux-design-expert': 'ux-design-expert',
   imperator: 'snps-orqx',
   'sinapse-orqx': 'snps-orqx',
   sinapse: 'snps-orqx',
   snps: 'snps-orqx',
-  'claude-orqx': 'swarm-orqx',
+  'claude-orqx': 'claude-mastery-chief',
+  'sinapse-claude': 'claude-mastery-chief',
+  'sinapse-swarm': 'swarm-orqx',
+  'sinapse-brand': 'brand-orqx',
+  'sinapse-animations': 'animations-orqx',
+  'sinapse-cloning': 'cloning-orqx',
+  'sinapse-commercial': 'commercial-orqx',
+  'sinapse-content': 'content-orqx',
+  'sinapse-copy': 'copy-orqx',
+  'sinapse-council': 'council-orqx',
+  'sinapse-courses': 'courses-orqx',
+  'sinapse-cyber': 'cyber-orqx',
+  'sinapse-design': 'design-orqx',
+  'sinapse-finance': 'finance-orqx',
+  'sinapse-growth': 'growth-orqx',
+  'sinapse-paidmedia': 'paidmedia-orqx',
+  'sinapse-product': 'product-orqx',
+  'sinapse-research': 'research-orqx',
+  'sinapse-storytelling': 'storytelling-orqx',
 };
 
 function resolveAgentId(index, agentInput) {

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

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+const PROJECT_ROOT = path.resolve(__dirname, '..', '..');
+const SPEC_WORKFLOW_PATH = '.sinapse-ai/development/workflows/spec-pipeline.yaml';
+const TASKS_DIR = '.sinapse-ai/development/tasks';
+const DELEGATION_MATRIX_PATH = '.codex/delegation-matrix.json';
+
+const WORKFLOW_ALIASES = Object.freeze({
+  spec: 'spec',
+  'create-spec': 'spec',
+  'spec-pipeline': 'plan',
+  plan: 'plan',
+  orchestrate: 'orchestrate',
+});
+
+const PHASE_ALIASES = Object.freeze({
+  critique_1: 'critique',
+});
+
+const PHASE_TASK_FALLBACKS = Object.freeze({
+  revise: 'spec-write-spec.md',
+});
+
+const PHASE_COMMANDS = Object.freeze({
+  gather: { agent: 'sinapse-pm', command: 'gather-requirements' },
+  assess: { agent: 'sinapse-architect', command: 'assess-complexity' },
+  research: { agent: 'sinapse-analyst', command: 'research-deps' },
+  spec: { agent: 'sinapse-pm', command: 'write-spec' },
+  clarify: { agent: 'sinapse-pm', command: 'clarify-spec' },
+  critique: { agent: 'sinapse-qa', command: 'critique-spec' },
+  critique_1: { agent: 'sinapse-qa', command: 'critique-spec' },
+  revise: { agent: 'sinapse-pm', command: 'write-spec' },
+  critique_2: { agent: 'sinapse-qa', command: 'critique-spec' },
+  plan: { agent: 'sinapse-architect', command: 'create-plan' },
+  analyze: { agent: 'sinapse-qa', command: 'analyze-spec' },
+});
+
+function projectFile(projectRoot, relativePath) {
+  const root = path.resolve(projectRoot);
+  const absolute = path.resolve(root, relativePath);
+  if (absolute !== root && !absolute.startsWith(`${root}${path.sep}`)) {
+    throw new Error(`Path escapes project root: ${relativePath}`);
+  }
+  if (!fs.existsSync(absolute) || !fs.statSync(absolute).isFile()) {
+    throw new Error(`Missing workflow dependency: ${relativePath}`);
+  }
+  return absolute;
+}
+
+function loadYamlFile(projectRoot, relativePath) {
+  const raw = fs.readFileSync(projectFile(projectRoot, relativePath), 'utf8');
+  return yaml.load(raw);
+}
+
+function extractAutoClaudeContract(taskPath) {
+  const raw = fs.readFileSync(taskPath, 'utf8');
+  const fencedYaml = /```ya?ml\s*([\s\S]*?)```/gi;
+  let match;
+
+  while ((match = fencedYaml.exec(raw)) !== null) {
+    try {
+      const document = yaml.load(match[1]);
+      if (document && document.autoClaude) {
+        return document.autoClaude;
+      }
+    } catch {
+      // Keep looking: task files may contain unrelated illustrative YAML blocks.
+    }
+  }
+
+  return null;
+}
+
+function normalizeWorkflowName(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  const workflowName = WORKFLOW_ALIASES[normalized];
+  if (!workflowName) {
+    throw new Error(`Unknown Codex workflow "${value}"`);
+  }
+  return workflowName;
+}
+
+function normalizeComplexity(value) {
+  const normalized = String(value || 'STANDARD').trim().toUpperCase();
+  if (!['SIMPLE', 'STANDARD', 'COMPLEX'].includes(normalized)) {
+    throw new Error(`Unknown complexity "${value}"`);
+  }
+  return normalized;
+}
+
+function loadSpecWorkflow(projectRoot = PROJECT_ROOT) {
+  const document = loadYamlFile(projectRoot, SPEC_WORKFLOW_PATH);
+  if (!document || !document.workflow) {
+    throw new Error(`Invalid workflow document: ${SPEC_WORKFLOW_PATH}`);
+  }
+  return document.workflow;
+}
+
+function resolvePhaseDefinition(workflow, phaseId) {
+  const sourceStep = PHASE_ALIASES[phaseId] || phaseId;
+  const definition = (workflow.sequence || []).find(
+    (candidate) => candidate.step === sourceStep,
+  );
+  if (!definition) {
+    throw new Error(`Workflow phase has no sequence definition: ${phaseId}`);
+  }
+  return definition;
+}
+
+function buildPhase(workflow, phaseId, projectRoot) {
+  const definition = resolvePhaseDefinition(workflow, phaseId);
+  const taskFile =
+    definition.task ||
+    PHASE_TASK_FALLBACKS[phaseId] ||
+    PHASE_TASK_FALLBACKS[definition.step];
+
+  if (!taskFile) {
+    throw new Error(`Workflow phase has no task contract: ${phaseId}`);
+  }
+
+  const taskTarget = `${TASKS_DIR}/${taskFile}`;
+  const contract = extractAutoClaudeContract(projectFile(projectRoot, taskTarget));
+  if (!contract) {
+    throw new Error(`Task has no autoClaude contract: ${taskTarget}`);
+  }
+
+  const command = PHASE_COMMANDS[phaseId] || PHASE_COMMANDS[definition.step];
+  if (!command) {
+    throw new Error(`Workflow phase has no Codex command mapping: ${phaseId}`);
+  }
+
+  return {
+    id: phaseId,
+    sourceStep: definition.step,
+    phase: definition.phase,
+    name: definition.phase_name,
+    agent: command.agent,
+    command: command.command,
+    task: taskTarget,
+    condition: definition.condition || null,
+    skipIf: definition.skip_if || null,
+    gate: Boolean(definition.gate || contract.verification?.type === 'gate'),
+    readOnly: Boolean(contract.readOnly || definition.read_only),
+    elicit: Boolean(contract.elicit),
+    deterministic: Boolean(contract.deterministic),
+    inputs: contract.inputs || [],
+    outputs: contract.outputs || [],
+    verification: contract.verification || null,
+    taskFirst: {
+      inputs: true,
+      outputs: true,
+      verification: true,
+    },
+  };
+}
+
+function loadDeliveryPreparation(projectRoot = PROJECT_ROOT) {
+  const matrixPath = projectFile(projectRoot, DELEGATION_MATRIX_PATH);
+  const matrix = JSON.parse(fs.readFileSync(matrixPath, 'utf8'));
+  const route = matrix.routes?.['framework-story-delivery'];
+  if (!route) {
+    throw new Error('Missing framework-story-delivery delegation route');
+  }
+
+  return {
+    routeId: 'framework-story-delivery',
+    source: DELEGATION_MATRIX_PATH,
+    preparationOnly: true,
+    chain: route.delegationChain.map((step) => ({
+      from: step.from,
+      to: step.to,
+      agent: step.to,
+      command: step.command,
+      target: step.path,
+    })),
+  };
+}
+
+function resolveCodexWorkflow(name, options = {}) {
+  const projectRoot = options.projectRoot || PROJECT_ROOT;
+  const workflowName = normalizeWorkflowName(name);
+  const complexity = normalizeComplexity(options.complexity);
+  const workflow = loadSpecWorkflow(projectRoot);
+  const profile = workflow.phases?.[complexity];
+  if (!profile || !Array.isArray(profile.steps)) {
+    throw new Error(`Workflow has no ${complexity} phase profile`);
+  }
+
+  let phaseIds = [...profile.steps];
+  if (workflowName === 'spec') {
+    const firstPlanPhase = phaseIds.findIndex((phase) =>
+      ['plan', 'analyze'].includes(phase),
+    );
+    if (firstPlanPhase >= 0) {
+      phaseIds = phaseIds.slice(0, firstPlanPhase);
+    }
+  }
+
+  const result = {
+    workflowId: workflow.id,
+    request: workflowName,
+    subject: options.subject ? String(options.subject) : null,
+    complexity,
+    source: SPEC_WORKFLOW_PATH,
+    sourceVersion: workflow.version,
+    preparationOnly: true,
+    taskFirst: true,
+    phases: phaseIds.map((phaseId) =>
+      buildPhase(workflow, phaseId, projectRoot),
+    ),
+  };
+
+  if (workflowName === 'orchestrate') {
+    result.delivery = loadDeliveryPreparation(projectRoot);
+  }
+
+  return result;
+}
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const positional = [];
+  let complexity = 'STANDARD';
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === '--complexity') {
+      complexity = argv[index + 1];
+      index += 1;
+    } else if (argument.startsWith('--complexity=')) {
+      complexity = argument.slice('--complexity='.length);
+    } else if (!argument.startsWith('--')) {
+      positional.push(argument);
+    }
+  }
+
+  return { name: positional[0], complexity };
+}
+
+function main() {
+  const args = parseArgs();
+  if (!args.name) {
+    console.error(
+      'Usage: node .codex/scripts/resolve-codex-workflow.js <spec|plan|orchestrate> [--complexity STANDARD]',
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  try {
+    console.log(
+      JSON.stringify(
+        resolveCodexWorkflow(args.name, { complexity: args.complexity }),
+        null,
+        2,
+      ),
+    );
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  PROJECT_ROOT,
+  SPEC_WORKFLOW_PATH,
+  DELEGATION_MATRIX_PATH,
+  extractAutoClaudeContract,
+  normalizeWorkflowName,
+  normalizeComplexity,
+  loadSpecWorkflow,
+  loadDeliveryPreparation,
+  resolveCodexWorkflow,
+  parseArgs,
+};

package/.codex/scripts/sinapse-codex.js

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const {
+  buildEcosystemStats,
+} = require('./resolve-codex-agent');
+const {
+  loadCommandRegistry,
+  resolveCodexAgentEntry,
+  resolveCodexCommand,
+} = require('./resolve-codex-command');
+const {
+  resolveCodexWorkflow,
+} = require('./resolve-codex-workflow');
+
+const DISTRIBUTION_ROOT = path.resolve(__dirname, '..', '..');
+
+function isSinapseProject(candidate) {
+  return relativeFileExists(candidate, '.codex/catalog.json') &&
+    relativeFileExists(candidate, '.sinapse-ai/constitution.md');
+}
+
+function detectProjectRoot(cwd = process.cwd()) {
+  let current = path.resolve(cwd);
+  while (true) {
+    if (isSinapseProject(current)) return current;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return DISTRIBUTION_ROOT;
+}
+
+const PROJECT_ROOT = detectProjectRoot();
+const LOOP_MAX_ITERATIONS = 3;
+const LOOP_STATE_PATH = '.sinapse/workflow-state/codex-loop.json';
+const WORKFLOW_SKILLS = Object.freeze([
+  'sinapse-orqx',
+  'sinapse-spec-driven',
+  'sinapse-loop',
+]);
+
+function relativeFileExists(projectRoot, relativePath) {
+  try {
+    return fs.statSync(path.join(projectRoot, relativePath)).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function loadJson(projectRoot, relativePath) {
+  return JSON.parse(fs.readFileSync(path.join(projectRoot, relativePath), 'utf8'));
+}
+
+function countRegistryCommands(registry) {
+  return Object.values(registry.agents || {}).reduce(
+    (total, agent) => total + Object.keys(agent.commands || {}).length,
+    0,
+  );
+}
+
+function countAgentSurfaces(projectRoot) {
+  const agentsDir = path.join(projectRoot, '.codex', 'agents');
+  const entries = fs.readdirSync(agentsDir);
+  return {
+    markdown: entries.filter((entry) => entry.endsWith('.md')).length,
+    toml: entries.filter((entry) => entry.endsWith('.toml')).length,
+  };
+}
+
+function buildDoctorReport(projectRoot = PROJECT_ROOT) {
+  const registry = loadCommandRegistry(projectRoot);
+  const delegationMatrix = loadJson(projectRoot, '.codex/delegation-matrix.json');
+  const delegationParity = loadJson(projectRoot, '.codex/delegation-parity.json');
+  const agentSurfaces = countAgentSurfaces(projectRoot);
+  const skills = WORKFLOW_SKILLS.map((skillId) => ({
+    skillId,
+    native: relativeFileExists(
+      projectRoot,
+      `.agents/skills/${skillId}/SKILL.md`,
+    ),
+  }));
+  const delegationEquivalent =
+    JSON.stringify(delegationMatrix) === JSON.stringify(delegationParity);
+
+  const checks = {
+    commandRegistry: true,
+    codexConfig: relativeFileExists(projectRoot, '.codex/config.toml'),
+    codexHooks: relativeFileExists(projectRoot, '.codex/hooks.json'),
+    delegationEquivalent,
+    nativeAgentParity: agentSurfaces.markdown === agentSurfaces.toml,
+    nativeWorkflowSkills: skills.every((skill) => skill.native),
+    workflowResolver: relativeFileExists(
+      projectRoot,
+      '.codex/scripts/resolve-codex-workflow.js',
+    ),
+  };
+
+  return {
+    ok: Object.values(checks).every(Boolean),
+    runtime: 'native-session-preparation',
+    preparationOnly: true,
+    checks,
+    metrics: {
+      ecosystem: buildEcosystemStats(projectRoot),
+      agentSurfaces,
+      registryAgents: Object.keys(registry.agents || {}).length,
+      registryCommands: countRegistryCommands(registry),
+      workflowSkills: skills.length,
+    },
+    skills,
+  };
+}
+
+function inactiveLoopStatus() {
+  return {
+    optIn: true,
+    active: false,
+    currentIteration: 0,
+    maxIterations: LOOP_MAX_ITERATIONS,
+    completionCriterionRequired: true,
+    statePath: LOOP_STATE_PATH,
+  };
+}
+
+function loopStateFile(projectRoot = PROJECT_ROOT) {
+  return path.join(projectRoot, LOOP_STATE_PATH);
+}
+
+function buildLoopStatus(projectRoot = null) {
+  if (!projectRoot || !fs.existsSync(loopStateFile(projectRoot))) return inactiveLoopStatus();
+  const state = JSON.parse(fs.readFileSync(loopStateFile(projectRoot), 'utf8'));
+  return { ...inactiveLoopStatus(), ...state };
+}
+
+function persistLoopState(projectRoot, state) {
+  const stateFile = loopStateFile(projectRoot);
+  fs.mkdirSync(path.dirname(stateFile), { recursive: true });
+  fs.writeFileSync(stateFile, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+  return state;
+}
+
+function prepareLoop(completionCriterion, options = {}) {
+  const criterion = String(completionCriterion || '').trim();
+  if (!criterion) {
+    throw new Error('Loop preparation requires a completion criterion');
+  }
+
+  const state = {
+    ...inactiveLoopStatus(),
+    active: true,
+    completionCriterion: criterion,
+    startedAt: new Date().toISOString(),
+    phases: ['inspect', 'delegate', 'verify'],
+    stopConditions: [
+      'completion-criterion-met',
+      'max-iterations-reached',
+      'blocked',
+      'user-stop',
+    ],
+  };
+  return options.persist
+    ? persistLoopState(options.projectRoot || PROJECT_ROOT, state)
+    : state;
+}
+
+function advanceLoop(projectRoot = PROJECT_ROOT, outcome = 'continue') {
+  const normalizedOutcome = String(outcome || '').trim().toLowerCase();
+  if (!['continue', 'complete', 'blocked', 'user-stop'].includes(normalizedOutcome)) {
+    throw new Error(`Unknown loop outcome "${outcome}"`);
+  }
+  const current = buildLoopStatus(projectRoot);
+  if (!current.active || !current.completionCriterion) {
+    throw new Error('No active SINAPSE loop; run loop prepare first');
+  }
+
+  const currentIteration = Number(current.currentIteration || 0) + 1;
+  const reachedLimit = currentIteration >= LOOP_MAX_ITERATIONS;
+  const stopReason = normalizedOutcome === 'complete'
+    ? 'completion-criterion-met'
+    : normalizedOutcome === 'blocked'
+      ? 'blocked'
+      : normalizedOutcome === 'user-stop'
+        ? 'user-stop'
+        : reachedLimit
+          ? 'max-iterations-reached'
+          : null;
+  const next = {
+    ...current,
+    active: !stopReason,
+    currentIteration,
+    lastOutcome: normalizedOutcome,
+    stopReason,
+    updatedAt: new Date().toISOString(),
+  };
+  return persistLoopState(projectRoot, next);
+}
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const positional = [];
+  const options = {};
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === '--complexity') {
+      options.complexity = argv[index + 1];
+      index += 1;
+    } else if (argument.startsWith('--complexity=')) {
+      options.complexity = argument.slice('--complexity='.length);
+    } else if (argument === '--criterion') {
+      options.criterion = argv[index + 1];
+      index += 1;
+    } else if (argument.startsWith('--criterion=')) {
+      options.criterion = argument.slice('--criterion='.length);
+    } else if (argument === '--outcome') {
+      options.outcome = argv[index + 1];
+      index += 1;
+    } else if (argument.startsWith('--outcome=')) {
+      options.outcome = argument.slice('--outcome='.length);
+    } else if (!argument.startsWith('--')) {
+      positional.push(argument);
+    }
+  }
+
+  return { positional, options };
+}
+
+function resolveRequest(argv = process.argv.slice(2), projectRoot = PROJECT_ROOT) {
+  const { positional, options } = parseArgs(argv);
+  const [operation, first, second] = positional;
+
+  switch (operation) {
+    case 'doctor':
+      return buildDoctorReport(projectRoot);
+    case 'agent':
+      if (!first) throw new Error('Agent id is required');
+      return resolveCodexAgentEntry(first, projectRoot);
+    case 'command':
+      if (!first || !second) {
+        throw new Error('Agent id and command are required');
+      }
+      return resolveCodexCommand(first, second, projectRoot);
+    case 'workflow':
+      if (!first) throw new Error('Workflow name is required');
+      return resolveCodexWorkflow(first, {
+        complexity: options.complexity,
+        projectRoot,
+        subject: second,
+      });
+    case 'spec':
+    case 'plan':
+    case 'orchestrate':
+      return resolveCodexWorkflow(operation, {
+        complexity: options.complexity,
+        projectRoot,
+        subject: first,
+      });
+    case 'loop':
+      if (!first || first === 'status') return buildLoopStatus(projectRoot);
+      if (first === 'prepare') {
+        return prepareLoop(options.criterion, { persist: true, projectRoot });
+      }
+      if (first === 'advance') return advanceLoop(projectRoot, options.outcome);
+      throw new Error(`Unknown loop operation "${first}"`);
+    default:
+      throw new Error(
+        'Usage: sinapse-codex <doctor|agent|command|workflow|spec|plan|orchestrate|loop> [...args]',
+      );
+  }
+}
+
+function main() {
+  try {
+    console.log(JSON.stringify(resolveRequest(), null, 2));
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  PROJECT_ROOT,
+  DISTRIBUTION_ROOT,
+  LOOP_MAX_ITERATIONS,
+  LOOP_STATE_PATH,
+  WORKFLOW_SKILLS,
+  isSinapseProject,
+  detectProjectRoot,
+  countRegistryCommands,
+  countAgentSurfaces,
+  buildDoctorReport,
+  buildLoopStatus,
+  prepareLoop,
+  advanceLoop,
+  parseArgs,
+  resolveRequest,
+};