feat(autonomy): Phase 2 Continuous Learning Pipeline — GitPoller + AUTO-03/04

- GitPoller (src/history/git-poller.ts): polls CommitIngester.ingestLatest every
  30s in production; emits commits event when new commits detected (AUTO-03)
- BackgroundAutonomyService: wires GitPoller via optional gitPollIntervalMs param
  (null = disabled, safe for fake-timer tests); server.ts passes 30_000 (AUTO-04)
- 8 new tests in git-poller.test.ts: poll/event/error/start/stop/idempotent
- 122/122 tests green

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

Author: Aitomates

universal-refiner/src/core/background-service.ts

@@ -2,23 +2,35 @@ import * as chokidar from 'chokidar';
 import { CommitIngester } from "../history/commit-ingest.js";
 import { LessonExtractor } from "../history/lesson-extractor.js";
 import { CorrelationEngine } from "../history/correlation-engine.js";
+import { GitPoller } from "../history/git-poller.js";
 import { RuntimeLogger } from "./logger.js";
 import { CommandCenterDashboard } from "./dashboard.js";
 import { SerializedJobQueue } from "./job-queue.js";
 
 export class BackgroundAutonomyService {
   private watcher: chokidar.FSWatcher | null = null;
+  private gitPoller: GitPoller | null = null;
   private debounceTimer: NodeJS.Timeout | null = null;
   private rootPath: string;
   private requestModelText: (taskName: string, userPrompt: string, maxTokens: number) => Promise<string | null>;
   private queue = new SerializedJobQueue();
 
+  /**
+   * @param gitPollIntervalMs — pass a number (ms) to enable git polling (AUTO-03).
+   *   Defaults to null (disabled) so tests that use vi.runAllTimersAsync() are not
+   *   affected by an infinite setInterval.  The production server passes 30_000.
+   */
   constructor(
     rootPath: string,
-    requestModelText: (taskName: string, userPrompt: string, maxTokens: number) => Promise<string | null>
+    requestModelText: (taskName: string, userPrompt: string, maxTokens: number) => Promise<string | null>,
+    gitPollIntervalMs: number | null = null,
   ) {
     this.rootPath = rootPath;
     this.requestModelText = requestModelText;
+    if (gitPollIntervalMs !== null) {
+      this.gitPoller = new GitPoller(rootPath, gitPollIntervalMs);
+      this.gitPoller.on("commits", () => this.triggerAutonomy());
+    }
   }
 
   public start() {
@@ -41,11 +53,11 @@ export class BackgroundAutonomyService {
     });
 
     this.watcher.on('all', (event, filePath) => {
-      // Don't log every single file change to dashboard to avoid noise, but log to RuntimeLogger
       RuntimeLogger.debug(`File change detected: ${event} ${filePath}`);
       this.triggerAutonomy();
     });
 
+    this.gitPoller?.start();
     this.queue.enqueue(`autonomy:${this.rootPath}`, () => this.runCycles());
   }
 
