opencode-swarm-plugin 0.20.0 → 0.22.0

package/src/streams/events.test.ts

@@ -21,6 +21,9 @@ import {
   TaskProgressEventSchema,
   TaskCompletedEventSchema,
   TaskBlockedEventSchema,
+  DecompositionGeneratedEventSchema,
+  SubtaskOutcomeEventSchema,
+  HumanFeedbackEventSchema,
   createEvent,
   isEventType,
   type AgentEvent,
@@ -361,6 +364,299 @@ describe("TaskBlockedEventSchema", () => {
   });
 });
 
+describe("DecompositionGeneratedEventSchema", () => {
+  it("validates a complete decomposition_generated event", () => {
+    const event = {
+      type: "decomposition_generated",
+      project_key: "/test/project",
+      timestamp: Date.now(),
+      epic_id: "bd-123",
+      task: "Add user authentication",
+      context: "OAuth integration for GitHub",
+      strategy: "feature-based",
+      epic_title: "User Authentication",
+      subtasks: [
+        {
+          title: "Create OAuth flow",
+          files: ["src/auth/oauth.ts"],
+          priority: 2,
+        },
+        { title: "Add login UI", files: ["src/ui/login.tsx"], priority: 1 },
+      ],
+    };
+    expect(() => DecompositionGeneratedEventSchema.parse(event)).not.toThrow();
+  });
+
+  it("validates without optional context", () => {
+    const event = {
+      type: "decomposition_generated",
+      project_key: "/test/project",
+      timestamp: Date.now(),
+      epic_id: "bd-123",
+      task: "Add user authentication",
+      strategy: "file-based",
+      epic_title: "User Authentication",
+      subtasks: [{ title: "Create OAuth flow", files: ["src/auth/oauth.ts"] }],
+    };
+    expect(() => DecompositionGeneratedEventSchema.parse(event)).not.toThrow();
+  });
+
+  it("validates strategy enum values", () => {
+    const validStrategies = ["file-based", "feature-based", "risk-based"];
+    for (const strategy of validStrategies) {
+      const event = {
+        type: "decomposition_generated",
+        project_key: "/test/project",
+        timestamp: Date.now(),
+        epic_id: "bd-123",
+        task: "Test task",
+        strategy,
+        epic_title: "Test",
+        subtasks: [{ title: "Subtask", files: ["test.ts"] }],
+      };
+      expect(() =>
+        DecompositionGeneratedEventSchema.parse(event),
+      ).not.toThrow();
+    }
+  });
+
+  it("rejects invalid strategy value", () => {
+    const event = {
+      type: "decomposition_generated",
+      project_key: "/test/project",
+      timestamp: Date.now(),
+      epic_id: "bd-123",
+      task: "Test task",
+      strategy: "invalid-strategy",
+      epic_title: "Test",
+      subtasks: [{ title: "Subtask", files: ["test.ts"] }],
+    };
+    expect(() => DecompositionGeneratedEventSchema.parse(event)).toThrow();
+  });
+
+  it("validates subtask priority bounds", () => {
+    const baseEvent = {
+      type: "decomposition_generated",
+      project_key: "/test/project",
+      timestamp: Date.now(),
+      epic_id: "bd-123",
+      task: "Test",
+      strategy: "file-based",
+      epic_title: "Test",
+    };
+
+    // Valid: 0
+    expect(() =>
+      DecompositionGeneratedEventSchema.parse({
+        ...baseEvent,
+        subtasks: [{ title: "Test", files: ["test.ts"], priority: 0 }],
+      }),
+    ).not.toThrow();
+
+    // Valid: 3
+    expect(() =>
+      DecompositionGeneratedEventSchema.parse({
+        ...baseEvent,
+        subtasks: [{ title: "Test", files: ["test.ts"], priority: 3 }],
+      }),
+    ).not.toThrow();
+
+    // Invalid: -1
+    expect(() =>
+      DecompositionGeneratedEventSchema.parse({
+        ...baseEvent,
+        subtasks: [{ title: "Test", files: ["test.ts"], priority: -1 }],
+      }),
+    ).toThrow();
+
+    // Invalid: 4
+    expect(() =>
+      DecompositionGeneratedEventSchema.parse({
+        ...baseEvent,
+        subtasks: [{ title: "Test", files: ["test.ts"], priority: 4 }],
+      }),
+    ).toThrow();
+  });
+
+  it("rejects empty subtasks array", () => {
+    const event = {
+      type: "decomposition_generated",
+      project_key: "/test/project",
+      timestamp: Date.now(),
+      epic_id: "bd-123",
+      task: "Test",
+      strategy: "file-based",
+      epic_title: "Test",
+      subtasks: [],
+    };
+    // Empty subtasks is valid per schema but semantically questionable
+    expect(() => DecompositionGeneratedEventSchema.parse(event)).not.toThrow();
+  });
+});
+
+describe("SubtaskOutcomeEventSchema", () => {
+  it("validates a complete subtask_outcome event", () => {
+    const event = {
+      type: "subtask_outcome",
+      project_key: "/test/project",
+      timestamp: Date.now(),
+      epic_id: "bd-123",
+      bead_id: "bd-123.1",
+      planned_files: ["src/auth.ts", "src/config.ts"],
+      actual_files: ["src/auth.ts", "src/config.ts", "src/utils.ts"],
+      duration_ms: 45000,
+      error_count: 2,
+      retry_count: 1,
+      success: true,
+    };
+    expect(() => SubtaskOutcomeEventSchema.parse(event)).not.toThrow();
+  });
+
+  it("applies defaults for error_count and retry_count", () => {
+    const event = {
+      type: "subtask_outcome",
+      project_key: "/test/project",
+      timestamp: Date.now(),
+      epic_id: "bd-123",
+      bead_id: "bd-123.1",
+      planned_files: ["src/auth.ts"],
+      actual_files: ["src/auth.ts"],
+      duration_ms: 10000,
+      success: true,
+    };
+    const parsed = SubtaskOutcomeEventSchema.parse(event);
+    expect(parsed.error_count).toBe(0);
+    expect(parsed.retry_count).toBe(0);
+  });
+
+  it("validates duration_ms is non-negative", () => {
+    const baseEvent = {
+      type: "subtask_outcome",
+      project_key: "/test/project",
+      timestamp: Date.now(),
+      epic_id: "bd-123",
+      bead_id: "bd-123.1",
+      planned_files: ["test.ts"],
+      actual_files: ["test.ts"],
+      success: true,
+    };
+
+    // Valid: 0
+    expect(() =>
+      SubtaskOutcomeEventSchema.parse({ ...baseEvent, duration_ms: 0 }),
+    ).not.toThrow();
+
+    // Valid: positive
+    expect(() =>
+      SubtaskOutcomeEventSchema.parse({ ...baseEvent, duration_ms: 1000 }),
+    ).not.toThrow();
+
+    // Invalid: negative
+    expect(() =>
+      SubtaskOutcomeEventSchema.parse({ ...baseEvent, duration_ms: -1 }),
+    ).toThrow();
+  });
+
+  it("validates error_count is non-negative", () => {
+    const baseEvent = {
+      type: "subtask_outcome",
+      project_key: "/test/project",
+      timestamp: Date.now(),
+      epic_id: "bd-123",
+      bead_id: "bd-123.1",
+      planned_files: ["test.ts"],
+      actual_files: ["test.ts"],
+      duration_ms: 1000,
+      success: true,
+    };
+
+    // Invalid: negative
+    expect(() =>
+      SubtaskOutcomeEventSchema.parse({ ...baseEvent, error_count: -1 }),
+    ).toThrow();
+  });
+
+  it("handles file lists with different lengths", () => {
+    const event = {
+      type: "subtask_outcome",
+      project_key: "/test/project",
+      timestamp: Date.now(),
+      epic_id: "bd-123",
+      bead_id: "bd-123.1",
+      planned_files: ["a.ts", "b.ts"],
+      actual_files: ["a.ts", "b.ts", "c.ts", "d.ts"],
+      duration_ms: 5000,
+      success: true,
+    };
+    expect(() => SubtaskOutcomeEventSchema.parse(event)).not.toThrow();
+  });
+});
+
+describe("HumanFeedbackEventSchema", () => {
+  it("validates a complete human_feedback event", () => {
+    const event = {
+      type: "human_feedback",
+      project_key: "/test/project",
+      timestamp: Date.now(),
+      epic_id: "bd-123",
+      accepted: true,
+      modified: false,
+      notes: "Looks good, no changes needed",
+    };
+    expect(() => HumanFeedbackEventSchema.parse(event)).not.toThrow();
+  });
+
+  it("validates accepted with modification", () => {
+    const event = {
+      type: "human_feedback",
+      project_key: "/test/project",
+      timestamp: Date.now(),
+      epic_id: "bd-123",
+      accepted: true,
+      modified: true,
+      notes: "Changed priority on subtask 2",
+    };
+    expect(() => HumanFeedbackEventSchema.parse(event)).not.toThrow();
+  });
+
+  it("validates rejected feedback", () => {
+    const event = {
+      type: "human_feedback",
+      project_key: "/test/project",
+      timestamp: Date.now(),
+      epic_id: "bd-123",
+      accepted: false,
+      modified: false,
+      notes: "Decomposition too granular, needs consolidation",
+    };
+    expect(() => HumanFeedbackEventSchema.parse(event)).not.toThrow();
+  });
+
+  it("applies default for modified", () => {
+    const event = {
+      type: "human_feedback",
+      project_key: "/test/project",
+      timestamp: Date.now(),
+      epic_id: "bd-123",
+      accepted: true,
+    };
+    const parsed = HumanFeedbackEventSchema.parse(event);
+    expect(parsed.modified).toBe(false);
+  });
+
+  it("validates without notes", () => {
+    const event = {
+      type: "human_feedback",
+      project_key: "/test/project",
+      timestamp: Date.now(),
+      epic_id: "bd-123",
+      accepted: true,
+      modified: false,
+    };
+    expect(() => HumanFeedbackEventSchema.parse(event)).not.toThrow();
+  });
+});
+
 // ============================================================================
 // Discriminated Union Tests
 // ============================================================================

