aidp 0.47.1 → 0.48.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 687e2dc3dc54edf4fcdabb7ca75462595d51f0d8a1f3ad09d1954d035f576b05
-  data.tar.gz: '089d63153f9a059188ce59385882d3920b32fbb40d4be644bbc877eade2263b6'
+  metadata.gz: 497afaf23ef14fc5ebced21f0ca90a090bcc66f642002fc289d3757dc9a136f8
+  data.tar.gz: f2a8e664cb040b4869a5b2b1ccf15fabe9524baed622bf6b9a04ce57e0d3c864
 SHA512:
-  metadata.gz: bd7626bbf6245b7f02748abb9761423a4d7e64fc81983ca35bf7ecd14a15b3c6916ac80085e7df5c1dc6861e007cfb372bacf67bef6fb670bd73de5b206655b9
-  data.tar.gz: 8ef9d9a2dbd220408a45d3d7f4d3bf96b07445d24a5a05867a4c6094a4e0425f69c7f033e42966d73d35ab207d2f157fc781163196ba2c837f4ddc7ad5149371
+  metadata.gz: 69b44c42f6c45c7d7239674c2f06f3326b1437c477bea43f98dfcf9fdfab3ed1a9811c14fd20ec49e7af0af0efe798c0cfe7e74443f43a39de263f30e62cb745
+  data.tar.gz: 5be71e4d983121166264108f9711245d7f26129a26e318a6a0ce9f38b3a5aaabba30544e818c41a6606671554e8a6264adba4abdd622b0c49e8d0c0e90051591

data/lib/aidp/cli/temporal_command.rb

@@ -3,6 +3,8 @@
 require "tty-prompt"
 require "tty-table"
 require "pastel"
+require_relative "../strategy_execution/strategy_loader"
+require_relative "../strategy_execution/experience_store"
 require_relative "terminal_io"
 
 module Aidp
@@ -30,6 +32,10 @@ module Aidp
         case subcommand
         when "start", nil
           start_workflow(args)
+        when "replay"
+          replay_workflow(args)
+        when "benchmark"
+          benchmark_workflows(args)
         when "list"
           list_workflows(args)
         when "status"
@@ -61,6 +67,9 @@ module Aidp
         display_message("")
         display_message("Temporal Workflow Commands:", type: :info)
         display_message("  aidp temporal start [issue_number]  - Start issue-to-PR workflow", type: :info)
+        display_message("  aidp temporal start strategy <strategy.yml> [task.json] - Start strategy workflow", type: :info)
+        display_message("  aidp temporal replay <run_id> <strategy.yml> - Replay a task with a new strategy", type: :info)
+        display_message("  aidp temporal benchmark <strategy.yml> <run_id> [run_id...] - Replay many runs", type: :info)
         display_message("  aidp temporal list                  - List active workflows", type: :info)
         display_message("  aidp temporal status <workflow_id>  - Show workflow status", type: :info)
         display_message("  aidp temporal signal <workflow_id> <signal> - Send signal to workflow", type: :info)
@@ -80,9 +89,11 @@ module Aidp
           start_issue_to_pr_workflow(issue_number)
         when "workloop", "work_loop"
           start_work_loop_workflow(args)
+        when "strategy"
+          start_strategy_workflow(args)
         else
           display_message("Unknown workflow type: #{workflow_type}", type: :error)
-          display_message("Available: issue, workloop", type: :info)
+          display_message("Available: issue, workloop, strategy", type: :info)
         end
       end
 
@@ -90,6 +101,7 @@ module Aidp
         @prompt.select("Select workflow type:") do |menu|
           menu.choice "Issue to PR (full pipeline)", "issue"
           menu.choice "Work Loop (fix-forward iteration)", "workloop"
+          menu.choice "Strategy Execution", "strategy"
         end
       end
 
@@ -144,6 +156,92 @@ module Aidp
         display_message("Monitor with: aidp temporal status #{handle.id}", type: :info)
       end
 
