@the-open-engine/zeroshot 6.38.1 → 6.39.0

package/src/template-validation/simulate-two-stage-validation.js

@@ -1,270 +1,46 @@
-const assert = require('node:assert');
-
-const Ledger = require('../ledger');
-const MessageBus = require('../message-bus');
-const LogicEngine = require('../logic-engine');
-const { executeHook } = require('../agent/agent-hook-executor');
-const { parseResultOutput } = require('../agent/agent-task-executor');
-
-function createSimAgent({ agentConfig, cluster, messageBus }) {
-  const simAgent = {
-    id: agentConfig.id,
-    role: agentConfig.role,
-    iteration: 1,
-    cluster,
-    messageBus,
-    config: agentConfig,
-    currentTaskId: 'sim-task',
-    workingDirectory: process.cwd(),
-    _log: () => {},
-    _resolveProvider: () => 'claude',
-    _parseResultOutput: (output) => parseResultOutput(simAgent, output),
-    _publish: (message) => {
-      const receiver = message.receiver || 'broadcast';
-      return messageBus.publish({
-        ...message,
-        receiver,
-        cluster_id: cluster.id,
-        sender: simAgent.id,
-      });
-    },
-  };
-  return simAgent;
-}
-
-async function simulateQuickValidation({ config }) {
-  const cluster = {
-    id: 'quick-sim',
-    agents: config.agents.map((a) => ({ id: a.id, role: a.role })),
-  };
-
-  const coordinator = config.agents.find((a) => a.id === 'consensus-coordinator');
-  assert.ok(coordinator, 'quick-validation: consensus-coordinator missing');
-
-  const trigger = coordinator.triggers.find((t) => t.topic === 'QUICK_VALIDATION_RESULT');
-  assert.ok(trigger?.logic?.script, 'quick-validation: coordinator trigger logic missing');
-  assert.ok(coordinator.hooks?.onComplete, 'quick-validation: coordinator onComplete missing');
-
-  const failures = [];
-
-  const runScenario = async (allApproved) => {
-    const ledger = new Ledger(':memory:');
-    const messageBus = new MessageBus(ledger);
-    const logicEngine = new LogicEngine(messageBus, cluster);
-
-    // Stage start
-    const now = Date.now();
-    messageBus.publish({
-      cluster_id: cluster.id,
-      topic: 'IMPLEMENTATION_READY',
-      sender: 'worker',
-      timestamp: now,
-    });
-
-    // Validator outputs (stage 1)
-    messageBus.publish({
-      cluster_id: cluster.id,
-      topic: 'QUICK_VALIDATION_RESULT',
-      sender: 'validator-requirements',
-      timestamp: now + 10,
-      content: { data: { approved: true, errors: ['req-error'] } },
-    });
-    messageBus.publish({
-      cluster_id: cluster.id,
-      topic: 'QUICK_VALIDATION_RESULT',
-      sender: 'validator-code',
-      timestamp: now + 20,
-      content: { data: { approved: true, errors: ['code-error'] } },
-    });
-
-    const gateOk = logicEngine.evaluate(
-      trigger.logic.script,
-      { id: 'consensus-coordinator', cluster_id: cluster.id },
-      { topic: 'QUICK_VALIDATION_RESULT' }
-    );
-    if (!gateOk) {
-      ledger.close();
-      return { ok: false, error: 'quick-validation: gate did not open after both validators' };
-    }
-
-    const simAgent = createSimAgent({ agentConfig: coordinator, cluster, messageBus });
-    const triggeringMessage = messageBus.findLast({
-      cluster_id: cluster.id,
-      topic: 'QUICK_VALIDATION_RESULT',
-    });
-
-    try {
-      await executeHook({
-        hook: coordinator.hooks.onComplete,
-        agent: simAgent,
-        message: triggeringMessage,
-        result: {
-          output: JSON.stringify({ allApproved, summary: allApproved ? 'ok' : 'nope' }),
-          success: true,
-          taskId: 'sim-task',
-        },
-        messageBus,
-        cluster,
-      });
-    } catch (err) {
-      ledger.close();
-      return { ok: false, error: `quick-validation: onComplete failed: ${err.message}` };
-    }
-
-    const passed = messageBus.findLast({
-      cluster_id: cluster.id,
-      topic: 'QUICK_VALIDATION_PASSED',
-    });
-    const validationResult = messageBus.findLast({
-      cluster_id: cluster.id,
-      topic: 'VALIDATION_RESULT',
-    });
-
-    ledger.close();
-
-    if (allApproved) {
-      if (!passed)
-        return { ok: false, error: 'quick-validation: expected QUICK_VALIDATION_PASSED' };
-      return { ok: true };
-    }
-
-    if (!validationResult) {
-      return { ok: false, error: 'quick-validation: expected VALIDATION_RESULT on rejection' };
-    }
-
-    const errors = validationResult.content?.data?.errors || [];
-    if (!errors.includes('req-error') || !errors.includes('code-error')) {
-      return { ok: false, error: 'quick-validation: rejection did not aggregate validator errors' };
-    }
-
-    return { ok: true };
-  };
-
-  for (const allApproved of [true, false]) {
-    const res = await runScenario(allApproved);
-    if (!res.ok) failures.push(res.error);
-  }
-
-  return failures;
-}
-
-async function simulateHeavyValidation({ config }) {
-  const cluster = {
-    id: 'heavy-sim',
-    agents: config.agents.map((a) => ({ id: a.id, role: a.role })),
-  };
-
-  const coordinator = config.agents.find((a) => a.id === 'consensus-coordinator');
-  assert.ok(coordinator, 'heavy-validation: consensus-coordinator missing');
-
-  const trigger = coordinator.triggers.find((t) => t.topic === 'HEAVY_VALIDATION_RESULT');
-  assert.ok(trigger?.logic?.script, 'heavy-validation: coordinator trigger logic missing');
-  assert.ok(coordinator.hooks?.onComplete, 'heavy-validation: coordinator onComplete missing');
-
-  const failures = [];
-
-  const runScenario = async (allApproved) => {
-    const ledger = new Ledger(':memory:');
-    const messageBus = new MessageBus(ledger);
-    const logicEngine = new LogicEngine(messageBus, cluster);
-
-    const now = Date.now();
-    messageBus.publish({
-      cluster_id: cluster.id,
-      topic: 'QUICK_VALIDATION_PASSED',
-      sender: 'consensus-coordinator',
-      timestamp: now,
-    });
-
-    messageBus.publish({
-      cluster_id: cluster.id,
-      topic: 'HEAVY_VALIDATION_RESULT',
-      sender: 'validator-security',
-      timestamp: now + 10,
-      content: { data: { approved: true, errors: ['sec-error'] } },
-    });
-    messageBus.publish({
-      cluster_id: cluster.id,
-      topic: 'HEAVY_VALIDATION_RESULT',
-      sender: 'validator-tester',
-      timestamp: now + 20,
-      content: { data: { approved: true, errors: ['test-error'] } },
-    });
-
-    const gateOk = logicEngine.evaluate(
-      trigger.logic.script,
-      { id: 'consensus-coordinator', cluster_id: cluster.id },
-      { topic: 'HEAVY_VALIDATION_RESULT' }
-    );
-    if (!gateOk) {
-      ledger.close();
-      return { ok: false, error: 'heavy-validation: gate did not open after both validators' };
-    }
-
-    const simAgent = createSimAgent({ agentConfig: coordinator, cluster, messageBus });
-    const triggeringMessage = messageBus.findLast({
-      cluster_id: cluster.id,
-      topic: 'HEAVY_VALIDATION_RESULT',
-    });
-
-    try {
-      await executeHook({
-        hook: coordinator.hooks.onComplete,
-        agent: simAgent,
-        message: triggeringMessage,
-        result: {
-          output: JSON.stringify({ allApproved, summary: allApproved ? 'ok' : 'nope' }),
-          success: true,
-          taskId: 'sim-task',
-        },
-        messageBus,
-        cluster,
-      });
-    } catch (err) {
-      ledger.close();
-      return { ok: false, error: `heavy-validation: onComplete failed: ${err.message}` };
-    }
-
-    const validationResult = messageBus.findLast({
-      cluster_id: cluster.id,
-      topic: 'VALIDATION_RESULT',
-    });
-    ledger.close();
-
-    if (!validationResult) {
-      return { ok: false, error: 'heavy-validation: expected VALIDATION_RESULT' };
+"use strict";
+const two_stage_scenario_1 = require("./two-stage-scenario");
+const QUICK_VALIDATION_SPEC = {
+    templateId: 'quick-validation',
+    clusterId: 'quick-sim',
+    triggerTopic: 'QUICK_VALIDATION_RESULT',
+    stageStartTopic: 'IMPLEMENTATION_READY',
+    stageStartSender: 'worker',
+    validators: [
+        { sender: 'validator-requirements', error: 'req-error' },
+        { sender: 'validator-code', error: 'code-error' },
+    ],
+    passTopic: 'QUICK_VALIDATION_PASSED',
+    gateFailure: 'quick-validation: gate did not open after both validators',
+    missingPassFailure: 'quick-validation: expected QUICK_VALIDATION_PASSED',
+    missingResultFailure: 'quick-validation: expected VALIDATION_RESULT on rejection',
+    aggregateFailure: 'quick-validation: rejection did not aggregate validator errors',
+};
+const HEAVY_VALIDATION_SPEC = {
+    templateId: 'heavy-validation',
+    clusterId: 'heavy-sim',
+    triggerTopic: 'HEAVY_VALIDATION_RESULT',
+    stageStartTopic: 'QUICK_VALIDATION_PASSED',
+    stageStartSender: 'consensus-coordinator',
+    validators: [
+        { sender: 'validator-security', error: 'sec-error' },
+        { sender: 'validator-tester', error: 'test-error' },
+    ],
+    gateFailure: 'heavy-validation: gate did not open after both validators',
+    missingPassFailure: 'heavy-validation: expected QUICK_VALIDATION_PASSED',
+    missingResultFailure: 'heavy-validation: expected VALIDATION_RESULT',
+    aggregateFailure: 'heavy-validation: did not aggregate validator errors',
+};
+/** Run deterministic two-stage validation scenarios for base templates. */
+function simulateTwoStageValidation({ templateId, config }) {
+    if (templateId === 'quick-validation') {
+        return (0, two_stage_scenario_1.simulateValidationStage)(QUICK_VALIDATION_SPEC, config);
     }
-
-    const errors = validationResult.content?.data?.errors || [];
-    if (!errors.includes('sec-error') || !errors.includes('test-error')) {
-      return { ok: false, error: 'heavy-validation: did not aggregate validator errors' };
+    if (templateId === 'heavy-validation') {
+        return (0, two_stage_scenario_1.simulateValidationStage)(HEAVY_VALIDATION_SPEC, config);
     }
-
-    return { ok: true };
-  };
-
-  for (const allApproved of [true, false]) {
-    const res = await runScenario(allApproved);
-    if (!res.ok) failures.push(res.error);
-  }
-
-  return failures;
-}
-
-/**
- * Deep sim: run deterministic two-stage validation scenarios for base templates.
- * Returns an array of error strings.
- */
-function simulateTwoStageValidation({ templateId, config }) {
-  if (templateId === 'quick-validation') {
-    return simulateQuickValidation({ config });
-  }
-  if (templateId === 'heavy-validation') {
-    return simulateHeavyValidation({ config });
-  }
-  return Promise.resolve([]);
+    return Promise.resolve([]);
 }
-
 module.exports = {
-  simulateTwoStageValidation,
+    simulateTwoStageValidation,
 };

package/src/template-validation/simulate-two-stage-validation.ts

@@ -0,0 +1,55 @@
+import { simulateValidationStage } from './two-stage-scenario';
+import type { ValidationStageSpec, ValidationTemplateConfig } from './two-stage-contracts';
+
+const QUICK_VALIDATION_SPEC: ValidationStageSpec = {
+  templateId: 'quick-validation',
+  clusterId: 'quick-sim',
+  triggerTopic: 'QUICK_VALIDATION_RESULT',
+  stageStartTopic: 'IMPLEMENTATION_READY',
+  stageStartSender: 'worker',
+  validators: [
+    { sender: 'validator-requirements', error: 'req-error' },
+    { sender: 'validator-code', error: 'code-error' },
+  ],
+  passTopic: 'QUICK_VALIDATION_PASSED',
+  gateFailure: 'quick-validation: gate did not open after both validators',
+  missingPassFailure: 'quick-validation: expected QUICK_VALIDATION_PASSED',
+  missingResultFailure: 'quick-validation: expected VALIDATION_RESULT on rejection',
+  aggregateFailure: 'quick-validation: rejection did not aggregate validator errors',
+};
+
+const HEAVY_VALIDATION_SPEC: ValidationStageSpec = {
+  templateId: 'heavy-validation',
+  clusterId: 'heavy-sim',
+  triggerTopic: 'HEAVY_VALIDATION_RESULT',
+  stageStartTopic: 'QUICK_VALIDATION_PASSED',
+  stageStartSender: 'consensus-coordinator',
+  validators: [
+    { sender: 'validator-security', error: 'sec-error' },
+    { sender: 'validator-tester', error: 'test-error' },
+  ],
+  gateFailure: 'heavy-validation: gate did not open after both validators',
+  missingPassFailure: 'heavy-validation: expected QUICK_VALIDATION_PASSED',
+  missingResultFailure: 'heavy-validation: expected VALIDATION_RESULT',
+  aggregateFailure: 'heavy-validation: did not aggregate validator errors',
+};
+
+interface SimulationInput {
+  templateId: string;
+  config: ValidationTemplateConfig;
+}
+
+/** Run deterministic two-stage validation scenarios for base templates. */
+function simulateTwoStageValidation({ templateId, config }: SimulationInput): Promise<string[]> {
+  if (templateId === 'quick-validation') {
+    return simulateValidationStage(QUICK_VALIDATION_SPEC, config);
+  }
+  if (templateId === 'heavy-validation') {
+    return simulateValidationStage(HEAVY_VALIDATION_SPEC, config);
+  }
+  return Promise.resolve([]);
+}
+
+export = {
+  simulateTwoStageValidation,
+};

package/src/template-validation/simulation-agent-runtime.js

@@ -0,0 +1,25 @@
+"use strict";
+function isAgentHookExecutorModule(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'executeHook' in value &&
+        typeof value.executeHook === 'function');
+}
+function isAgentTaskExecutorModule(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'parseResultOutput' in value &&
+        typeof value.parseResultOutput === 'function');
+}
+const agentHookExecutorModule = require('../agent/agent-hook-executor');
+const agentTaskExecutorModule = require('../agent/agent-task-executor');
+if (!isAgentHookExecutorModule(agentHookExecutorModule)) {
+    throw new TypeError('agent-hook-executor must export executeHook');
+}
+if (!isAgentTaskExecutorModule(agentTaskExecutorModule)) {
+    throw new TypeError('agent-task-executor must export parseResultOutput');
+}
+module.exports = {
+    executeHook: agentHookExecutorModule.executeHook,
+    parseResultOutput: agentTaskExecutorModule.parseResultOutput,
+};

package/src/template-validation/simulation-agent-runtime.ts

@@ -0,0 +1,40 @@
+interface AgentHookExecutorModule {
+  executeHook(options: unknown): Promise<void>;
+}
+
+interface AgentTaskExecutorModule {
+  parseResultOutput(agent: unknown, output: string): Promise<unknown>;
+}
+
+function isAgentHookExecutorModule(value: unknown): value is AgentHookExecutorModule {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'executeHook' in value &&
+    typeof value.executeHook === 'function'
+  );
+}
+
+function isAgentTaskExecutorModule(value: unknown): value is AgentTaskExecutorModule {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'parseResultOutput' in value &&
+    typeof value.parseResultOutput === 'function'
+  );
+}
+
+const agentHookExecutorModule: unknown = require('../agent/agent-hook-executor');
+const agentTaskExecutorModule: unknown = require('../agent/agent-task-executor');
+
+if (!isAgentHookExecutorModule(agentHookExecutorModule)) {
+  throw new TypeError('agent-hook-executor must export executeHook');
+}
+if (!isAgentTaskExecutorModule(agentTaskExecutorModule)) {
+  throw new TypeError('agent-task-executor must export parseResultOutput');
+}
+
+export = {
+  executeHook: agentHookExecutorModule.executeHook,
+  parseResultOutput: agentTaskExecutorModule.parseResultOutput,
+};