package/src/streams/events.ts

@@ -141,6 +141,85 @@ export const TaskBlockedEventSchema = BaseEventSchema.extend({
   reason: z.string(),
 });
 
+// ============================================================================
+// Eval Capture Events (for learning system)
+// ============================================================================
+
+export const DecompositionGeneratedEventSchema = BaseEventSchema.extend({
+  type: z.literal("decomposition_generated"),
+  epic_id: z.string(),
+  task: z.string(),
+  context: z.string().optional(),
+  strategy: z.enum(["file-based", "feature-based", "risk-based"]),
+  epic_title: z.string(),
+  subtasks: z.array(
+    z.object({
+      title: z.string(),
+      files: z.array(z.string()),
+      priority: z.number().min(0).max(3).optional(),
+    }),
+  ),
+  recovery_context: z
+    .object({
+      shared_context: z.string().optional(),
+      skills_to_load: z.array(z.string()).optional(),
+      coordinator_notes: z.string().optional(),
+    })
+    .optional(),
+});
+
+export const SubtaskOutcomeEventSchema = BaseEventSchema.extend({
+  type: z.literal("subtask_outcome"),
+  epic_id: z.string(),
+  bead_id: z.string(),
+  planned_files: z.array(z.string()),
+  actual_files: z.array(z.string()),
+  duration_ms: z.number().min(0),
+  error_count: z.number().min(0).default(0),
+  retry_count: z.number().min(0).default(0),
+  success: z.boolean(),
+});
+
+export const HumanFeedbackEventSchema = BaseEventSchema.extend({
+  type: z.literal("human_feedback"),
+  epic_id: z.string(),
+  accepted: z.boolean(),
+  modified: z.boolean().default(false),
+  notes: z.string().optional(),
+});
+
+// ============================================================================
+// Swarm Checkpoint Events (for recovery and coordination)
+// ============================================================================
+
+export const SwarmCheckpointedEventSchema = BaseEventSchema.extend({
+  type: z.literal("swarm_checkpointed"),
+  epic_id: z.string(),
+  bead_id: z.string(),
+  strategy: z.enum(["file-based", "feature-based", "risk-based"]),
+  files: z.array(z.string()),
+  dependencies: z.array(z.string()),
+  directives: z.object({
+    shared_context: z.string().optional(),
+    skills_to_load: z.array(z.string()).optional(),
+    coordinator_notes: z.string().optional(),
+  }),
+  recovery: z.object({
+    last_checkpoint: z.number(),
+    files_modified: z.array(z.string()),
+    progress_percent: z.number().min(0).max(100),
+    last_message: z.string().optional(),
+    error_context: z.string().optional(),
+  }),
+});
+
+export const SwarmRecoveredEventSchema = BaseEventSchema.extend({
+  type: z.literal("swarm_recovered"),
+  epic_id: z.string(),
+  bead_id: z.string(),
+  recovered_from_checkpoint: z.number(), // timestamp
+});
+
 // ============================================================================
 // Union Type
 // ============================================================================