+      def start_strategy_workflow(args)
+        strategy_path = args.shift
+        task_path = args.shift
+
+        unless strategy_path
+          display_message("Usage: aidp temporal start strategy <strategy.yml> [task.json]", type: :error)
+          return
+        end
+
+        strategy = load_strategy(strategy_path)
+        task = task_path ? load_task(task_path) : prompt_for_task
+
+        handle = Aidp::Temporal.start_workflow(
+          Aidp::Temporal::Workflows::StrategyExecutionWorkflow,
+          {
+            project_dir: @project_dir,
+            strategy: strategy.to_h,
+            task: task
+          },
+          project_dir: @project_dir
+        )
+
+        display_message("Started strategy workflow #{strategy.name}", type: :success)
+        display_message("  Workflow ID: #{handle.id}", type: :info)
+      end
+
+      def replay_workflow(args)
+        original_run_id = args.shift
+        strategy_path = args.shift
+
+        unless original_run_id && strategy_path
+          display_message("Usage: aidp temporal replay <run_id> <strategy.yml>", type: :error)
+          return
+        end
+
+        bundle = experience_store.replay_bundle(original_run_id)
+        unless bundle
+          display_message("Replay source run not found: #{original_run_id}", type: :error)
+          return
+        end
+
+        strategy = load_strategy(strategy_path)
+        replay_task = build_replay_task(bundle[:task], original_run_id)
+
+        handle = Aidp::Temporal.start_workflow(
+          Aidp::Temporal::Workflows::StrategyExecutionWorkflow,
+          {
+            project_dir: @project_dir,
+            strategy: strategy.to_h,
+            task: replay_task
+          },
+          project_dir: @project_dir
+        )
+
+        display_message("Replay started from run #{original_run_id}", type: :success)
+        display_message("  Workflow ID: #{handle.id}", type: :info)
+      end
+
+      def benchmark_workflows(args)
+        strategy_path = args.shift
+        run_ids = args
+
+        unless strategy_path && run_ids.any?
+          display_message("Usage: aidp temporal benchmark <strategy.yml> <run_id> [run_id...]", type: :error)
+          return
+        end
+
+        strategy = load_strategy(strategy_path)
+        started = run_ids.filter_map do |run_id|
+          bundle = experience_store.replay_bundle(run_id)
+          next unless bundle
+
+          Aidp::Temporal.start_workflow(
+            Aidp::Temporal::Workflows::StrategyExecutionWorkflow,
+            {
+              project_dir: @project_dir,
+              strategy: strategy.to_h,
+              task: build_replay_task(bundle[:task], run_id)
+            },
+            project_dir: @project_dir
+          ).id
+        end
+
+        display_message("Started #{started.length} benchmark replay workflow(s)", type: :success)
+      end
+
       def list_workflows(args)
         require_relative "../temporal"
 
@@ -327,7 +425,9 @@ module Aidp
         worker.register_workflows(
           Aidp::Temporal::Workflows::IssueToPrWorkflow,
           Aidp::Temporal::Workflows::WorkLoopWorkflow,
-          Aidp::Temporal::Workflows::SubIssueWorkflow
+          Aidp::Temporal::Workflows::SubIssueWorkflow,
+          Aidp::Temporal::Workflows::StrategyBranchWorkflow,
+          Aidp::Temporal::Workflows::StrategyExecutionWorkflow
         )
 
         # Register all activities
@@ -342,7 +442,9 @@ module Aidp
           Aidp::Temporal::Activities::RecordCheckpointActivity.new,
           Aidp::Temporal::Activities::CreatePrActivity.new,
           Aidp::Temporal::Activities::RunWorkLoopIterationActivity.new,
-          Aidp::Temporal::Activities::AnalyzeSubTaskActivity.new
+          Aidp::Temporal::Activities::AnalyzeSubTaskActivity.new,
+          Aidp::Temporal::Activities::ExecuteCliCommandActivity.new,
+          Aidp::Temporal::Activities::ManageExperienceStoreActivity.new
         )
 
         display_message(@pastel.green("Worker started"), type: :success)
@@ -420,6 +522,33 @@ module Aidp
         display_message("  3. Start workflow: aidp temporal start issue <number>", type: :info)
       end
 
+      def load_strategy(strategy_path)
+        StrategyExecution::StrategyLoader.new(project_dir: @project_dir).load_file(strategy_path)
+      end
+
+      def build_replay_task(bundle_task, source_run_id)
+        bundle_task.except(:id, :source_run_id).merge(source_run_id: source_run_id)
+      end
+
+      def load_task(task_path)
+        JSON.parse(File.read(expand_path(task_path)), symbolize_names: true)
+      end
+
+      def prompt_for_task
+        {
+          title: @prompt.ask("Task title:"),
+          description: @prompt.ask("Task description:")
+        }
+      end
+
+      def experience_store
+        @experience_store ||= StrategyExecution::ExperienceStore.new(project_dir: @project_dir)
+      end
+
+      def expand_path(path)
+        File.expand_path(path, @project_dir)
+      end
+
       def format_status(status)
         case status.to_s
         when "running"

