feat: Enhance gRPC client with trajectory pattern storage functionality

- Added `storeTrajectoryPattern` method to `AegisRuntimeClient` for storing trajectory patterns in Cortex.
- Updated logging to reflect new response structure in validation process.

refactor: Simplify server workflow registration process

- Removed workflow registry registration from server logic.
- Cleaned up workflow deletion process by removing unnecessary unregister calls.

chore: Update types for judges and workflow states

- Introduced `JudgeConfig` interface for per-state validation configuration.
- Enhanced `WorkflowState` interface to include judges and pre-execution validation fields.

fix: Improve validation request and response structures

- Updated `ValidateRequest` and `ValidateResponse` interfaces to align with new validation logic.
- Adjusted transition conditions to include consensus-based evaluations.

refactor: Remove deprecated workflow generator and registry

- Deleted `workflow-generator.ts` and `workflow-registry.ts` as part of the refactor.
- Cleaned up associated tests and imports.

feat: Implement trajectory pattern storage in workflow execution

- Integrated trajectory pattern storage into the `aegis_workflow` function.
- Enhanced state execution logic to handle judges and trajectory accumulation.

test: Remove obsolete workflow registry tests

- Deleted tests related to the removed workflow registry functionality.

Author: Theaxiom

CONTRIBUTING.md