@@ -157,6 +236,11 @@ export const AgentEventSchema = z.discriminatedUnion("type", [
   TaskProgressEventSchema,
   TaskCompletedEventSchema,
   TaskBlockedEventSchema,
+  DecompositionGeneratedEventSchema,
+  SubtaskOutcomeEventSchema,
+  HumanFeedbackEventSchema,
+  SwarmCheckpointedEventSchema,
+  SwarmRecoveredEventSchema,
 ]);
 
 export type AgentEvent = z.infer<typeof AgentEventSchema>;
@@ -173,6 +257,15 @@ export type TaskStartedEvent = z.infer<typeof TaskStartedEventSchema>;
 export type TaskProgressEvent = z.infer<typeof TaskProgressEventSchema>;
 export type TaskCompletedEvent = z.infer<typeof TaskCompletedEventSchema>;
 export type TaskBlockedEvent = z.infer<typeof TaskBlockedEventSchema>;
+export type DecompositionGeneratedEvent = z.infer<
+  typeof DecompositionGeneratedEventSchema
+>;
+export type SubtaskOutcomeEvent = z.infer<typeof SubtaskOutcomeEventSchema>;
+export type HumanFeedbackEvent = z.infer<typeof HumanFeedbackEventSchema>;
+export type SwarmCheckpointedEvent = z.infer<
+  typeof SwarmCheckpointedEventSchema
+>;
+export type SwarmRecoveredEvent = z.infer<typeof SwarmRecoveredEventSchema>;
 
 // ============================================================================
 // Session State Types

