feat: wire genome into autopilot and coordinator

Autopilot integration:
- Loads genome manifest at start
- Retrieves task-relevant genome sections for sub-agent context
- Proposes genome updates after completing work items
- Evaluates genome fitness every 10 ticks
- Auto-advances generation when milestone completes
- Extracts next milestone from backlog

Coordinator integration:
- Retrieves genome sections for batch task descriptions
- Injects genome context into all sub-agent system prompts
- Proposes knowledge updates after coordinator completes

All integration is gracefully optional — genome not required.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: masonwyatt23

src/agent/autopilot-loop.ts

@@ -27,6 +27,7 @@ import { sleep } from "./error-handler.ts";
 import type { ProviderRouter } from "../providers/router.ts";
 import type { ToolRegistry } from "../tools/registry.ts";
 import type { ToolContext } from "../tools/types.ts";
+import type { GenomeManifest } from "../genome/manifest.ts";
 
 /* ── Vision interface (inline until vision.ts exists) ──────────── */
 
@@ -176,6 +177,7 @@ export class AutopilotLoop {
   private config!: AutopilotConfig;
   private lastScanHash = "";
   private focusState: FocusState = "unknown";
+  private genome: GenomeManifest | null = null;
 
   /* ── Public API ────────────────────────────────────────────── */
 
@@ -193,6 +195,14 @@ export class AutopilotLoop {
     this.queue = new WorkQueue(config.toolContext.cwd);
     await this.queue.load();
 
+    // Load genome if available — enhances agent context and enables auto-evolution
+    try {
+      const { loadManifest } = await import("../genome/manifest.ts");
+      this.genome = await loadManifest(config.toolContext.cwd);
+    } catch {
+      this.genome = null;
+    }
+
     config.onProgress?.({ type: "started", goal: vision.goal });
 
     await this.runLoop();
@@ -263,13 +273,22 @@ export class AutopilotLoop {
           break;
         }
 
-        // Step 3: Re-assess vision (every 5 ticks)
+        // Step 3: Re-assess vision (every 5 ticks) + genome evolution
         if (this.tickNumber % 5 === 0) {
           const complete = await this.assessVision();
           if (complete) {
+            // If genome exists, end generation and advance before wrapping up
+            if (this.genome) {
+              await this.advanceGeneration();
+            }
             this.wrapUpRequested = true;
             continue; // Next iteration will handle wrap-up
           }
+
+          // Evaluate genome fitness periodically (every 10 ticks)
+          if (this.genome && this.tickNumber % 10 === 0) {
+            await this.evaluateGenomeFitness();
+          }
         }
 
         // Step 4: Scan for new work (every 3 ticks)
@@ -639,10 +658,27 @@ Reply with JSON only: {"focusAreas": ["..."], "assessment": "...", "isComplete":
       itemDescription: item.title,
     });
 
+    // Build context with genome sections if available
+    let genomeContext = "";
+    if (this.genome) {
+      try {
+        const { retrieveSections, formatGenomeForPrompt } = await import("../genome/retriever.ts");
+        const sections = await retrieveSections(
+          this.config.toolContext.cwd,
+          `${item.title} ${item.description}`,
+          4000,
+        );
+        genomeContext = formatGenomeForPrompt(sections);
+      } catch {
+        // Genome retrieval failed — continue without
+      }
+    }
+
     const contextPrompt = [
       `## Vision`,
       `Goal: ${this.vision.goal}`,
       `Focus areas: ${this.vision.focusAreas.join(", ") || "none"}`,
+      genomeContext ? `\n${genomeContext}` : "",
       ``,
       `## Task`,
       `${item.title}: ${item.description}`,
@@ -791,6 +827,23 @@ Reply with JSON only: {"focusAreas": ["..."], "assessment": "...", "isComplete":
       if (this.vision.progress.length > 50) {
         this.vision.progress = this.vision.progress.slice(-50);
       }
+
+      // Propose genome progress update if genome exists
+      if (this.genome) {
+        try {
+          const { proposeUpdate } = await import("../genome/scribe.ts");
+          await proposeUpdate(this.config.toolContext.cwd, {
+            agentId: "autopilot",
+            section: "knowledge/discoveries.md",
+            operation: "append",
+            content: `- [${new Date().toISOString().split("T")[0]}] Tick ${this.tickNumber}: ${this.itemsCompleted} completed, ${this.itemsFailed} failed`,
+            rationale: "Autopilot progress update",
+            generation: this.genome.generation.number,
+          });
+        } catch {
+          // Genome proposal failed — not critical
+        }
+      }
     }
 
     // Notify user if terminal unfocused
@@ -805,6 +858,64 @@ Reply with JSON only: {"focusAreas": ["..."], "assessment": "...", "isComplete":
     }
   }
 
+  /* ── Genome integration ──────────────────────────────────────── */
+
+  /**
+   * Evaluate genome fitness and consolidate pending proposals.
+   */
+  private async evaluateGenomeFitness(): Promise<void> {
+    try {
+      const { evaluateGeneration, formatGenerationReport } = await import("../genome/generations.ts");
+      const { consolidateProposals } = await import("../genome/scribe.ts");
+      const cwd = this.config.toolContext.cwd;
+
+      // First consolidate any pending proposals
+      await consolidateProposals(cwd, this.config.router);
+
+      // Then evaluate fitness
+      const report = await evaluateGeneration(cwd, this.config.router);
+
+      this.config.onProgress?.({
+        type: "notification",
+        title: "Genome Fitness",
+        body: `Gen ${report.generation}: ${(report.fitness.milestoneProgress * 100).toFixed(0)}% milestone, ${report.mutations} mutations`,
+      });
+    } catch {
+      // Genome evaluation failed — not critical
+    }
+  }
+
+  /**
+   * End the current generation and start the next one.
+   */
+  private async advanceGeneration(): Promise<void> {
+    try {
+      const { endGeneration, startGeneration } = await import("../genome/generations.ts");
+      const { loadManifest } = await import("../genome/manifest.ts");
+      const { readSection } = await import("../genome/manifest.ts");
+      const cwd = this.config.toolContext.cwd;
+
+      await endGeneration(cwd);
+
+      // Check backlog for next milestone
+      const backlog = await readSection(cwd, "milestones/backlog.md");
+      const nextMilestone = backlog
+        ? extractFirstMilestone(backlog)
+        : "Continue development";
+
+      const genNum = await startGeneration(cwd, nextMilestone);
+      this.genome = await loadManifest(cwd);
+
+      this.config.onProgress?.({
+        type: "notification",
+        title: "Generation Advanced",
+        body: `Generation ${genNum}: ${nextMilestone}`,
+      });
+    } catch {
+      // Generation advance failed — not critical
+    }
+  }
+
   /* ── Step 10: Abortable sleep ──────────────────────────────── */
 
   private async abortableSleep(ms: number): Promise<void> {
@@ -833,3 +944,17 @@ export function createAutopilotLoop(): AutopilotLoop {
   _instance = new AutopilotLoop();
   return _instance;
 }
+
+/**
+ * Extract the first milestone from a backlog markdown file.
+ * Looks for the first ## heading or first bullet point.
+ */
+function extractFirstMilestone(backlog: string): string {
+  for (const line of backlog.split("\n")) {
+    const heading = line.match(/^##\s+(.+)/);
+    if (heading) return heading[1]!.trim();
+    const bullet = line.match(/^[-*]\s+(.+)/);
+    if (bullet) return bullet[1]!.trim();
+  }
+  return "Continue development";
+}

src/agent/coordinator.ts

@@ -373,6 +373,20 @@ async function dispatchTasks(
     for (let batch = 0; batch < wave.length; batch += maxParallel) {
       const batchTasks = wave.slice(batch, batch + maxParallel);
 
+      // Retrieve genome context for task-relevant section injection
+      let genomeContext = "";
+      try {
+        const { genomeExists } = await import("../genome/manifest.ts");
+        if (genomeExists(config.toolContext.cwd)) {
+          const { retrieveSections, formatGenomeForPrompt } = await import("../genome/retriever.ts");
+          const taskDescriptions = batchTasks.map((t) => t.description).join(" ");
+          const sections = await retrieveSections(config.toolContext.cwd, taskDescriptions, 3000);
+          genomeContext = formatGenomeForPrompt(sections);
+        }
+      } catch {
+        // Genome not available — continue without
+      }
+
       const agentConfigs: SubAgentConfig[] = batchTasks.map((task) => {
         const teammate = team ? pickTeammateForTask(team, task.role) : null;
         const agentName = teammate?.name ?? `${task.role}-${task.id}`;
@@ -386,10 +400,13 @@ async function dispatchTasks(
           agentName,
         });
 
+        const promptParts = [config.systemPrompt, agentPrompt];
+        if (genomeContext) promptParts.push(genomeContext);
+
         return {
           name: agentName,
           prompt: task.description,
-          systemPrompt: config.systemPrompt + "\n\n" + agentPrompt,
+          systemPrompt: promptParts.join("\n\n"),
           router: config.router,
           toolRegistry: config.toolRegistry,
           toolContext: config.toolContext,
@@ -501,6 +518,33 @@ export async function coordinate(
 
   config.onProgress?.({ type: "complete", summary });
 
+  // Propose genome update with coordinator findings
+  try {
+    const { genomeExists, loadManifest } = await import("../genome/manifest.ts");
+    if (genomeExists(config.toolContext.cwd)) {
+      const { proposeUpdate } = await import("../genome/scribe.ts");
+      const manifest = await loadManifest(config.toolContext.cwd);
+      if (manifest) {
+        const findings = taskResults
+          .filter((t) => t.success)
+          .map((t) => `- ${t.summary?.slice(0, 100) ?? "Task completed"}`)
+          .join("\n");
+        if (findings) {
+          await proposeUpdate(config.toolContext.cwd, {
+            agentId: "coordinator",
+            section: "knowledge/discoveries.md",
+            operation: "append",
+            content: `## Coordinator run: ${goal.slice(0, 80)}\n${findings}`,
+            rationale: `Coordinator completed ${successCount}/${taskResults.length} tasks for: ${goal.slice(0, 100)}`,
+            generation: manifest.generation.number,
+          });
+        }
+      }
+    }
+  } catch {
+    // Genome proposal failed — not critical
+  }
+
   return { tasks: taskResults, verificationPassed, summary };
 }