pi-harness-runtime 1.1.410 → 1.1.412

package/packages/write-review/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moocoding/write-review",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "Two-agent write-review loop with blackboard coordination",
   "type": "module",
   "main": "src/index.ts",

package/scripts/sync-to-qdrant.ts

@@ -14,6 +14,21 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join, basename } from "node:path";
 import { QdrantClient } from "@qdrant/js-client-rest";
+// The runtime and this script must write into the SAME collection with the
+// SAME vectors: a collection holds vectors of exactly one size, and a vector
+// of a different size cannot be searched with the vectors of the other one.
+// The embedder and the collection name are therefore imported from the
+// packages that own them - they are not repeated here.
+import {
+  EMBEDDING_DIMENSIONS,
+  EMBEDDING_MODEL,
+  createEmbedding,
+  createEmbeddingsBatch,
+} from "../packages/qdrant-skills/dist/index.js";
+import {
+  LEGACY_SKILL_COLLECTION,
+  SKILL_COLLECTION,
+} from "../packages/skills/dist/vector-schema.js";
 
 // =============================================================================
 // SANITIZATION: Replace client-specific names with placeholders
@@ -81,17 +96,17 @@ interface QdrantConfig {
 function getQdrantConfig(): QdrantConfig | null {
   let apiKey = process.env.QDRANT_API_KEY;
   const url = process.env.QDRANT_CLUSTER_ENDPOINT || "https://api.qdrant.tech";
-  const collection = process.env.QDRANT_COLLECTION || "pi-harness-skills";
-  
+  const collection = process.env.QDRANT_COLLECTION || SKILL_COLLECTION;
+
   if (!apiKey) {
     const keyPath = `${process.env.HOME}/.pi-harness-runtime/keys/qdrant-api-key.txt`;
     if (existsSync(keyPath)) {
       apiKey = readFileSync(keyPath, "utf-8").trim();
     }
   }
-  
+
   if (!apiKey) return null;
-  
+
   return { url, apiKey, collection };
 }
 
@@ -180,15 +195,58 @@ function findSkillDirs(dir: string): string[] {
 // =============================================================================
 
 async function ensureCollection(client: QdrantClient, name: string): Promise<void> {
+  const existing = await collectionSchema(client, name);
+  if (existing?.dimensions !== undefined && existing.dimensions !== EMBEDDING_DIMENSIONS) {
+    // The collection holds vectors of another size. Writing into it would
+    // fail, and recreating it would destroy the skills of the other model.
+    // The name says so the user can act.
+    console.error(
+      `[Sync] The collection ${name} holds ${existing.dimensions}-dimensional vectors,` +
+        ` but the runtime embeds with ${EMBEDDING_DIMENSIONS} (${EMBEDDING_MODEL}).`,
+    );
+    if (name === LEGACY_SKILL_COLLECTION) {
+      console.error(
+        `[Sync] ${LEGACY_SKILL_COLLECTION} is the legacy collection of the MiniLM model.`,
+      );
+    }
+    console.error(
+      `[Sync] Use a different collection (QDRANT_COLLECTION) or re-create this one.`,
+    );
+    process.exit(1);
+  }
   try {
     await client.createCollection(name, {
-      vectors: { size: 384, distance: "Cosine" }
+      vectors: { size: EMBEDDING_DIMENSIONS, distance: "Cosine" }
     });
   } catch {
     // Already exists - OK
   }
 }
 
+/**
+ * The vector size and the distance of a collection.
+ *
+ * `null` means the collection does not exist (or cannot be read).
+ */
+async function collectionSchema(
+  client: QdrantClient,
+  name: string,
+): Promise<{ dimensions?: number; distance?: string } | null> {
+  try {
+    // SAFETY: the Qdrant client answers with the collection description;
+    // the shape below is the one field this function reads. The cast is
+    // needed because the generated client types the response as `unknown`.
+    const info = (await client.getCollection(name)) as unknown as {
+      config?: { params?: { vectors?: { size?: number; distance?: string } } };
+    };
+    const vectors = info?.config?.params?.vectors;
+    if (!vectors) return { };
+    return { dimensions: vectors.size, distance: vectors.distance };
+  } catch {
+    return null;
+  }
+}
+
 async function clearCollection(client: QdrantClient, name: string): Promise<void> {
   try {
     await client.deleteCollection(name);
@@ -203,6 +261,17 @@ async function upsertSkills(
   collectionName: string,
   skills: SkillDoc[]
 ): Promise<void> {
+  // The vectors are produced by the same embedder the runtime uses, so the
+  // two can search each other's points. The embedding happens in batches:
+  // one request per 64 skills instead of one per skill.
+  const { embeddings } = await createEmbeddingsBatch(skills.map((skill) => skill.text));
+  if (embeddings.length !== skills.length) {
+    console.error(
+      `[Sync] The embedder returned ${embeddings.length} vectors for ${skills.length} skills.`,
+    );
+    process.exit(1);
+  }
+
   const points = skills.map((skill, idx) => ({
     id: idx + 1,
     payload: {
@@ -210,12 +279,9 @@ async function upsertSkills(
       description: skill.description,
       body: skill.body,
     },
-    vector: {
-      text: skill.text,
-      model: "sentence-transformers/all-MiniLM-L6-v2"
-    }
+    vector: embeddings[idx],
   }));
-  
+
   await client.upsert(collectionName, { wait: true, points });
 }
 
@@ -224,11 +290,10 @@ async function searchSkills(
   collectionName: string,
   query: string
 ): Promise<void> {
+  // The query is embedded with the same model as the stored vectors.
+  const { embedding } = await createEmbedding(query);
   const results = await client.query(collectionName, {
-    query: {
-      text: query,
-      model: "sentence-transformers/all-MiniLM-L6-v2"
-    },
+    query: embedding,
     limit: 10,
     with_payload: true,
   } as Parameters<typeof client.query>[1]);

package/packages/autonomous-runtime/test/autonomous-runtime.test.ts

@@ -1,194 +0,0 @@
-/**
- * Tests for autonomous-runtime (RFC-0101 Phase 1)
- *
- * Covers: TaskRecord, TaskStatus, TaskLease, TaskInbox, LeaseManager
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtempSync, rmSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import type { TaskRecord, TaskLease } from "../src/types.js";
-import { TaskInbox, LeaseManager } from "../src/index.js";
-
-const TEST_DIR = mkdtempSync(join(tmpdir(), "pi-autonomous-"));
-const INBOX_DIR = join(TEST_DIR, "inbox");
-const LEASE_DIR = join(TEST_DIR, "leases");
-
-afterEach(() => {
-	try {
-		rmSync(TEST_DIR, { recursive: true, force: true });
-	} catch {
-		// ignore
-	}
-});
-
-describe("TaskRecord types", () => {
-	it("accepts valid task shape", () => {
-		const task: TaskRecord = {
-			id: "task-1",
-			status: "pending",
-			title: "Test task",
-			created_at: new Date().toISOString(),
-			updated_at: new Date().toISOString(),
-			attempts: 0,
-		};
-		expect(task.id).toBe("task-1");
-		expect(task.status).toBe("pending");
-	});
-});
-
-describe("LeaseManager", () => {
-	it("grants exclusive lease to first worker", async () => {
-		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
-		const lease = await mgr.acquire("task-1", "worker-1");
-		expect(lease).not.toBeNull();
-		expect(lease!.worker_id).toBe("worker-1");
-		expect(lease!.task_id).toBe("task-1");
-		expect(lease!.acquired_at).toBeTruthy();
-	});
-
-	it("denies lease to second worker", async () => {
-		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
-		await mgr.acquire("task-1", "worker-1");
-		const second = await mgr.acquire("task-1", "worker-2");
-		expect(second).toBeNull();
-	});
-
-	it("releases and allows re-acquisition", async () => {
-		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
-		await mgr.acquire("task-1", "worker-1");
-		await mgr.release("task-1", "worker-1");
-		const next = await mgr.acquire("task-1", "worker-2");
-		expect(next).not.toBeNull();
-		expect(next!.worker_id).toBe("worker-2");
-	});
-
-	it("only owner can release", async () => {
-		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
-		await mgr.acquire("task-1", "worker-1");
-		const released = await mgr.release("task-1", "worker-2");
-		expect(released).toBe(false);
-	});
-
-	it("renewLease extends expiry if owner", async () => {
-		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
-		await mgr.acquire("task-1", "worker-1");
-		const renewed = await mgr.renewLease("task-1", "worker-1");
-		expect(renewed).toBe(true);
-	});
-
-	it("renewLease fails for non-owner", async () => {
-		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
-		await mgr.acquire("task-1", "worker-1");
-		const renewed = await mgr.renewLease("task-1", "worker-2");
-		expect(renewed).toBe(false);
-	});
-
-	it("getLease returns current lease", async () => {
-		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
-		const lease = await mgr.acquire("task-1", "worker-1");
-		const found = await mgr.getLease("task-1");
-		expect(found).toEqual(lease);
-	});
-
-	it("expired lease allows re-acquisition", async () => {
-		const mgr = new LeaseManager({ leases_dir: LEASE_DIR, default_ttl_ms: 1 });
-		await mgr.acquire("task-1", "worker-1");
-		// Wait for expiry
-		await new Promise((r) => setTimeout(r, 10));
-		const next = await mgr.acquire("task-1", "worker-2");
-		expect(next).not.toBeNull();
-		expect(next!.worker_id).toBe("worker-2");
-	});
-});
-
-describe("TaskInbox", () => {
-	it("accepts and returns pending tasks", async () => {
-		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
-		await inbox.submit({
-			title: "Do the thing",
-			description: "A test task",
-			capability: "read",
-		});
-		const tasks = await inbox.getPending();
-		expect(tasks.length).toBe(1);
-		expect(tasks[0].status).toBe("pending");
-	});
-
-	it("assigns sequential integer IDs", async () => {
-		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
-		await inbox.submit({ title: "Task 1", capability: "read" });
-		await inbox.submit({ title: "Task 2", capability: "read" });
-		const tasks = await inbox.getPending();
-		expect(tasks.length).toBe(2);
-		expect(tasks[0].id).toMatch(/^\d+$/);
-		expect(tasks[1].id).toMatch(/^\d+$/);
-		expect(Number(tasks[0].id)).toBeLessThan(Number(tasks[1].id));
-	});
-
-	it("transitions pending → running → completed", async () => {
-		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
-		await inbox.submit({ title: "Test", capability: "read" });
-
-		const task = (await inbox.getPending())[0];
-		const started = await inbox.start(task.id);
-		expect(started.status).toBe("running");
-
-		const completed = await inbox.complete(task.id, { success: true });
-		expect(completed.status).toBe("completed");
-	});
-
-	it("fails a running task", async () => {
-		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
-		await inbox.submit({ title: "Fail task", capability: "read" });
-		const task = (await inbox.getPending())[0];
-		await inbox.start(task.id);
-		const failed = await inbox.fail(task.id, "Intentional test failure");
-		expect(failed.status).toBe("failed");
-		expect(failed.error).toBe("Intentional test failure");
-	});
-
-	it("retries a failed task if max_attempts not exceeded", async () => {
-		const inbox = new TaskInbox({
-			inbox_dir: INBOX_DIR,
-			options: { max_attempts: 2 },
-		});
-		await inbox.submit({ title: "Retry task", capability: "read" });
-		const task = (await inbox.getPending())[0];
-		await inbox.start(task.id);
-		await inbox.fail(task.id, "First attempt failed");
-		const retried = (await inbox.getPending()).find((t) => t.id === task.id);
-		expect(retried).not.toBeUndefined();
-		expect(retried!.attempts).toBe(1);
-	});
-
-	it("does not retry if max_attempts exceeded", async () => {
-		const inbox = new TaskInbox({
-			inbox_dir: INBOX_DIR,
-			options: { max_attempts: 1 },
-		});
-		await inbox.submit({ title: "No retry task", capability: "read" });
-		const task = (await inbox.getPending())[0];
-		await inbox.start(task.id);
-		await inbox.fail(task.id, "Final failure");
-		const retried = await inbox.getTask(task.id);
-		expect(retried?.status).toBe("failed");
-		expect(retried?.attempts).toBe(1);
-	});
-
-	it("getTask returns specific task by id", async () => {
-		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
-		await inbox.submit({ title: "Specific task", capability: "read" });
-		const [task] = await inbox.getPending();
-		const found = await inbox.getTask(task.id);
-		expect(found?.id).toBe(task.id);
-	});
-
-	it("returns null for non-existent task", async () => {
-		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
-		const found = await inbox.getTask("nonexistent");
-		expect(found).toBeNull();
-	});
-});

package/packages/autonomous-runtime/test/inbox.test.ts

@@ -1,80 +0,0 @@
-/**
- * Tests for TaskInbox (filesystem-backed).
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtempSync, rmSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { TaskInbox } from "../src/inbox.js";
-
-const DIR = mkdtempSync(join(tmpdir(), "pi-inbox-test-"));
-
-// Set env so inbox uses our temp dir
-process.env.PI_HARNESS_RUNTIME_ROOT = DIR;
-
-const inbox = new TaskInbox({ rootDir: DIR });
-
-afterEach(async () => {
-	await inbox.clear?.();
-});
-
-afterAll(() => {
-	try { rmSync(DIR, { recursive: true }); } catch { /* ignore */ }
-});
-
-describe("TaskInbox.submit", () => {
-	it("accepts and returns a pending task", async () => {
-		const spec = {
-			id: "test-1",
-			kind: "once" as const,
-			priority: 5,
-			spec: {},
-		};
-		const record = await inbox.submit(spec);
-		expect(record.id).toBe("test-1");
-		expect(record.status).toBe("pending");
-		expect(record.submittedAt).toBeDefined();
-	});
-
-	it("rejects duplicate ids", async () => {
-		const spec = {
-			id: "dup-test",
-			kind: "once" as const,
-			priority: 5,
-			spec: {},
-		};
-		await inbox.submit(spec);
-		await expect(inbox.submit(spec)).rejects.toThrow();
-	});
-});
-
-describe("TaskInbox.list", () => {
-	it("returns all submitted tasks", async () => {
-		await inbox.submit({ id: "l1", kind: "once", priority: 1, spec: {} });
-		await inbox.submit({ id: "l2", kind: "once", priority: 2, spec: {} });
-		const records = await inbox.list();
-		expect(records.length).toBeGreaterThanOrEqual(2);
-	});
-
-	it("filters by status", async () => {
-		await inbox.submit({ id: "f1", kind: "once", priority: 1, spec: {} });
-		const pending = await inbox.list({ status: "pending" });
-		expect(pending.every((r) => r.status === "pending")).toBe(true);
-	});
-});
-
-describe("TaskInbox.claim", () => {
-	it("returns null when nothing is pending", async () => {
-		const lease = await inbox.claim({ workerId: "w1", heartbeatIntervalMs: 30_000 });
-		expect(lease).toBeNull();
-	});
-
-	it("returns a lease for a pending task", async () => {
-		await inbox.submit({ id: "claim-1", kind: "once", priority: 5, spec: {} });
-		const lease = await inbox.claim({ workerId: "w1", heartbeatIntervalMs: 30_000 });
-		expect(lease).not.toBeNull();
-		expect(lease!.taskId).toBe("claim-1");
-		expect(lease!.status).toBe("active");
-	});
-});