package/src/streams/migrations.test.ts

@@ -34,11 +34,11 @@ describe("Schema Migrations", () => {
     it("should run all migrations on fresh database", async () => {
       const result = await runMigrations(db);
 
-      expect(result.applied).toEqual([1, 2]);
-      expect(result.current).toBe(2);
+      expect(result.applied).toEqual([1, 2, 3, 4]);
+      expect(result.current).toBe(4);
 
       const version = await getCurrentVersion(db);
-      expect(version).toBe(2);
+      expect(version).toBe(4);
     });
 
     it("should create cursors table with correct schema", async () => {
@@ -105,16 +105,16 @@ describe("Schema Migrations", () => {
     it("should be safe to run migrations multiple times", async () => {
       // First run
       const result1 = await runMigrations(db);
-      expect(result1.applied).toEqual([1, 2]);
+      expect(result1.applied).toEqual([1, 2, 3, 4]);
 
       // Second run - should apply nothing
       const result2 = await runMigrations(db);
       expect(result2.applied).toEqual([]);
-      expect(result2.current).toBe(2);
+      expect(result2.current).toBe(4);
 
       // Version should still be 2
       const version = await getCurrentVersion(db);
-      expect(version).toBe(2);
+      expect(version).toBe(4);
     });
   });
 
@@ -137,8 +137,8 @@ describe("Schema Migrations", () => {
 
       // Now run migrations - should only apply 2
       const result = await runMigrations(db);
-      expect(result.applied).toEqual([2]);
-      expect(result.current).toBe(2);
+      expect(result.applied).toEqual([2, 3, 4]);
+      expect(result.current).toBe(4);
     });
   });
 
@@ -146,11 +146,11 @@ describe("Schema Migrations", () => {
     it("should rollback to target version", async () => {
       // Apply all migrations
       await runMigrations(db);
-      expect(await getCurrentVersion(db)).toBe(2);
+      expect(await getCurrentVersion(db)).toBe(4);
 
       // Rollback to version 1
       const result = await rollbackTo(db, 1);
-      expect(result.rolledBack).toEqual([2]);
+      expect(result.rolledBack).toEqual([4, 3, 2]);
       expect(result.current).toBe(1);
 
       // Version should be 1
@@ -180,7 +180,7 @@ describe("Schema Migrations", () => {
       await runMigrations(db);
 
       const result = await rollbackTo(db, 0);
-      expect(result.rolledBack).toEqual([2, 1]);
+      expect(result.rolledBack).toEqual([4, 3, 2, 1]);
       expect(result.current).toBe(0);
 
       // All tables should be gone
@@ -196,9 +196,9 @@ describe("Schema Migrations", () => {
     it("should do nothing if target version >= current", async () => {
       await runMigrations(db);
 
-      const result = await rollbackTo(db, 2);
+      const result = await rollbackTo(db, 4);
       expect(result.rolledBack).toEqual([]);
-      expect(result.current).toBe(2);
+      expect(result.current).toBe(4);
     });
   });
 
@@ -210,12 +210,16 @@ describe("Schema Migrations", () => {
 
       expect(await isMigrationApplied(db, 1)).toBe(true);
       expect(await isMigrationApplied(db, 2)).toBe(true);
+      expect(await isMigrationApplied(db, 3)).toBe(true);
+      expect(await isMigrationApplied(db, 4)).toBe(true);
+      expect(await isMigrationApplied(db, 3)).toBe(true);
+      expect(await isMigrationApplied(db, 4)).toBe(true);
     });
 
     it("should list pending migrations", async () => {
       const pending1 = await getPendingMigrations(db);
-      expect(pending1).toHaveLength(2);
-      expect(pending1.map((m) => m.version)).toEqual([1, 2]);
+      expect(pending1).toHaveLength(4);
+      expect(pending1.map((m) => m.version)).toEqual([1, 2, 3, 4]);
 
       // Apply migration 1
       const migration = migrations[0];
@@ -236,8 +240,8 @@ describe("Schema Migrations", () => {
       );
 
       const pending2 = await getPendingMigrations(db);
-      expect(pending2).toHaveLength(1);
-      expect(pending2.map((m) => m.version)).toEqual([2]);
+      expect(pending2).toHaveLength(3);
+      expect(pending2.map((m) => m.version)).toEqual([2, 3, 4]);
     });
 
     it("should list applied migrations", async () => {
@@ -247,8 +251,8 @@ describe("Schema Migrations", () => {
       await runMigrations(db);
 
       const applied2 = await getAppliedMigrations(db);
-      expect(applied2).toHaveLength(2);
-      expect(applied2.map((m) => m.version)).toEqual([1, 2]);
+      expect(applied2).toHaveLength(4);
+      expect(applied2.map((m) => m.version)).toEqual([1, 2, 3, 4]);
       expect(applied2[0]?.description).toBe(
         "Add cursors table for DurableCursor",
       );
@@ -340,7 +344,7 @@ describe("Schema Migrations", () => {
         `SELECT version, applied_at, description FROM schema_version ORDER BY version`,
       );
 
-      expect(result.rows).toHaveLength(2);
+      expect(result.rows).toHaveLength(4);
       expect(result.rows[0]?.version).toBe(1);
       expect(result.rows[0]?.description).toBe(
         "Add cursors table for DurableCursor",

package/src/streams/migrations.ts

@@ -107,6 +107,57 @@ export const migrations: Migration[] = [
     `,
     down: `DROP TABLE IF EXISTS deferred;`,
   },
+  {
+    version: 3,
+    description: "Add eval_records table for learning system",
+    up: `
+      CREATE TABLE IF NOT EXISTS eval_records (
+        id TEXT PRIMARY KEY,
+        project_key TEXT NOT NULL,
+        task TEXT NOT NULL,
+        context TEXT,
+        strategy TEXT NOT NULL,
+        epic_title TEXT NOT NULL,
+        subtasks JSONB NOT NULL,
+        outcomes JSONB,
+        overall_success BOOLEAN,
+        total_duration_ms INTEGER,
+        total_errors INTEGER,
+        human_accepted BOOLEAN,
+        human_modified BOOLEAN,
+        human_notes TEXT,
+        file_overlap_count INTEGER,
+        scope_accuracy REAL,
+        time_balance_ratio REAL,
+        created_at BIGINT NOT NULL,
+        updated_at BIGINT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_eval_records_project ON eval_records(project_key);
+      CREATE INDEX IF NOT EXISTS idx_eval_records_strategy ON eval_records(strategy);
+    `,
+    down: `DROP TABLE IF EXISTS eval_records;`,
+  },
+  {
+    version: 4,
+    description: "Add swarm_contexts table for context recovery",
+    up: `
+      CREATE TABLE IF NOT EXISTS swarm_contexts (
+        id TEXT PRIMARY KEY,
+        epic_id TEXT NOT NULL,
+        bead_id TEXT NOT NULL,
+        strategy TEXT NOT NULL,
+        files JSONB NOT NULL,
+        dependencies JSONB NOT NULL,
+        directives JSONB NOT NULL,
+        recovery JSONB NOT NULL,
+        created_at BIGINT NOT NULL,
+        updated_at BIGINT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_swarm_contexts_epic ON swarm_contexts(epic_id);
+      CREATE INDEX IF NOT EXISTS idx_swarm_contexts_bead ON swarm_contexts(bead_id);
+    `,
+    down: `DROP TABLE IF EXISTS swarm_contexts;`,
+  },
 ];
 
 // ============================================================================