Fix Dialyzer type errors and remove incorrect Genesis references

- Add @type definitions to all Orchestrator schema modules
- Fix pattern matching issues in executor, messaging, notifications
- Remove incorrect Genesis v2 labeling from Lineage and OrchestratorOptimizer
- Remove Genesis cron jobs from deployment guide (separate system)

Lineage and OrchestratorOptimizer are workflow features, not Genesis.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: mikkihugo

TEST_REPORT.md

@@ -0,0 +1,23 @@
+# Test Report
+
+date: 2025-11-09T23:53:39Z
+
+## Summary
+
+- Bootstrapped all Mix dependencies offline via `scripts/bootstrap_deps.exs` and compiled the project in the test environment using the path overrides controlled by `BOOTSTRAP_HEX_DEPS`. 【0d28f4†L1-L88】【55e75c†L1-L2】
+- Installed PostgreSQL 16, started the cluster, and set the default `postgres` user's password to match the configuration used in `config/test.exs`. 【a7164c†L1-L13】【4e2311†L1-L1】【015903†L1-L5】
+- Database migrations fail because the required `pgmq` extension is not available in the system PostgreSQL installation; as a result, schema objects and stored procedures referenced by the test suite are missing. 【36dab8†L1-L11】
+- With the database skipped (`SINGULARITY_WORKFLOW_SKIP_DB=1`), the ExUnit suite aborts on the first test because the `Singularity.Workflow.Repo` sandbox cannot be checked out, demonstrating that database-backed tests still require the repo to be running even when migrations are bypassed. 【09ef84†L1-L23】
+
+## Logs
+
+- Manual dependency bootstrap downloads Hex tarballs and unpacks them into `deps/`. 【4e9b5f†L1-L90】
+- Compiling the application after bootstrapping succeeds. 【55e75c†L1-L2】
+- Attempting to run migrations raises `ERROR 0A000 (feature_not_supported) extension "pgmq" is not available`. 【36dab8†L1-L11】
+- `mix test --max-failures 1` exits early because the repo cannot be checked out, even when the database startup is skipped via environment variable. 【09ef84†L1-L23】【8de6bf†L1-L33】
+
+## Next Steps for Release Readiness
+
+1. Install the `pgmq` PostgreSQL extension (or adjust the migrations to skip it in CI) so that `mix ecto.migrate` can succeed. 【36dab8†L1-L11】
+2. Provide a lightweight `Singularity.Workflow.Repo` stub or start the repo under `SINGULARITY_WORKFLOW_SKIP_DB=1` so ExUnit can check out the sandbox during tests. 【09ef84†L1-L23】
+3. After the database issues are resolved, run the full `mix test` suite and the quality checks (`mix quality`) before cutting a release.

docs/DEPLOYMENT_GUIDE.md

@@ -167,19 +167,6 @@ SELECT cron.schedule(
   'SELECT Singularity.Storage.ValidationMetricsStore.sync_with_centralcloud();'
 );
 