package/src/template-validation/simulation-agent.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSimulationAgent = createSimulationAgent;
+const simulationAgentRuntime = require("./simulation-agent-runtime");
+function createSimulationAgent({ agentConfig, cluster, messageBus, iteration = 1, currentTaskId = 'sim-task', }) {
+    const simulationAgent = {
+        id: agentConfig.id,
+        role: agentConfig.role,
+        iteration,
+        cluster,
+        messageBus,
+        config: agentConfig,
+        currentTaskId,
+        workingDirectory: process.cwd(),
+        _log: () => { },
+        _resolveProvider: () => 'claude',
+        _parseResultOutput: (output) => simulationAgentRuntime.parseResultOutput(simulationAgent, output),
+        _publish: (message) => {
+            const receiver = message.receiver || 'broadcast';
+            return messageBus.publish({
+                ...message,
+                receiver,
+                cluster_id: cluster.id,
+                sender: simulationAgent.id,
+            });
+        },
+    };
+    return simulationAgent;
+}

package/src/template-validation/simulation-agent.ts

@@ -0,0 +1,73 @@
+import simulationAgentRuntime = require('./simulation-agent-runtime');
+
+interface SimulationMessageBus {
+  publish(message: unknown): unknown;
+}
+
+type PublishMessage = Record<string, unknown> & { receiver?: unknown };
+
+export interface SimulationAgentConfig {
+  id: string;
+  role?: string;
+}
+
+export interface SimulationCluster {
+  id: string;
+  agents: Array<{ id: string; role: string | undefined }>;
+}
+
+interface SimulationAgent {
+  id: string;
+  role: string | undefined;
+  iteration: number;
+  cluster: SimulationCluster;
+  messageBus: SimulationMessageBus;
+  config: SimulationAgentConfig;
+  currentTaskId: string;
+  workingDirectory: string;
+  _log(...arguments_: unknown[]): void;
+  _resolveProvider(): 'claude';
+  _parseResultOutput(output: string): Promise<unknown>;
+  _publish(message: PublishMessage): unknown;
+}
+
+interface CreateSimulationAgentOptions {
+  agentConfig: SimulationAgentConfig;
+  cluster: SimulationCluster;
+  messageBus: SimulationMessageBus;
+  iteration?: number;
+  currentTaskId?: string;
+}
+
+export function createSimulationAgent({
+  agentConfig,
+  cluster,
+  messageBus,
+  iteration = 1,
+  currentTaskId = 'sim-task',
+}: CreateSimulationAgentOptions): SimulationAgent {
+  const simulationAgent: SimulationAgent = {
+    id: agentConfig.id,
+    role: agentConfig.role,
+    iteration,
+    cluster,
+    messageBus,
+    config: agentConfig,
+    currentTaskId,
+    workingDirectory: process.cwd(),
+    _log: () => {},
+    _resolveProvider: () => 'claude',
+    _parseResultOutput: (output) =>
+      simulationAgentRuntime.parseResultOutput(simulationAgent, output),
+    _publish: (message) => {
+      const receiver = message.receiver || 'broadcast';
+      return messageBus.publish({
+        ...message,
+        receiver,
+        cluster_id: cluster.id,
+        sender: simulationAgent.id,
+      });
+    },
+  };
+  return simulationAgent;
+}