data/lib/aidp/database/repositories/experience_artifact_repository.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      class ExperienceArtifactRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "experience_artifacts")
+        end
+
+        def record(run_id:, role:, path:, metadata: {})
+          execute(
+            insert_sql([:project_dir, :run_id, :role, :path, :metadata]),
+            [project_dir, run_id, role, path, serialize_json(metadata || {})]
+          )
+
+          Aidp.log_debug("experience_artifact_repository", "recorded",
+            run_id: run_id, role: role, path: path)
+        end
+
+        def list_for_run(run_id)
+          rows = query(
+            "SELECT * FROM experience_artifacts WHERE run_id = ? AND project_dir = ? ORDER BY id ASC",
+            [run_id, project_dir]
+          )
+          rows.map do |row|
+            {
+              role: row["role"],
+              path: row["path"],
+              metadata: deserialize_json(row["metadata"]) || {},
+              created_at: row["created_at"]
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aidp/database/repositories/experience_evaluation_repository.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      class ExperienceEvaluationRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "experience_evaluations")
+        end
+
+        def record(run_id:, evaluator_name:, score:, passed:, summary: nil, metadata: {})
+          execute(
+            insert_sql([
+              :project_dir, :run_id, :evaluator_name, :score, :passed, :summary, :metadata
+            ]),
+            [
+              project_dir,
+              run_id,
+              evaluator_name,
+              score,
+              passed ? 1 : 0,
+              summary,
+              serialize_json(metadata || {})
+            ]
+          )
+
+          Aidp.log_debug("experience_evaluation_repository", "recorded",
+            run_id: run_id,
+            evaluator_name: evaluator_name,
+            score: score,
+            passed: passed)
+        end
+
+        def list_for_run(run_id)
+          rows = query(
+            "SELECT * FROM experience_evaluations WHERE run_id = ? AND project_dir = ? ORDER BY id ASC",
+            [run_id, project_dir]
+          )
+          rows.map do |row|
+            {
+              evaluator_name: row["evaluator_name"],
+              score: row["score"],
+              passed: row["passed"] == 1,
+              summary: row["summary"],
+              metadata: deserialize_json(row["metadata"]) || {},
+              created_at: row["created_at"]
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aidp/database/repositories/experience_run_repository.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      class ExperienceRunRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "experience_runs")
+        end
+
+        def start(task_id:, strategy_id:, workflow_id:, depth:, input_payload:, parent_run_id: nil, branch_key: nil, metadata: {})
+          run_id = SecureRandom.uuid
+
+          execute(
+            insert_sql([
+              :id, :project_dir, :task_id, :strategy_id, :workflow_id, :parent_run_id,
+              :branch_key, :status, :depth, :input_payload, :metadata
+            ]),
+            [
+              run_id,
+              project_dir,
+              task_id,
+              strategy_id,
+              workflow_id,
+              parent_run_id,
+              branch_key,
+              "running",
+              depth,
+              serialize_json(input_payload || {}),
+              serialize_json(metadata || {})
+            ]
+          )
+
+          Aidp.log_debug("experience_run_repository", "started",
+            id: run_id,
+            task_id: task_id,
+            strategy_id: strategy_id,
+            branch_key: branch_key,
+            depth: depth)
+
+          load(run_id)
+        end
+
+        def complete(run_id:, status:, output_payload:, metadata: {})
+          merged_metadata = existing_metadata(run_id).merge(metadata || {})
+
+          execute(
+            <<~SQL,
+              UPDATE experience_runs
+              SET status = ?, output_payload = ?, metadata = ?, completed_at = ?
+              WHERE id = ? AND project_dir = ?
+            SQL
+            [
+              status,
+              serialize_json(output_payload || {}),
+              serialize_json(merged_metadata),
+              current_timestamp,
+              run_id,
+              project_dir
+            ]
+          )
+
+          Aidp.log_debug("experience_run_repository", "completed",
+            id: run_id, status: status)
+
+          load(run_id)
+        end
+
+        def load(run_id)
+          row = query_one(
+            "SELECT * FROM experience_runs WHERE id = ? AND project_dir = ?",
+            [run_id, project_dir]
+          )
+          deserialize_run(row)
+        end
+
+        def bundle_for_replay(run_id)
+          row = query_one(
+            <<~SQL,
+              SELECT runs.*, tasks.title AS task_title, tasks.description AS task_description,
+                     tasks.input_payload AS task_input_payload, tasks.context AS task_context,
+                     tasks.source_run_id AS task_source_run_id
+              FROM experience_runs runs
+              JOIN experience_tasks tasks ON tasks.id = runs.task_id
+              WHERE runs.id = ? AND runs.project_dir = ?
+            SQL
+            [run_id, project_dir]
+          )
+          return nil unless row
+
+          run = deserialize_run(row)
+          run.merge(
+            task: {
+              id: row["task_id"],
+              title: row["task_title"],
+              description: row["task_description"],
+              input_payload: deserialize_json(row["task_input_payload"]) || {},
+              context: deserialize_json(row["task_context"]) || {},
+              source_run_id: row["task_source_run_id"]
+            }
+          )
+        end
+
+        def children(parent_run_id)
+          rows = query(
+            "SELECT * FROM experience_runs WHERE parent_run_id = ? AND project_dir = ? ORDER BY started_at ASC",
+            [parent_run_id, project_dir]
+          )
+          rows.map { |row| deserialize_run(row) }
+        end
+
+        private
+
+        def existing_metadata(run_id)
+          load(run_id)&.fetch(:metadata, {}) || {}
+        end
+
+        def deserialize_run(row)
+          return nil unless row
+
+          {
+            id: row["id"],
+            task_id: row["task_id"],
+            strategy_id: row["strategy_id"],
+            workflow_id: row["workflow_id"],
+            parent_run_id: row["parent_run_id"],
+            branch_key: row["branch_key"],
+            status: row["status"],
+            depth: row["depth"],
+            input_payload: deserialize_json(row["input_payload"]) || {},
+            output_payload: deserialize_json(row["output_payload"]) || {},
+            metadata: deserialize_json(row["metadata"]) || {},
+            started_at: row["started_at"],
+            completed_at: row["completed_at"]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/aidp/database/repositories/experience_task_repository.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      class ExperienceTaskRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "experience_tasks")
+        end
+
+        def create(description:, title: nil, input_payload: {}, context: {}, source_run_id: nil)
+          task_id = SecureRandom.uuid
+
+          execute(
+            insert_sql([:id, :project_dir, :title, :description, :input_payload, :context, :source_run_id]),
+            [
+              task_id,
+              project_dir,
+              title,
+              description,
+              serialize_json(input_payload || {}),
+              serialize_json(context || {}),
+              source_run_id
+            ]
+          )
+
+          Aidp.log_debug("experience_task_repository", "created",
+            id: task_id, source_run_id: source_run_id)
+
+          load(task_id)
+        end
+
+        def load(task_id)
+          row = query_one(
+            "SELECT * FROM experience_tasks WHERE id = ? AND project_dir = ?",
+            [task_id, project_dir]
+          )
+          deserialize_task(row)
+        end
+
+        private
+
+        def deserialize_task(row)
+          return nil unless row
+
+          {
+            id: row["id"],
+            title: row["title"],
+            description: row["description"],
+            input_payload: deserialize_json(row["input_payload"]) || {},
+            context: deserialize_json(row["context"]) || {},
+            source_run_id: row["source_run_id"],
+            created_at: row["created_at"]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/aidp/database/repositories/strategy_repository.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "digest"
+require_relative "../repository"
+
+module Aidp
+  module Database
+    module Repositories
+      class StrategyRepository < Repository
+        def initialize(project_dir: Dir.pwd)
+          super(project_dir: project_dir, table_name: "strategies")
+        end
+
+        def register(name:, spec:)
+          strategy_id = Digest::SHA256.hexdigest("#{project_dir}:#{name}:#{spec}")
+
+          # Concurrent sibling child workflows can register the identical
+          # strategy at the same time (same deterministic strategy_id), so
+          # the insert must be idempotent rather than a check-then-insert to
+          # avoid a primary-key race between them.
+          execute(
+            "INSERT OR IGNORE INTO #{table_name} (id, project_dir, name, spec) VALUES (?, ?, ?, ?)",
+            [strategy_id, project_dir, name, spec]
+          )
+
+          Aidp.log_debug("strategy_repository", "registered", id: strategy_id, name: name)
+
+          {id: strategy_id, name: name}
+        end
+
+        def load(id)
+          row = query_one("SELECT * FROM strategies WHERE id = ? AND project_dir = ?", [id, project_dir])
+          deserialize_strategy(row)
+        end
+
+        def find_by_name(name)
+          row = query_one(
+            "SELECT * FROM strategies WHERE project_dir = ? AND name = ? ORDER BY created_at DESC, rowid DESC",
+            [project_dir, name]
+          )
+          deserialize_strategy(row)
+        end
+
+        private
+
+        def deserialize_strategy(row)
+          return nil unless row
+
+          {
+            id: row["id"],
+            name: row["name"],
+            spec: deserialize_json(row["spec"]) || {},
+            created_at: row["created_at"]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/aidp/database/schema.rb

@@ -321,11 +321,105 @@ module Aidp
         CREATE UNIQUE INDEX IF NOT EXISTS idx_template_versions_unique ON template_versions(project_dir, template_id, version_number);
       SQL
 
+      # Version 4: Add strategy execution experience store
+      V4_STRATEGY_EXECUTION = <<~SQL
+        -- Strategy definitions for orchestration-as-data
+        CREATE TABLE IF NOT EXISTS strategies (
+            id TEXT PRIMARY KEY,
+            project_dir TEXT NOT NULL,
+            name TEXT NOT NULL,
+            spec TEXT NOT NULL,
+            created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_strategies_project_name ON strategies(project_dir, name);
+
+        -- Replayable task inputs for strategy execution
+        CREATE TABLE IF NOT EXISTS experience_tasks (
+            id TEXT PRIMARY KEY,
+            project_dir TEXT NOT NULL,
+            title TEXT,
+            description TEXT NOT NULL,
+            input_payload TEXT,
+            context TEXT,
+            source_run_id TEXT,
+            created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_experience_tasks_project ON experience_tasks(project_dir);
+        CREATE INDEX IF NOT EXISTS idx_experience_tasks_source_run ON experience_tasks(source_run_id);
+
+        -- Individual strategy execution runs, including speculative branches
+        CREATE TABLE IF NOT EXISTS experience_runs (
+            id TEXT PRIMARY KEY,
+            project_dir TEXT NOT NULL,
+            task_id TEXT NOT NULL,
+            strategy_id TEXT NOT NULL,
+            workflow_id TEXT,
+            parent_run_id TEXT,
+            branch_key TEXT,
+            status TEXT NOT NULL,
+            depth INTEGER DEFAULT 0,
+            input_payload TEXT,
+            output_payload TEXT,
+            metadata TEXT,
+            started_at TEXT NOT NULL DEFAULT (datetime('now')),
+            completed_at TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_experience_runs_project ON experience_runs(project_dir);
+        CREATE INDEX IF NOT EXISTS idx_experience_runs_task ON experience_runs(task_id);
+        CREATE INDEX IF NOT EXISTS idx_experience_runs_parent ON experience_runs(parent_run_id);
+        CREATE INDEX IF NOT EXISTS idx_experience_runs_strategy ON experience_runs(strategy_id);
+
+        -- Evaluation signals captured for each run
+        CREATE TABLE IF NOT EXISTS experience_evaluations (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            project_dir TEXT NOT NULL,
+            run_id TEXT NOT NULL,
+            evaluator_name TEXT NOT NULL,
+            score REAL,
+            passed INTEGER DEFAULT 0 CHECK (passed IN (0, 1)),
+            summary TEXT,
+            metadata TEXT,
+            created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_experience_evaluations_run ON experience_evaluations(run_id);
+        CREATE INDEX IF NOT EXISTS idx_experience_evaluations_name ON experience_evaluations(project_dir, evaluator_name);
+
+        -- Artifact metadata produced by runs
+        CREATE TABLE IF NOT EXISTS experience_artifacts (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            project_dir TEXT NOT NULL,
+            run_id TEXT NOT NULL,
+            role TEXT NOT NULL,
+            path TEXT NOT NULL,
+            metadata TEXT,
+            created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_experience_artifacts_run ON experience_artifacts(run_id);
+
+        -- Embeddings are stored as JSON vectors until a dedicated vector store exists
+        CREATE TABLE IF NOT EXISTS experience_embeddings (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            project_dir TEXT NOT NULL,
+            task_id TEXT,
+            run_id TEXT,
+            embedding_type TEXT NOT NULL,
+            vector TEXT NOT NULL,
+            metadata TEXT,
+            created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_experience_embeddings_task ON experience_embeddings(task_id);
+        CREATE INDEX IF NOT EXISTS idx_experience_embeddings_run ON experience_embeddings(run_id);
+      SQL
+
       # All migrations in order
+      # V4's strategies index is intentionally non-unique so that immutable
+      # versions of a named strategy can coexist for replay and auditability;
+      # StrategyRepository keys rows by a SHA256(project_dir:name:spec) digest.
       MIGRATIONS = {
         1 => V1_INITIAL,
         2 => V2_PROMPT_FEEDBACK,
-        3 => V3_TEMPLATE_VERSIONS
+        3 => V3_TEMPLATE_VERSIONS,
+        4 => V4_STRATEGY_EXECUTION
       }.freeze
 
       # Get SQL for a specific version