--- Genesis v2: Publish learned rules every 6 hours
-SELECT cron.schedule(
-  'genesis-v2-publish-rules',
-  '0 */6 * * *',
-  'SELECT Singularity.Genesis.GenesisPublisher.publish_rules();'
-);
-
--- Genesis v2: Import evolved rules every 4 hours
-SELECT cron.schedule(
-  'genesis-v2-import-rules',
-  '0 */4 * * *',
-  'SELECT Singularity.Genesis.GenesisPublisher.import_rules_from_genesis();'
-);
 ```
 
 ### Database Maintenance

lib/singularity_workflow.ex

@@ -1,11 +1,11 @@
 defmodule Singularity.Workflow do
   @moduledoc """
-  Singularity.Workflow - Complete workflow orchestration with Genesis v2 (Self-Improving Workflows).
+  Singularity.Workflow - Complete workflow orchestration with self-improving capabilities.
 
   A unified package providing complete workflow orchestration capabilities,
   combining PGMQ-based message queuing, HTDAG goal decomposition, workflow execution,
-  and real-time notifications. Includes **Genesis v2** - self-improving workflows that
-  learn and adapt from execution history via `Lineage` tracking and `OrchestratorOptimizer`.
+  and real-time notifications. Includes workflow optimization features that learn and
+  adapt from execution history via `Lineage` tracking and `OrchestratorOptimizer`.
 
   Converts high-level goals into executable task graphs with automatic dependency
   resolution and parallel execution. Workflows automatically improve over time
@@ -90,7 +90,7 @@ defmodule Singularity.Workflow do
   - **Map Steps** - Variable task counts (`initial_tasks: N`) for bulk processing
   - **Dependency Merging** - Steps receive outputs from all dependencies
   - **Multi-Instance** - Horizontal scaling via pgmq + PostgreSQL
-  - **Genesis v2 (Self-Improving)** - Lineage tracking + OrchestratorOptimizer for adaptive learning
+  - **Self-Improving Workflows** - Lineage tracking + OrchestratorOptimizer for adaptive learning
 
   ## Quick Start
 
@@ -160,9 +160,9 @@ defmodule Singularity.Workflow do
         ]
       end
 
-  ## Genesis v2: Self-Improving Workflows
+  ## Self-Improving Workflows
 
-  Singularity.Workflow includes **Genesis v2** for automatic workflow optimization:
+  Singularity.Workflow includes automatic workflow optimization features:
 
   **Lineage Tracking** (`Singularity.Workflow.Lineage`):
   - Tracks complete execution history (genotype + phenotype + metrics)

lib/singularity_workflow/lineage.ex

@@ -1,8 +1,8 @@
 defmodule Singularity.Workflow.Lineage do
   @moduledoc """
-  DAG-based lineage tracking for Genesis v2 (self-improving workflows).
+  DAG-based lineage tracking for workflow execution history.
 
-  Exposes workflow execution history for learning systems and optimization.
+  Exposes workflow execution history for external learning systems.
   Each workflow run encodes:
   - Goal/input that triggered execution
   - Generated task graph (genotype)
@@ -14,7 +14,6 @@ defmodule Singularity.Workflow.Lineage do
   - Generational learning
   - Pattern mining
   - Performance analysis
-  - Adaptive workflow optimization (via OrchestratorOptimizer)
   """
 
   import Ecto.Query

lib/singularity_workflow/orchestrator/repository.ex

@@ -9,6 +9,7 @@ defmodule Singularity.Workflow.Orchestrator.Repository do
   require Logger
   import Ecto.Query
   alias Singularity.Workflow.Orchestrator.Schemas
+  @behaviour Singularity.Workflow.Orchestrator.Repository.Behaviour
 
   @doc """
   Create a new task graph.

lib/singularity_workflow/orchestrator/repository/behaviour.ex

@@ -0,0 +1,26 @@
+defmodule Singularity.Workflow.Orchestrator.Repository.Behaviour do
+  @moduledoc """
+  Behaviour definition for the orchestrator repository module so it can be mocked in tests.
+  """
+
+  alias Singularity.Workflow.Orchestrator.Schemas
+
+  @callback create_execution(map(), term()) ::
+              {:ok, Schemas.Execution.t()} | {:error, any()}
+  @callback update_execution_status(
+              Schemas.Execution.t(),
+              String.t(),
+              term(),
+              keyword()
+            ) :: {:ok, Schemas.Execution.t()} | {:error, any()}
+  @callback create_task_execution(map(), term()) ::
+              {:ok, Schemas.TaskExecution.t()} | {:error, any()}
+  @callback update_task_execution_status(
+              Schemas.TaskExecution.t(),
+              String.t(),
+              term(),
+              keyword()
+            ) :: {:ok, Schemas.TaskExecution.t()} | {:error, any()}
+  @callback get_execution(String.t(), term()) ::
+              {:ok, Schemas.Execution.t()} | {:error, any()}
+end

lib/singularity_workflow/orchestrator/schemas.ex

@@ -23,18 +23,25 @@ defmodule Singularity.Workflow.Orchestrator.Schemas do
           }
 
     @primary_key {:id, :binary_id, autogenerate: true}
+    @statuses ~w(pending ready active completed failed cancelled)
+
     schema "orchestrator_task_graphs" do
+      field(:name, :string)
       field(:goal, :string)
-      field(:tasks, :map)
+      field(:decomposer_module, :string)
+      field(:task_graph, :map)
       field(:metadata, :map, default: %{})
+      field(:max_depth, :integer, default: 5)
       field(:status, :string, default: "pending")
       timestamps()
     end
 
     def changeset(task_graph, attrs) do
       task_graph
-      |> cast(attrs, [:goal, :tasks, :metadata, :status])
-      |> validate_required([:goal])
+      |> cast(attrs, [:name, :goal, :decomposer_module, :task_graph, :metadata, :max_depth, :status])
+      |> validate_required([:name, :goal, :decomposer_module, :task_graph])
+      |> validate_number(:max_depth, greater_than: 0, less_than: 20)
+      |> validate_inclusion(:status, @statuses)
     end
   end
 
@@ -55,17 +62,38 @@ defmodule Singularity.Workflow.Orchestrator.Schemas do
           }
 
     @primary_key {:id, :binary_id, autogenerate: true}
+    @statuses ~w(created running completed failed cancelled)
+
     schema "orchestrator_workflows" do
       field(:name, :string)
       field(:description, :string)
+      field(:workflow_definition, :map)
+      field(:step_functions, :map)
       field(:config, :map, default: %{})
+      field(:metadata, :map, default: %{})
+      field(:max_parallel, :integer, default: 1)
+      field(:retry_attempts, :integer, default: 0)
+      field(:status, :string, default: "created")
       timestamps()
     end
 
     def workflow_changeset(workflow, attrs) do
       workflow
-      |> cast(attrs, [:name, :description, :config])
-      |> validate_required([:name])
+      |> cast(attrs, [
+        :name,
+        :description,
+        :workflow_definition,
+        :step_functions,
+        :config,
+        :metadata,
+        :max_parallel,
+        :retry_attempts,
+        :status
+      ])
+      |> validate_required([:name, :workflow_definition, :step_functions])
+      |> validate_number(:max_parallel, greater_than: 0)
+      |> validate_number(:retry_attempts, greater_than_or_equal_to: 0)
+      |> validate_inclusion(:status, @statuses)
     end
   end
 
@@ -88,19 +116,36 @@ defmodule Singularity.Workflow.Orchestrator.Schemas do
           }
 
     @primary_key {:id, :binary_id, autogenerate: true}
+    @statuses ~w(pending running completed failed cancelled)
+
     schema "orchestrator_executions" do
+      field(:execution_id, :string)
       field(:workflow_id, :binary_id)
-      field(:status, :string)
-      field(:result, :map)
+      field(:goal_context, :map, default: %{})
+      field(:status, :string, default: "pending")
+      field(:result, :map, default: %{})
+      field(:error_message, :string)
+      field(:duration_ms, :integer)
       field(:started_at, :utc_datetime)
       field(:completed_at, :utc_datetime)
       timestamps()
     end
 
     def execution_changeset(execution, attrs) do
       execution
-      |> cast(attrs, [:workflow_id, :status, :result, :started_at, :completed_at])
-      |> validate_required([:workflow_id, :status])
+      |> cast(attrs, [
+        :execution_id,
+        :workflow_id,
+        :goal_context,
+        :status,
+        :result,
+        :error_message,
+        :duration_ms,
+        :started_at,
+        :completed_at
+      ])
+      |> validate_required([:execution_id, :goal_context, :status])
+      |> validate_inclusion(:status, @statuses)
     end
   end
 
@@ -122,18 +167,39 @@ defmodule Singularity.Workflow.Orchestrator.Schemas do
           }
 
     @primary_key {:id, :binary_id, autogenerate: true}
+    @statuses ~w(pending running completed failed cancelled)
+
     schema "orchestrator_task_executions" do
       field(:execution_id, :binary_id)
       field(:task_id, :string)
-      field(:status, :string)
-      field(:result, :map)
+      field(:task_name, :string)
+      field(:status, :string, default: "pending")
+      field(:retry_count, :integer, default: 0)
+      field(:result, :map, default: %{})
+      field(:error_message, :string)
+      field(:duration_ms, :integer)
+      field(:started_at, :utc_datetime)
+      field(:completed_at, :utc_datetime)
       timestamps()
     end
 
     def task_execution_changeset(task_execution, attrs) do
       task_execution
-      |> cast(attrs, [:execution_id, :task_id, :status, :result])
-      |> validate_required([:execution_id, :task_id, :status])
+      |> cast(attrs, [
+        :execution_id,
+        :task_id,
+        :task_name,
+        :status,
+        :retry_count,
+        :result,
+        :error_message,
+        :duration_ms,
+        :started_at,
+        :completed_at
+      ])
+      |> validate_required([:execution_id, :task_id, :task_name, :status])
+      |> validate_number(:retry_count, greater_than_or_equal_to: 0, less_than: 10)
+      |> validate_inclusion(:status, @statuses)
     end
   end
 
@@ -153,17 +219,44 @@ defmodule Singularity.Workflow.Orchestrator.Schemas do
           }
 
     @primary_key {:id, :binary_id, autogenerate: true}
+    @allowed_event_types [
+      "task:started",
+      "task:completed",
+      "task:failed",
+      "workflow:started",
+      "workflow:completed",
+      "workflow:failed",
+      "decomposition:started",
+      "decomposition:completed",
+      "decomposition:failed",
+      "performance",
+      "performance:metrics"
+    ]
+
     schema "orchestrator_events" do
-      field(:type, :string)
-      field(:data, :map)
+      field(:event_type, :string)
+      field(:event_data, :map, default: %{})
+      field(:timestamp, :utc_datetime)
+      field(:execution_id, :binary_id)
+      field(:task_execution_id, :binary_id)
       timestamps()
     end
 
     def event_changeset(event, attrs) do
       event
-      |> cast(attrs, [:type, :data])
-      |> validate_required([:type])
+      |> cast(attrs, [:event_type, :event_data, :timestamp, :execution_id, :task_execution_id])
+      |> validate_required([:event_type, :event_data])
+      |> validate_change(:event_type, fn :event_type, value ->
+        if valid_event_type?(value) do
+          []
+        else
+          [event_type: "is invalid"]
+        end
+      end)
     end
+
+    defp valid_event_type?(value) when value in @allowed_event_types, do: true
+    defp valid_event_type?(value), do: String.match?(value, ~r/^[a-z_]+:(started|completed|failed)$/)
   end
 
   defmodule PerformanceMetric do
@@ -183,17 +276,24 @@ defmodule Singularity.Workflow.Orchestrator.Schemas do
           }
 
     @primary_key {:id, :binary_id, autogenerate: true}
+    @metric_types ["execution_time", "success_rate", "error_rate", "throughput", "latency"]
+
     schema "orchestrator_performance_metrics" do
-      field(:execution_id, :binary_id)
-      field(:metric_name, :string)
-      field(:value, :float)
+      field(:task_id, :string)
+      field(:metric_type, :string)
+      field(:metric_value, :float)
+      field(:metric_unit, :string)
+      field(:context, :map, default: %{})
+      field(:recorded_at, :utc_datetime)
       timestamps()
     end
 
     def performance_metric_changeset(metric, attrs) do
       metric
-      |> cast(attrs, [:execution_id, :metric_name, :value])
-      |> validate_required([:execution_id, :metric_name, :value])
+      |> cast(attrs, [:task_id, :metric_type, :metric_value, :metric_unit, :context, :recorded_at])
+      |> validate_required([:task_id, :metric_type, :metric_value])
+      |> validate_number(:metric_value, greater_than_or_equal_to: 0)
+      |> validate_inclusion(:metric_type, @metric_types)
     end
   end
 
@@ -214,17 +314,24 @@ defmodule Singularity.Workflow.Orchestrator.Schemas do
           }
 
     @primary_key {:id, :binary_id, autogenerate: true}
+    @pattern_types ["parallelization", "decomposition", "retry_strategy", "resource_allocation"]
+
     schema "orchestrator_learning_patterns" do
+      field(:workflow_name, :string)
       field(:pattern_type, :string)
       field(:pattern_data, :map)
-      field(:confidence, :float)
+      field(:confidence_score, :float, default: 0.0)
+      field(:usage_count, :integer, default: 0)
       timestamps()
     end
 
     def learning_pattern_changeset(pattern, attrs) do
       pattern
-      |> cast(attrs, [:pattern_type, :pattern_data, :confidence])
-      |> validate_required([:pattern_type, :pattern_data])
+      |> cast(attrs, [:workflow_name, :pattern_type, :pattern_data, :confidence_score, :usage_count])
+      |> validate_required([:workflow_name, :pattern_type, :pattern_data])
+      |> validate_number(:confidence_score, greater_than_or_equal_to: 0, less_than_or_equal_to: 1)
+      |> validate_number(:usage_count, greater_than_or_equal_to: 0)
+      |> validate_inclusion(:pattern_type, @pattern_types)
     end
   end
 end