package/src/template-validation/simulation-runtime.js

@@ -0,0 +1,34 @@
+"use strict";
+function isLedgerConstructor(value) {
+    return typeof value === 'function';
+}
+function isMessageBusConstructor(value) {
+    return typeof value === 'function';
+}
+function isLogicEngineConstructor(value) {
+    return typeof value === 'function';
+}
+const ledgerModule = require('../ledger');
+const messageBusModule = require('../message-bus');
+const logicEngineModule = require('../logic-engine');
+if (!isLedgerConstructor(ledgerModule)) {
+    throw new TypeError('ledger must export a constructor');
+}
+if (!isMessageBusConstructor(messageBusModule)) {
+    throw new TypeError('message-bus must export a constructor');
+}
+if (!isLogicEngineConstructor(logicEngineModule)) {
+    throw new TypeError('logic-engine must export a constructor');
+}
+const Ledger = ledgerModule;
+const MessageBus = messageBusModule;
+const LogicEngine = logicEngineModule;
+function createSimulationRuntime(cluster) {
+    const ledger = new Ledger(':memory:');
+    const messageBus = new MessageBus(ledger);
+    const logicEngine = new LogicEngine(messageBus, cluster);
+    return { ledger, messageBus, logicEngine };
+}
+module.exports = {
+    createSimulationRuntime,
+};