@@ -28,7 +28,7 @@ By participating in this project you agree to abide by our [Code of Conduct](COD
 
 - **Node.js** 20+
 - **npm** 9+
-- **PostgreSQL** 15+ (for workflow registry)
+- **PostgreSQL** 15+
 - **Temporal Server** (run locally via `temporal server start-dev` or the compose stack in [aegis-examples](https://github.com/100monkeys-ai/aegis-examples))
 - **AEGIS Runtime** — the Rust gRPC service (`aegis-orchestrator`)
 

README.md

@@ -36,7 +36,7 @@ TemporalWorkflowDefinition (JSON)
 
 - **Generic Interpreter Workflow** — a single Temporal workflow (`aegis_workflow`) interprets all AEGIS FSM definitions at runtime; no code generation needed
 - **Dynamic workflow registration** — POST a JSON definition to `/register-workflow`; no worker restart required
-- **Multi-worker coordination** — PostgreSQL-backed workflow registry ensures all worker replicas share the same definitions
+- **Multi-worker coordination** — PostgreSQL ensures all worker replicas share the same definitions
 - **Full activity suite** — `executeAgentActivity`, `executeSystemCommandActivity`, `validateOutputActivity`, `executeParallelAgentsActivity`
 - **Event bridge** — publishes `WorkflowStateEntered`, `IterationStarted`, `RefinementApplied`, etc. back to the Rust orchestrator so they become typed domain events
 
@@ -161,7 +161,7 @@ aegis-temporal-worker/
 │   ├── config.ts                  # Zod-validated environment configuration
 │   ├── logger.ts                  # Pino structured logger
 │   ├── types.ts                   # TypeScript type definitions
-│   ├── database.ts                # PostgreSQL client (workflow registry persistence)
+│   ├── database.ts                # PostgreSQL client
 │   ├── server.ts                  # Express HTTP server (workflow registration API)
 │   ├── worker.ts                  # Temporal worker initialization
 │   ├── workflow-registry.ts       # In-memory workflow function registry

src/activities/index.ts

@@ -9,6 +9,8 @@ import type {
   ExecuteAgentRequest,
   ExecuteSystemCommandRequest,
   ValidateRequest,
+  StoreTrajectoryPatternRequest,
+  TrajectoryStep,
   Blackboard,
 } from '../types.js';
 import { fetchWorkflowDefinition } from './workflow-activities.js';
@@ -20,6 +22,7 @@ export async function executeAgentActivity(params: {
   agentId: string;
   input: string;
   context: Blackboard;
+  parentExecutionId?: string;
 }): Promise<any> {
   logger.info({ agent_id: params.agentId }, 'Executing agent activity');
 
@@ -28,6 +31,7 @@ export async function executeAgentActivity(params: {
     input: params.input,
     context_json: JSON.stringify(params.context),
     timeout_seconds: 300,
+    workflow_execution_id: params.parentExecutionId,  // proto field 5 (keepCase:true)
   };
 
   try {
@@ -99,25 +103,32 @@ export async function executeSystemCommandActivity(params: {
  */
 export async function validateOutputActivity(params: {
   output: string;
-  judges: Array<{ agent_id: string; weight?: number }>;
+  task?: string;
+  judges: Array<{ agent_id: string; weight?: number; input_template?: string }>;
   consensus_strategy?: string;
   consensus_threshold?: number;
+  context_json?: string;
 }): Promise<any> {
   logger.info({ judge_count: params.judges.length }, 'Validating output with judges');
 
   const request: ValidateRequest = {
-    agent_output: params.output,
-    judge_agent_ids: params.judges.map(j => j.agent_id),
-    context: {},
+    output: params.output,
+    task: params.task,
+    judges: params.judges.map(j => ({ agent_id: j.agent_id, weight: j.weight, input_template: j.input_template })),
+    consensus: params.consensus_strategy
+      ? { strategy: params.consensus_strategy, threshold: params.consensus_threshold ?? 0.8 }
+      : undefined,
+    context_json: params.context_json,
   };
 
   try {
     const response = await aegisRuntimeClient.validateWithJudges(request);
 
     return {
-      final_score: response.final_score,
+      score: response.score,
       confidence: response.confidence,
-      individual_scores: response.individual_scores,
+      binary_valid: response.binary_valid,
+      individual_results: response.individual_results,
       reasoning: response.reasoning,
     };
   } catch (error) {
@@ -131,6 +142,8 @@ export async function validateOutputActivity(params: {
  */
 export async function executeParallelAgentsActivity(params: {
   agents: Array<{ agent: string; input: string; weight?: number }>;
+  /** External judge agents from the state's `judges_for_parallel` field (ADR-016). */
+  judges?: Array<{ agent_id: string; weight?: number; input_template?: string }>;
   consensus: {
     strategy: string;
     threshold: number;
@@ -154,6 +167,7 @@ export async function executeParallelAgentsActivity(params: {
         if (completedEvent) {
           return {
             output: completedEvent.final_output || '',
+            agent: agentConfig.agent,
             weight: agentConfig.weight || 1.0,
           };
         }
@@ -162,28 +176,85 @@ export async function executeParallelAgentsActivity(params: {
       })
     );
 
-    // All agents completed - now validate with consensus
-    const outputsForValidation = results.map(r => r.output).join('\n\n---\n\n');
+    // All agents completed – validate the combined output with dedicated judge agents.
+    // judges_for_parallel must be a *separate* set of agents from the workers above;
+    // passing workers as their own judges would violate ADR-016 (agents cannot judge themselves).
+    if (!params.judges || params.judges.length === 0) {
+      // No external judges configured — return raw results without consensus scoring.
+      return {
+        consensus: {
+          score: 1.0,
+          confidence: 1.0,
+          strategy: params.consensus.strategy,
+          metadata: {
+            individual_outputs: results.map(r => r.output),
+            individual_results: [],
+            reasoning: 'No judge agents configured for this ParallelAgents state',
+          },
+        },
+      };
+    }
+
+    const outputsForValidation = results.map(r => `[${r.agent}]:\n${r.output}`).join('\n\n---\n\n');
 
     const validationResult = await aegisRuntimeClient.validateWithJudges({
-      agent_output: outputsForValidation,
-      judge_agent_ids: params.agents.map(a => a.agent),
-      context: {},
+      output: outputsForValidation,
+      judges: params.judges,
+      consensus: {
+        strategy: params.consensus.strategy,
+        threshold: params.consensus.threshold,
+      },
     });
 
     return {
-      individual_outputs: results.map(r => r.output),
-      individual_scores: validationResult.individual_scores,
-      final_score: validationResult.final_score,
-      confidence: validationResult.confidence,
-      reasoning: validationResult.reasoning,
+      consensus: {
+        score: validationResult.score,
+        confidence: validationResult.confidence,
+        binary_valid: validationResult.binary_valid,
+        strategy: params.consensus.strategy,
+        metadata: {
+          individual_outputs: results.map(r => r.output),
+          individual_results: validationResult.individual_results,
+          reasoning: validationResult.reasoning,
+        },
+      },
     };
   } catch (error) {
     logger.error({ error }, 'Parallel agents activity failed');
     throw error;
   }
 }
 
+/**
+ * Store a successful trajectory in Cortex memory (ADR-049 Pillar 2)
+ */
+export async function storeTrajectoryPatternActivity(params: {
+  taskSignature: string;
+  steps: TrajectoryStep[];
+  successScore: number;
+}): Promise<any> {
+  logger.info({ task_signature: params.taskSignature, step_count: params.steps.length }, 'Storing trajectory pattern');
+
+  const request: StoreTrajectoryPatternRequest = {
+    task_signature: params.taskSignature,
+    steps: params.steps,
+    success_score: params.successScore,
+  };
+
+  try {
+    const response = await aegisRuntimeClient.storeTrajectoryPattern(request);
+    return {
+      trajectory_id: response.trajectory_id,
+      new_weight: response.new_weight,
+      deduplicated: response.deduplicated,
+    };
+  } catch (error) {
+    // Cortex storage failure must never crash the workflow — log and swallow.
+    logger.warn({ error, task_signature: params.taskSignature }, 'Trajectory pattern storage failed (non-fatal)');
+    return null;
+  }
+}
+
 import { publishEventActivity } from './event-activities.js';
 
 // Ensure all activities are exported for Temporal Worker
@@ -192,6 +263,7 @@ export const activities = {
   executeSystemCommandActivity,
   validateOutputActivity,
   executeParallelAgentsActivity,
+  storeTrajectoryPatternActivity,
   fetchWorkflowDefinition,
   publishEventActivity,
 };

src/grpc/client.ts

@@ -17,7 +17,9 @@ import type {
   QueryCortexRequest,
   QueryCortexResponse,
   StoreCortexPatternRequest,
-  StoreCortexPatternResponse
+  StoreCortexPatternResponse,
+  StoreTrajectoryPatternRequest,
+  StoreTrajectoryPatternResponse,
 } from '../types.js';
 
 // Load protobuf definition
@@ -101,7 +103,7 @@ class AegisRuntimeClient {
           logger.error({ error }, 'Validation with judges failed');
           reject(error);
         } else {
-          logger.info({ final_score: response.final_score, confidence: response.confidence }, 'Validation completed');
+          logger.info({ score: response.score, confidence: response.confidence, binary_valid: response.binary_valid }, 'Validation completed');
           resolve(response);
         }
       });
@@ -142,6 +144,23 @@ class AegisRuntimeClient {
     });
   }
 
+  /**
+   * Store a trajectory pattern in Cortex (ADR-049 Pillar 2)
+   */
+  async storeTrajectoryPattern(request: StoreTrajectoryPatternRequest): Promise<StoreTrajectoryPatternResponse> {
+    return new Promise((resolve, reject) => {
+      this.client.StoreTrajectoryPattern(request, (error: Error | null, response: StoreTrajectoryPatternResponse) => {
+        if (error) {
+          logger.error({ error }, 'Trajectory pattern storage failed');
+          reject(error);
+        } else {
+          logger.info({ new_weight: response.new_weight }, 'Trajectory pattern stored');
+          resolve(response);
+        }
+      });
+    });
+  }
+
   /**
    * Close the gRPC connection
    */

src/server.ts

@@ -7,7 +7,6 @@ import express, { type Request, type Response } from 'express';
 import { config } from './config.js';
 import { logger } from './logger.js';
 import { database } from './database.js';
-import { workflowRegistry } from './workflow-registry.js';
 import type { TemporalWorkflowDefinition } from './types.js';
 
 const app = express();
@@ -51,9 +50,6 @@ app.post('/register-workflow', async (req: Request, res: Response) => {
     // Save to database (for multi-worker coordination)
     await database.saveWorkflowDefinition(definition);
 
-    // Register with workflow registry (generates TypeScript workflow function)
-    await workflowRegistry.registerWorkflow(definition);
-
     logger.info({ workflow_id: definition.workflow_id, name: definition.name }, 'Workflow registered successfully');
 
     res.status(200).json({
@@ -136,7 +132,6 @@ app.delete('/workflows/:id', async (req: Request, res: Response) => {
     }
 
     await database.deleteWorkflowDefinition(id);
-    workflowRegistry.unregisterWorkflow(id);
 
     logger.info({ workflow_id: id }, 'Workflow deleted');