@@ -65,9 +77,6 @@ export class BackgroundAutonomyService {
   private async runCycles() {
     try {
       CommandCenterDashboard.log("Background Autonomy: Change detected. Triggering intelligence cycles...");
-      
-      // a) CommitIngester.ingestLatest()
-      // We increase the limit significantly because the ingester now fetches only since last SHA
       const ingestedCount = await CommitIngester.ingestLatest(this.rootPath, 100);
       CommandCenterDashboard.log(`Background Autonomy: Ingested ${ingestedCount} commits.`);
 
@@ -93,6 +102,7 @@ export class BackgroundAutonomyService {
       clearTimeout(this.debounceTimer);
       this.debounceTimer = null;
     }
+    this.gitPoller?.stop();
   }
 
   public async idle() {

universal-refiner/src/core/server.ts

@@ -737,7 +737,8 @@ Output ONLY the JSON array. If no gaps, return [].`,
     // Start Background Autonomy
     this.backgroundAutonomy = new BackgroundAutonomyService(
       this.rootPath,
-      this.requestModelText.bind(this)
+      this.requestModelText.bind(this),
+      30_000, // AUTO-03: poll git every 30s
     );
     this.backgroundAutonomy.start();
 

universal-refiner/src/history/git-poller.ts

@@ -0,0 +1,74 @@
+import { EventEmitter } from "node:events";
+import { CommitIngester } from "./commit-ingest.js";
+import { RuntimeLogger } from "../core/logger.js";
+import { CommandCenterDashboard } from "../core/dashboard.js";
+
+export const DEFAULT_POLL_INTERVAL_MS = 30_000;
+
+/**
+ * GitPoller satisfies AUTO-03: continuously monitors a git repository for new
+ * commits on a configurable interval, independent of file system events.
+ *
+ * Emits "commits" with the count of newly ingested commits whenever the poll
+ * detects work. Consumers (BackgroundAutonomyService) subscribe to "commits"
+ * to trigger the full learning pipeline (AUTO-04).
+ */
+export class GitPoller extends EventEmitter {
+  private readonly repoPath: string;
+  private readonly intervalMs: number;
+  private timer: NodeJS.Timeout | null = null;
+  private running = false;
+
+  constructor(repoPath: string, intervalMs = DEFAULT_POLL_INTERVAL_MS) {
+    super();
+    this.repoPath = repoPath;
+    this.intervalMs = intervalMs;
+  }
+
+  /** Start polling. Idempotent — calling twice is a no-op. */
+  public start(): void {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    RuntimeLogger.info("[GitPoller] Starting git commit polling", {
+      repoPath: this.repoPath,
+      intervalMs: this.intervalMs,
+    });
+    CommandCenterDashboard.log(`Background Autonomy: Git polling every ${this.intervalMs / 1000}s.`);
+    this.timer = setInterval(() => void this.poll(), this.intervalMs);
+  }
+
+  /** Stop polling and release the interval. */
+  public stop(): void {
+    if (!this.running) {
+      return;
+    }
+    this.running = false;
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    RuntimeLogger.info("[GitPoller] Stopped git commit polling");
+  }
+
+  /**
+   * One-shot poll: ingest any new commits. If new commits are found, emits
+   * "commits" with the count so subscribers can trigger downstream pipelines.
+   * Safe to call externally for an immediate check.
+   */
+  public async poll(): Promise<number> {
+    try {
+      const count = await CommitIngester.ingestLatest(this.repoPath, 50);
+      if (count > 0) {
+        RuntimeLogger.debug(`[GitPoller] Ingested ${count} new commit(s)`, { repoPath: this.repoPath });
+        CommandCenterDashboard.log(`Background Autonomy: ${count} new commit(s) detected.`);
+        this.emit("commits", count);
+      }
+      return count;
+    } catch (err) {
+      RuntimeLogger.error("[GitPoller] Poll failed", err);
+      return 0;
+    }
+  }
+}

universal-refiner/tests/background-service.test.ts

@@ -0,0 +1,63 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  watcher: { on: vi.fn(), close: vi.fn() },
+  watch: vi.fn(),
+  ingest: vi.fn(),
+  correlate: vi.fn(),
+  extract: vi.fn(),
+  info: vi.fn(),
+  debug: vi.fn(),
+  error: vi.fn(),
+  dashboard: vi.fn(),
+}));
+
+vi.mock("chokidar", () => ({ watch: mocks.watch }));
+vi.mock("../src/history/commit-ingest.js", () => ({ CommitIngester: { ingestLatest: mocks.ingest } }));
+vi.mock("../src/history/correlation-engine.js", () => ({ CorrelationEngine: class { correlateAll = mocks.correlate; } }));
+vi.mock("../src/history/lesson-extractor.js", () => ({ LessonExtractor: class { extractNewLessons = mocks.extract; } }));
+vi.mock("../src/core/logger.js", () => ({ RuntimeLogger: { info: mocks.info, debug: mocks.debug, error: mocks.error } }));
+vi.mock("../src/core/dashboard.js", () => ({ CommandCenterDashboard: { log: mocks.dashboard } }));
+
+import { BackgroundAutonomyService } from "../src/core/background-service.js";
+
+describe("BackgroundAutonomyService", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.watch.mockReturnValue(mocks.watcher);
+    mocks.watcher.on.mockReturnValue(mocks.watcher);
+    mocks.ingest.mockResolvedValue(2);
+    mocks.correlate.mockResolvedValue(undefined);
+    mocks.extract.mockResolvedValue(undefined);
+  });
+
+  it("starts once, runs the initial serialized cycle, and stops the watcher", async () => {
+    const service = new BackgroundAutonomyService("C:/repo", vi.fn());
+    service.start();
+    service.start();
+    await service.idle();
+    service.stop();
+
+    expect(mocks.watch).toHaveBeenCalledTimes(1);
+    expect(mocks.ingest).toHaveBeenCalledWith("C:/repo", 100);
+    expect(mocks.correlate).toHaveBeenCalledBefore(mocks.extract);
+    expect(mocks.watcher.close).toHaveBeenCalledOnce();
+  });
+
+  it("debounces file changes and logs cycle failures for queue retries", async () => {
+    vi.useFakeTimers();
+    mocks.correlate.mockRejectedValue(new Error("correlation failed"));
+    const service = new BackgroundAutonomyService("C:/repo", vi.fn());
+    service.start();
+    const changeHandler = mocks.watcher.on.mock.calls.find(call => call[0] === "all")?.[1];
+    changeHandler("change", "src/a.ts");
+    changeHandler("change", "src/b.ts");
+    await vi.runAllTimersAsync();
+    await service.idle();
+    service.stop();
+    vi.useRealTimers();
+
+    expect(mocks.debug).toHaveBeenCalledWith(expect.stringContaining("src/b.ts"));
+    expect(mocks.error).toHaveBeenCalledWith("Background Autonomy cycle failed", expect.any(Error));
+  });
+});

universal-refiner/tests/git-poller.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { GitPoller } from "../src/history/git-poller.js";
+import { CommitIngester } from "../src/history/commit-ingest.js";
+
+// ---------------------------------------------------------------------------
+// Stub CommitIngester so tests don't touch the real DB / git log
+// ---------------------------------------------------------------------------
+
+vi.mock("../src/history/commit-ingest.js", () => ({
+  CommitIngester: {
+    ingestLatest: vi.fn(),
+  },
+}));
+
+vi.mock("../src/core/logger.js", () => ({
+  RuntimeLogger: { info: vi.fn(), debug: vi.fn(), error: vi.fn() },
+}));
+
+vi.mock("../src/core/dashboard.js", () => ({
+  CommandCenterDashboard: { log: vi.fn() },
+}));
+
+const ingestLatest = vi.mocked(CommitIngester.ingestLatest);
+
+// ---------------------------------------------------------------------------
+// Suite
+// ---------------------------------------------------------------------------
+
+describe("GitPoller", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    ingestLatest.mockResolvedValue(0);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.clearAllMocks();
+  });
+
+  // -------------------------------------------------------------------------
+  // AUTO-03: poll() calls CommitIngester.ingestLatest
+  // -------------------------------------------------------------------------
+
+  it("poll() calls CommitIngester.ingestLatest with the repo path (AUTO-03)", async () => {
+    const poller = new GitPoller("/repo");
+    await poller.poll();
+    expect(ingestLatest).toHaveBeenCalledWith("/repo", 50);
+  });
+
+  // -------------------------------------------------------------------------
+  // AUTO-04: emits "commits" when new commits found
+  // -------------------------------------------------------------------------
+
+  it("emits 'commits' event when ingestLatest returns > 0 (AUTO-04)", async () => {
+    ingestLatest.mockResolvedValue(3);
+    const poller = new GitPoller("/repo");
+    const handler = vi.fn();
+    poller.on("commits", handler);
+
+    await poller.poll();
+
+    expect(handler).toHaveBeenCalledWith(3);
+  });
+
+  it("does NOT emit 'commits' when ingestLatest returns 0", async () => {
+    ingestLatest.mockResolvedValue(0);
+    const poller = new GitPoller("/repo");
+    const handler = vi.fn();
+    poller.on("commits", handler);
+
+    await poller.poll();
+
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  // -------------------------------------------------------------------------
+  // poll() return value
+  // -------------------------------------------------------------------------
+
+  it("poll() returns the count from ingestLatest", async () => {
+    ingestLatest.mockResolvedValue(7);
+    const poller = new GitPoller("/repo");
+    const count = await poller.poll();
+    expect(count).toBe(7);
+  });
+
+  it("poll() returns 0 and does not throw when ingestLatest rejects", async () => {
+    ingestLatest.mockRejectedValue(new Error("git failure"));
+    const poller = new GitPoller("/repo");
+    const count = await poller.poll();
+    expect(count).toBe(0);
+  });
+
+  // -------------------------------------------------------------------------
+  // AUTO-03: start() triggers polling on interval
+  // -------------------------------------------------------------------------
+
+  it("start() triggers poll at the configured interval", async () => {
+    const poller = new GitPoller("/repo", 1000);
+    poller.start();
+
+    await vi.advanceTimersByTimeAsync(2100);
+    poller.stop();
+
+    expect(ingestLatest.mock.calls.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("start() is idempotent — calling twice does not double the interval", async () => {
+    const poller = new GitPoller("/repo", 1000);
+    poller.start();
+    poller.start();
+
+    await vi.advanceTimersByTimeAsync(1000);
+    poller.stop();
+
+    // One interval fired exactly once
+    expect(ingestLatest.mock.calls.length).toBe(1);
+  });
+
+  // -------------------------------------------------------------------------
+  // stop() clears the interval
+  // -------------------------------------------------------------------------
+
+  it("stop() prevents further interval polls", async () => {
+    const poller = new GitPoller("/repo", 1000);
+    poller.start();
+
+    await vi.advanceTimersByTimeAsync(1000);
+    const callsBeforeStop = ingestLatest.mock.calls.length;
+    poller.stop();
+
+    await vi.advanceTimersByTimeAsync(5000);
+    expect(ingestLatest.mock.calls.length).toBe(callsBeforeStop);
+  });
+});