package/src/template-validation/simulation-runtime.ts

@@ -0,0 +1,72 @@
+interface SimulationLedger {
+  close(): void;
+}
+
+interface SimulationMessageBus {
+  publish(message: unknown): unknown;
+  subscribe(listener: (message: unknown) => void): () => void;
+  findLast(criteria: unknown): unknown;
+}
+
+interface SimulationLogicEngine {
+  evaluate(script: string, agent: unknown, message: unknown): boolean;
+}
+
+interface LedgerConstructor {
+  new (databasePath: string): SimulationLedger;
+}
+
+interface MessageBusConstructor {
+  new (ledger: SimulationLedger): SimulationMessageBus;
+}
+
+interface LogicEngineConstructor {
+  new (messageBus: SimulationMessageBus, cluster: unknown): SimulationLogicEngine;
+}
+
+interface SimulationRuntime {
+  ledger: SimulationLedger;
+  messageBus: SimulationMessageBus;
+  logicEngine: SimulationLogicEngine;
+}
+
+function isLedgerConstructor(value: unknown): value is LedgerConstructor {
+  return typeof value === 'function';
+}
+
+function isMessageBusConstructor(value: unknown): value is MessageBusConstructor {
+  return typeof value === 'function';
+}
+
+function isLogicEngineConstructor(value: unknown): value is LogicEngineConstructor {
+  return typeof value === 'function';
+}
+
+const ledgerModule: unknown = require('../ledger');
+const messageBusModule: unknown = require('../message-bus');
+const logicEngineModule: unknown = require('../logic-engine');
+
+if (!isLedgerConstructor(ledgerModule)) {
+  throw new TypeError('ledger must export a constructor');
+}
+if (!isMessageBusConstructor(messageBusModule)) {
+  throw new TypeError('message-bus must export a constructor');
+}
+if (!isLogicEngineConstructor(logicEngineModule)) {
+  throw new TypeError('logic-engine must export a constructor');
+}
+
+const Ledger = ledgerModule;
+const MessageBus = messageBusModule;
+const LogicEngine = logicEngineModule;
+
+function createSimulationRuntime(cluster: unknown): SimulationRuntime {
+  const ledger = new Ledger(':memory:');
+  const messageBus = new MessageBus(ledger);
+  const logicEngine = new LogicEngine(messageBus, cluster);
+  return { ledger, messageBus, logicEngine };
+}
+
+export = {
+  createSimulationRuntime,
+};

package/src/template-validation/two-stage-contracts.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });