@codexa/cli 9.0.7 → 9.0.9

package/commands/integration.test.ts

@@ -0,0 +1,754 @@
+/**
+ * Integration Tests — PLAN → CHECK → IMP → REV full lifecycle
+ *
+ * Tests the complete workflow cycle to ensure data flows correctly
+ * between phases, knowledge propagates between tasks, and gates
+ * enforce constraints as expected.
+ */
+import { describe, it, expect, beforeEach } from "bun:test";
+import { getDb } from "../db/connection";
+import { initSchema } from "../db/schema";
+import { cleanDb } from "../db/test-helpers";
+import { planStart, planTaskAdd } from "./plan";
+import { checkRequest, checkApprove } from "./check";
+import { taskStart, taskDone, taskNext } from "./task";
+import { reviewStart, reviewApprove, calculateReviewScore } from "./review";
+import { processSubagentReturn } from "../protocol/process-return";
+import { validateGate } from "../gates/validator";
+
+// Helper: criar spec + tasks diretamente no DB (bypass console.log)
+function setupSpec(name: string, phase: string = "planning"): string {
+  const db = getDb();
+  const id = `test-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+  const now = new Date().toISOString();
+  db.run(
+    "INSERT INTO specs (id, name, phase, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
+    [id, name, phase, now, now]
+  );
+  db.run(
+    "INSERT INTO context (spec_id, objective, updated_at) VALUES (?, ?, ?)",
+    [id, name, now]
+  );
+  return id;
+}
+
+function addTask(specId: string, number: number, name: string, agent?: string, dependsOn?: number[]): number {
+  const db = getDb();
+  const deps = dependsOn && dependsOn.length > 0 ? JSON.stringify(dependsOn) : null;
+  db.run(
+    `INSERT INTO tasks (spec_id, number, name, agent, depends_on, can_parallel, status)
+     VALUES (?, ?, ?, ?, ?, 1, 'pending')`,
+    [specId, number, name, agent || null, deps]
+  );
+  const task = db.query(
+    "SELECT id FROM tasks WHERE spec_id = ? AND number = ?"
+  ).get(specId, number) as any;
+  return task.id;
+}
+
+function approveSpec(specId: string) {
+  const db = getDb();
+  const now = new Date().toISOString();
+  db.run(
+    "UPDATE specs SET phase = 'implementing', approved_at = ?, updated_at = ? WHERE id = ?",
+    [now, now, specId]
+  );
+}
+
+function startTask(taskId: number) {
+  const db = getDb();
+  const now = new Date().toISOString();
+  db.run("UPDATE tasks SET status = 'running', started_at = ? WHERE id = ?", [now, taskId]);
+}
+
+function completeTask(taskId: number, checkpoint: string) {
+  const db = getDb();
+  const now = new Date().toISOString();
+  db.run(
+    "UPDATE tasks SET status = 'done', checkpoint = ?, completed_at = ? WHERE id = ?",
+    [checkpoint, now, taskId]
+  );
+}
+
+// ============================================================
+// Tests
+// ============================================================
+
+beforeEach(() => {
+  initSchema();
+  cleanDb();
+});
+
+describe("PLAN → CHECK → IMP → REV lifecycle", () => {
+  it("should complete full lifecycle with knowledge propagation", () => {
+    const db = getDb();
+
+    // ──── PLAN ────
+    const specId = setupSpec("E2E Test Feature");
+    const task1Id = addTask(specId, 1, "Setup database schema", "backend-javascript");
+    const task2Id = addTask(specId, 2, "Create API endpoints", "backend-javascript", [1]);
+
+    // Update task count in context
+    db.run("UPDATE context SET total_tasks = 2, updated_at = ? WHERE spec_id = ?", [
+      new Date().toISOString(), specId,
+    ]);
+
+    // Verify plan exists
+    const spec = db.query("SELECT * FROM specs WHERE id = ?").get(specId) as any;
+    expect(spec.phase).toBe("planning");
+
+    // ──── CHECK ────
+    // Move to checking phase, then approve
+    db.run("UPDATE specs SET phase = 'checking', updated_at = ? WHERE id = ?", [
+      new Date().toISOString(), specId,
+    ]);
+    approveSpec(specId);
+
+    const approvedSpec = db.query("SELECT * FROM specs WHERE id = ?").get(specId) as any;
+    expect(approvedSpec.phase).toBe("implementing");
+    expect(approvedSpec.approved_at).toBeTruthy();
+
+    // ──── IMP Task 1 ────
+    startTask(task1Id);
+
+    const runningTask = db.query("SELECT * FROM tasks WHERE id = ?").get(task1Id) as any;
+    expect(runningTask.status).toBe("running");
+    expect(runningTask.started_at).toBeTruthy();
+
+    // Simulate subagent return for task 1
+    const subagentReturn1 = {
+      status: "completed" as const,
+      summary: "Created database schema with users and sessions tables",
+      files_created: ["src/db/schema.sql", "src/db/migrate.ts"],
+      files_modified: [],
+      reasoning: {
+        approach: "Used PostgreSQL with Drizzle ORM for type-safe database access and migrations",
+        challenges: ["Deciding between raw SQL and ORM migrations"],
+        alternatives: ["Prisma was considered but Drizzle is lighter"],
+        recommendations: "Use Drizzle push for dev, generate for prod migrations",
+      },
+      decisions_made: [
+        {
+          title: "Database ORM choice",
+          decision: "Use Drizzle ORM over Prisma",
+          rationale: "Drizzle is lighter, SQL-first, and better for PostgreSQL",
+        },
+      ],
+      knowledge_to_broadcast: [
+        {
+          category: "discovery" as const,
+          content: "Database uses pgcrypto extension for UUID generation",
+          severity: "warning" as const,
+        },
+        {
+          category: "pattern" as const,
+          content: "All tables have created_at and updated_at timestamps",
+          severity: "info" as const,
+        },
+      ],
+    };
+
+    const processResult1 = processSubagentReturn(specId, task1Id, 1, subagentReturn1);
+    expect(processResult1.success).toBe(true);
+    expect(processResult1.knowledgeAdded).toBe(2);
+    expect(processResult1.decisionsAdded).toBe(1);
+    expect(processResult1.artifactsAdded).toBe(2);
+    expect(processResult1.reasoningAdded).toBeGreaterThanOrEqual(3); // approach + challenge + alternative + recommendation
+
+    // Complete task 1
+    completeTask(task1Id, "Created database schema with users and sessions tables");
+
+    // Verify knowledge was stored
+    const knowledge = db.query(
+      "SELECT * FROM knowledge WHERE spec_id = ? ORDER BY created_at"
+    ).all(specId) as any[];
+    expect(knowledge.length).toBeGreaterThanOrEqual(2);
+
+    const warningKnowledge = knowledge.find(
+      (k: any) => k.severity === "warning" && k.content.includes("pgcrypto")
+    );
+    expect(warningKnowledge).toBeTruthy();
+
+    // Verify decisions were stored
+    const decisions = db.query(
+      "SELECT * FROM decisions WHERE spec_id = ?"
+    ).all(specId) as any[];
+    expect(decisions.length).toBe(1);
+    expect(decisions[0].title).toBe("Database ORM choice");
+
+    // Verify artifacts were stored
+    const artifacts = db.query(
+      "SELECT * FROM artifacts WHERE spec_id = ?"
+    ).all(specId) as any[];
+    expect(artifacts.length).toBe(2);
+
+    // Verify reasoning was logged
+    const reasoning = db.query(
+      "SELECT * FROM reasoning_log WHERE spec_id = ? AND task_id = ?"
+    ).all(specId, task1Id) as any[];
+    expect(reasoning.length).toBeGreaterThanOrEqual(3);
+
+    // Verify knowledge graph relations
+    const relations = db.query(
+      "SELECT * FROM knowledge_graph WHERE spec_id = ?"
+    ).all(specId) as any[];
+    expect(relations.length).toBeGreaterThan(0);
+
+    // ──── IMP Task 2 ────
+    // Task 2 depends on task 1 — verify dependencies gate passes
+    const task1Done = db.query("SELECT status FROM tasks WHERE id = ?").get(task1Id) as any;
+    expect(task1Done.status).toBe("done");
+
+    startTask(task2Id);
+
+    // Simulate subagent return for task 2
+    const subagentReturn2 = {
+      status: "completed" as const,
+      summary: "Created REST API endpoints for users CRUD with authentication",
+      files_created: ["src/api/users.ts", "src/api/auth.ts"],
+      files_modified: ["src/db/schema.sql"],
+      reasoning: {
+        approach: "Created Hono routes with middleware for authentication and input validation",
+      },
+      knowledge_to_broadcast: [
+        {
+          category: "discovery" as const,
+          content: "API uses rate limiting of 100 req/min per IP",
+          severity: "info" as const,
+        },
+      ],
+    };
+
+    const processResult2 = processSubagentReturn(specId, task2Id, 2, subagentReturn2);
+    expect(processResult2.success).toBe(true);
+    expect(processResult2.artifactsAdded).toBe(3); // 2 created + 1 modified (OR REPLACE)
+
+    completeTask(task2Id, "Created REST API endpoints for users CRUD with authentication");
+
+    // Verify total knowledge accumulated from both tasks
+    const allKnowledge = db.query(
+      "SELECT * FROM knowledge WHERE spec_id = ?"
+    ).all(specId) as any[];
+    expect(allKnowledge.length).toBeGreaterThanOrEqual(3); // 2 from task 1 + 1 from task 2
+
+    // ──── REV ────
+    // Move to reviewing phase
+    db.run("UPDATE specs SET phase = 'reviewing', updated_at = ? WHERE id = ?", [
+      new Date().toISOString(), specId,
+    ]);
+
+    // Calculate review score
+    const score = calculateReviewScore(specId);
+    expect(score.total).toBeGreaterThanOrEqual(50);
+    expect(score.breakdown.tasksCompleted).toBe(25); // All tasks done = full marks
+
+    // Verify all tasks are done
+    const pendingTasks = db.query(
+      "SELECT COUNT(*) as c FROM tasks WHERE spec_id = ? AND status != 'done'"
+    ).get(specId) as any;
+    expect(pendingTasks.c).toBe(0);
+  });
+
+  it("should propagate knowledge from task 1 to task 2 context", () => {
+    const db = getDb();
+
+    const specId = setupSpec("Knowledge Propagation Test");
+    const task1Id = addTask(specId, 1, "First task", "backend-javascript");
+    const task2Id = addTask(specId, 2, "Second task", "backend-javascript", [1]);
+
+    approveSpec(specId);
+    startTask(task1Id);
+
+    // Task 1 broadcasts critical knowledge
+    processSubagentReturn(specId, task1Id, 1, {
+      status: "completed",
+      summary: "Completed first task with important discovery",
+      files_created: ["src/first.ts"],
+      files_modified: [],
+      reasoning: { approach: "Implemented the first component using standard patterns" },
+      knowledge_to_broadcast: [
+        {
+          category: "discovery",
+          content: "CRITICAL: API requires authentication token in X-Auth header",
+          severity: "critical",
+        },
+      ],
+    });
+    completeTask(task1Id, "Done with first task");
+
+    // Verify knowledge exists
+    const criticalKnowledge = db.query(
+      "SELECT * FROM knowledge WHERE spec_id = ? AND severity = 'critical'"
+    ).all(specId) as any[];
+    expect(criticalKnowledge.length).toBeGreaterThanOrEqual(1);
+    expect(criticalKnowledge[0].content).toContain("X-Auth header");
+
+    // Knowledge should be visible for task 2
+    const task2Knowledge = db.query(
+      `SELECT * FROM knowledge WHERE spec_id = ? AND task_origin = ?`
+    ).all(specId, task1Id) as any[];
+    expect(task2Knowledge.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it("should deduplicate identical knowledge entries", () => {
+    const db = getDb();
+
+    const specId = setupSpec("Dedup Test");
+    const task1Id = addTask(specId, 1, "Task 1", "backend-javascript");
+    const task2Id = addTask(specId, 2, "Task 2", "backend-javascript");
+
+    approveSpec(specId);
+
+    // Both tasks broadcast the same knowledge
+    startTask(task1Id);
+    processSubagentReturn(specId, task1Id, 1, {
+      status: "completed",
+      summary: "First task done",
+      files_created: ["src/a.ts"],
+      files_modified: [],
+      reasoning: { approach: "Standard implementation approach used for component" },
+      knowledge_to_broadcast: [
+        { category: "discovery", content: "Uses UTF-8 encoding everywhere", severity: "info" },
+      ],
+    });
+    completeTask(task1Id, "Done");
+
+    startTask(task2Id);
+    processSubagentReturn(specId, task2Id, 2, {
+      status: "completed",
+      summary: "Second task done",
+      files_created: ["src/b.ts"],
+      files_modified: [],
+      reasoning: { approach: "Standard implementation approach used for second component" },
+      knowledge_to_broadcast: [
+        { category: "discovery", content: "Uses UTF-8 encoding everywhere", severity: "info" },
+      ],
+    });
+    completeTask(task2Id, "Done");
+
+    // Should only have 1 entry (deduplicated)
+    const entries = db.query(
+      "SELECT * FROM knowledge WHERE spec_id = ? AND content = 'Uses UTF-8 encoding everywhere'"
+    ).all(specId) as any[];
+    expect(entries.length).toBe(1);
+  });
+
+  it("should register decisions and detect conflicts", () => {
+    const db = getDb();
+
+    const specId = setupSpec("Decision Conflict Test");
+    const task1Id = addTask(specId, 1, "Task 1", "backend-javascript");
+    const task2Id = addTask(specId, 2, "Task 2", "backend-javascript");
+
+    approveSpec(specId);
+
+    // Task 1 decides to use Prisma
+    startTask(task1Id);
+    processSubagentReturn(specId, task1Id, 1, {
+      status: "completed",
+      summary: "Setup database with Prisma ORM for type-safe database access",
+      files_created: ["prisma/schema.prisma"],
+      files_modified: [],
+      reasoning: { approach: "Used Prisma for its excellent TypeScript integration and auto-generated types" },
+      decisions_made: [
+        { title: "ORM Selection", decision: "Use Prisma ORM", rationale: "Best TypeScript integration" },
+      ],
+    });
+    completeTask(task1Id, "Done with Prisma setup");
+
+    // Verify decision saved
+    const decisions = db.query(
+      "SELECT * FROM decisions WHERE spec_id = ? AND status = 'active'"
+    ).all(specId) as any[];
+    expect(decisions.length).toBe(1);
+    expect(decisions[0].decision).toContain("Prisma");
+  });
+});
+
+describe("Gate enforcement", () => {
+  it("should block task-done without checkpoint", () => {
+    const db = getDb();
+
+    const specId = setupSpec("Gate Test");
+    const taskId = addTask(specId, 1, "Test task");
+    approveSpec(specId);
+    startTask(taskId);
+
+    const result = validateGate("task-done", {
+      taskId,
+      checkpoint: "short",  // < 10 chars
+      files: [],
+    });
+    expect(result.passed).toBe(false);
+    expect(result.reason).toContain("Checkpoint");
+  });
+
+  it("should block task-start when dependencies are not done", () => {
+    const db = getDb();
+
+    const specId = setupSpec("Dependency Gate Test");
+    const task1Id = addTask(specId, 1, "First task");
+    const task2Id = addTask(specId, 2, "Second task", undefined, [1]);
+    approveSpec(specId);
+
+    // Task 1 is still pending
+    const result = validateGate("task-start", {
+      taskId: task2Id,
+      specId,
+    });
+    expect(result.passed).toBe(false);
+    expect(result.reason).toContain("Dependencias");
+  });
+
+  it("should pass task-start when dependencies are done", () => {
+    const db = getDb();
+
+    const specId = setupSpec("Dependency Pass Test");
+    const task1Id = addTask(specId, 1, "First task");
+    const task2Id = addTask(specId, 2, "Second task", undefined, [1]);
+    approveSpec(specId);
+
+    // Complete task 1
+    startTask(task1Id);
+    completeTask(task1Id, "First task completed successfully");
+
+    const result = validateGate("task-start", {
+      taskId: task2Id,
+      specId,
+    });
+    expect(result.passed).toBe(true);
+  });
+
+  it("should block review-start when tasks are pending", () => {
+    const specId = setupSpec("Review Gate Test");
+    addTask(specId, 1, "Incomplete task");
+    approveSpec(specId);
+
+    const result = validateGate("review-start", { specId });
+    expect(result.passed).toBe(false);
+    expect(result.reason).toContain("Tasks pendentes");
+  });
+
+  it("should pass review-start when all tasks are done", () => {
+    const specId = setupSpec("Review Pass Test");
+    const taskId = addTask(specId, 1, "Only task");
+    approveSpec(specId);
+    startTask(taskId);
+    completeTask(taskId, "Completed the only task successfully");
+
+    const result = validateGate("review-start", { specId });
+    expect(result.passed).toBe(true);
+  });
+
+  it("should require reasoning for completed subagent returns", () => {
+    const specId = setupSpec("Reasoning Gate Test");
+    const taskId = addTask(specId, 1, "Reasoning task");
+    approveSpec(specId);
+    startTask(taskId);
+
+    const result = validateGate("task-done", {
+      taskId,
+      checkpoint: "This is a valid checkpoint text",
+      files: [],
+      subagentData: {
+        status: "completed",
+        summary: "Done",
+        files_created: [],
+        files_modified: [],
+        reasoning: { approach: "short" },  // < 20 chars
+      },
+    });
+    expect(result.passed).toBe(false);
+    expect(result.reason).toContain("reasoning");
+  });
+});
+
+describe("files-exist gate with sandbox", () => {
+  it("should pass when subagent reports files that dont exist on disk", () => {
+    const specId = setupSpec("Sandbox Files Test");
+    const taskId = addTask(specId, 1, "Sandbox task");
+    approveSpec(specId);
+    startTask(taskId);
+
+    const result = validateGate("task-done", {
+      taskId,
+      checkpoint: "Completed sandbox task with new files created",
+      files: ["src/sandbox/nonexistent-file.ts"],
+      subagentData: {
+        status: "completed",
+        summary: "Created file in sandbox",
+        files_created: ["src/sandbox/nonexistent-file.ts"],
+        files_modified: [],
+        reasoning: { approach: "Created the file using standard TypeScript patterns and conventions" },
+      },
+    });
+    expect(result.passed).toBe(true);
+  });
+
+  it("should fail when file not on disk and not from subagent", () => {
+    const specId = setupSpec("Missing File Test");
+    const taskId = addTask(specId, 1, "Missing file task");
+    approveSpec(specId);
+    startTask(taskId);
+
+    const result = validateGate("task-done", {
+      taskId,
+      checkpoint: "Completed missing file task properly",
+      files: ["src/this-file-definitely-does-not-exist-xyz.ts"],
+      // No subagentData — file should exist on disk
+    });
+    expect(result.passed).toBe(false);
+    expect(result.reason).toContain("nao encontrado");
+  });
+
+  it("should pass when subagent reports mix of existing and sandbox files", () => {
+    const db = getDb();
+    const specId = setupSpec("Mixed Files Test");
+    const taskId = addTask(specId, 1, "Mixed files task");
+    approveSpec(specId);
+
+    // Set started_at far in the past so mtime check passes for existing file
+    const pastTime = new Date(Date.now() - 365 * 24 * 60 * 60 * 1000).toISOString();
+    db.run("UPDATE tasks SET status = 'running', started_at = ? WHERE id = ?", [pastTime, taskId]);
+
+    // Use a file that actually exists (this test file itself)
+    const existingFile = import.meta.path;
+
+    const result = validateGate("task-done", {
+      taskId,
+      checkpoint: "Completed mixed files task with both types",
+      files: [existingFile, "src/sandbox/new-file.ts"],
+      subagentData: {
+        status: "completed",
+        summary: "Modified existing and created new file",
+        files_created: ["src/sandbox/new-file.ts"],
+        files_modified: [existingFile],
+        reasoning: { approach: "Modified existing file and created new file for component" },
+      },
+    });
+    // The existing file passes validation, the sandbox file is trusted via subagent
+    expect(result.passed).toBe(true);
+  });
+});
+
+describe("Review scoring", () => {
+  it("should calculate perfect score when all tasks done and no bypasses", () => {
+    const db = getDb();
+
+    const specId = setupSpec("Perfect Score Test");
+    const task1Id = addTask(specId, 1, "Task 1");
+    const task2Id = addTask(specId, 2, "Task 2");
+    approveSpec(specId);
+
+    // Complete both tasks
+    startTask(task1Id);
+    completeTask(task1Id, "Task 1 done perfectly");
+    startTask(task2Id);
+    completeTask(task2Id, "Task 2 done perfectly");
+
+    // Register some artifacts
+    db.run(
+      "INSERT INTO artifacts (spec_id, task_ref, path, action) VALUES (?, 1, 'src/a.ts', 'created')",
+      [specId]
+    );
+    db.run(
+      "INSERT INTO artifacts (spec_id, task_ref, path, action) VALUES (?, 2, 'src/b.ts', 'created')",
+      [specId]
+    );
+
+    const score = calculateReviewScore(specId);
+    expect(score.breakdown.tasksCompleted).toBe(25);
+    expect(score.breakdown.gatesPassedClean).toBe(25);
+    expect(score.breakdown.standardsFollowed).toBe(25);
+    expect(score.total).toBeGreaterThanOrEqual(75); // files_delivered depends on planned vs created
+    expect(score.autoApproveEligible).toBe(true);
+    expect(score.mustReviewItems.length).toBe(0);
+  });
+
+  it("should reduce score when gates are bypassed", () => {
+    const db = getDb();
+
+    const specId = setupSpec("Bypass Score Test");
+    const taskId = addTask(specId, 1, "Bypassed task");
+    approveSpec(specId);
+
+    startTask(taskId);
+    completeTask(taskId, "Done with bypasses");
+
+    // Register a critical bypass
+    db.run(
+      "INSERT INTO gate_bypasses (spec_id, task_id, gate_name, reason) VALUES (?, ?, 'standards-follow', 'Test bypass')",
+      [specId, taskId]
+    );
+
+    const score = calculateReviewScore(specId);
+    expect(score.breakdown.gatesPassedClean).toBeLessThan(25);
+    expect(score.breakdown.standardsFollowed).toBeLessThan(25);
+    expect(score.autoApproveEligible).toBe(false); // Critical bypass
+    expect(score.mustReviewItems.length).toBeGreaterThan(0);
+  });
+});
+
+describe("processSubagentReturn", () => {
+  it("should handle blocked status with blockers as critical knowledge", () => {
+    const db = getDb();
+
+    const specId = setupSpec("Blocked Task Test");
+    const taskId = addTask(specId, 1, "Blocked task");
+    approveSpec(specId);
+    startTask(taskId);
+
+    const result = processSubagentReturn(specId, taskId, 1, {
+      status: "blocked",
+      summary: "Blocked by missing API key configuration",
+      files_created: [],
+      files_modified: [],
+      blockers: [
+        "Missing API key for external service",
+        "Configuration file not found at expected path",
+      ],
+    });
+
+    expect(result.knowledgeAdded).toBe(2);
+    expect(result.artifactsAdded).toBe(0);
+
+    // Verify blockers stored as critical knowledge
+    const blockers = db.query(
+      "SELECT * FROM knowledge WHERE spec_id = ? AND category = 'blocker' AND severity = 'critical'"
+    ).all(specId) as any[];
+    expect(blockers.length).toBe(2);
+  });
+
+  it("should store all artifacts from files_created and files_modified", () => {
+    const db = getDb();
+
+    const specId = setupSpec("Artifacts Test");
+    const taskId = addTask(specId, 1, "Artifact task");
+    approveSpec(specId);
+    startTask(taskId);
+
+    const result = processSubagentReturn(specId, taskId, 1, {
+      status: "completed",
+      summary: "Created and modified multiple files for the feature",
+      files_created: ["src/new1.ts", "src/new2.ts"],
+      files_modified: ["src/existing.ts"],
+      reasoning: { approach: "Created two new files and modified one existing file for the feature" },
+    });
+
+    expect(result.artifactsAdded).toBe(3);
+
+    const artifacts = db.query(
+      "SELECT * FROM artifacts WHERE spec_id = ? ORDER BY path"
+    ).all(specId) as any[];
+    expect(artifacts.length).toBe(3);
+
+    const created = artifacts.filter((a: any) => a.action === "created");
+    const modified = artifacts.filter((a: any) => a.action === "modified");
+    expect(created.length).toBe(2);
+    expect(modified.length).toBe(1);
+  });
+
+  it("should build knowledge graph relations", () => {
+    const db = getDb();
+
+    const specId = setupSpec("Graph Test");
+    const taskId = addTask(specId, 1, "Graph task");
+    approveSpec(specId);
+    startTask(taskId);
+
+    processSubagentReturn(specId, taskId, 1, {
+      status: "completed",
+      summary: "Created files with patterns for the component",
+      files_created: ["src/api.ts"],
+      files_modified: ["src/config.ts"],
+      reasoning: { approach: "Implemented API endpoint following existing patterns in the project" },
+      patterns_discovered: ["REST endpoint pattern"],
+    });
+
+    const relations = db.query(
+      "SELECT * FROM knowledge_graph WHERE spec_id = ?"
+    ).all(specId) as any[];
+
+    // Should have: task->api.ts(creates), task->config.ts(modifies),
+    //              pattern->api.ts(extracted_from)
+    const creates = relations.filter((r: any) => r.relation === "creates");
+    const modifies = relations.filter((r: any) => r.relation === "modifies");
+    const extracted = relations.filter((r: any) => r.relation === "extracted_from");
+
+    expect(creates.length).toBe(1);
+    expect(modifies.length).toBe(1);
+    expect(extracted.length).toBe(1);
+  });
+});
+
+describe("Multi-spec parallel", () => {
+  it("should allow multiple specs to coexist", () => {
+    const db = getDb();
+
+    const specA = setupSpec("Feature A");
+    const specB = setupSpec("Feature B");
+
+    addTask(specA, 1, "Task A1");
+    addTask(specB, 1, "Task B1");
+
+    // Both should exist
+    const specs = db.query(
+      "SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled')"
+    ).all() as any[];
+    expect(specs.length).toBe(2);
+
+    // Tasks should be isolated per spec
+    const tasksA = db.query("SELECT * FROM tasks WHERE spec_id = ?").all(specA) as any[];
+    const tasksB = db.query("SELECT * FROM tasks WHERE spec_id = ?").all(specB) as any[];
+    expect(tasksA.length).toBe(1);
+    expect(tasksB.length).toBe(1);
+  });
+
+  it("should isolate knowledge per spec", () => {
+    const db = getDb();
+
+    const specA = setupSpec("Feature A");
+    const specB = setupSpec("Feature B");
+    const taskA = addTask(specA, 1, "Task A1");
+    const taskB = addTask(specB, 1, "Task B1");
+
+    approveSpec(specA);
+    approveSpec(specB);
+    startTask(taskA);
+    startTask(taskB);
+
+    processSubagentReturn(specA, taskA, 1, {
+      status: "completed",
+      summary: "Done with Feature A task and found important info",
+      files_created: ["src/a.ts"],
+      files_modified: [],
+      reasoning: { approach: "Standard implementation of feature A component" },
+      knowledge_to_broadcast: [
+        { category: "discovery", content: "Knowledge from Feature A", severity: "info" },
+      ],
+    });
+
+    processSubagentReturn(specB, taskB, 1, {
+      status: "completed",
+      summary: "Done with Feature B task and found other info",
+      files_created: ["src/b.ts"],
+      files_modified: [],
+      reasoning: { approach: "Standard implementation of feature B component" },
+      knowledge_to_broadcast: [
+        { category: "discovery", content: "Knowledge from Feature B", severity: "info" },
+      ],
+    });
+
+    const knowledgeA = db.query(
+      "SELECT * FROM knowledge WHERE spec_id = ?"
+    ).all(specA) as any[];
+    const knowledgeB = db.query(
+      "SELECT * FROM knowledge WHERE spec_id = ?"
+    ).all(specB) as any[];
+
+    expect(knowledgeA.length).toBeGreaterThanOrEqual(1);
+    expect(knowledgeB.length).toBeGreaterThanOrEqual(1);
+    expect(knowledgeA[0].content).toContain("Feature A");
+    expect(knowledgeB[0].content).toContain("Feature B");
+  });
+});