pi-harness-runtime 1.1.410 → 1.1.412

package/packages/skills/test/remote-source.test.ts

@@ -0,0 +1,248 @@
+/**
+ * The skills that live on the server.
+ *
+ * The vector store is an index - it says WHICH skill fits a question. The
+ * service holds the authoritative files, so a machine without a local copy
+ * can still use a skill.
+ *
+ * The states must stay apart: a service that refused the call needs a
+ * different fix than a service that could not be reached, and both differ
+ * from a service that holds nothing.
+ *
+ * The source is injected, so the test neither reaches the network nor
+ * replaces a process-global module.
+ */
+
+import { describe, expect, it } from "bun:test";
+
+import { createSkillRegistry } from "../src/loader.js";
+import type { RemoteSkill, RemoteSkillSource } from "../src/remote-source.js";
+
+/** A source that holds the given skills. */
+class FakeSource implements RemoteSkillSource {
+	/** The skills the source holds. */
+	readonly skills: RemoteSkill[];
+	/** The ids that were asked for. */
+	readonly requested: string[] = [];
+	/** The error the next call raises. */
+	failure: { message: string; code: "denied" | "unavailable" } | null = null;
+
+	constructor(skills: RemoteSkill[] = []) {
+		this.skills = skills;
+	}
+
+	async list(): Promise<RemoteSkill[]> {
+		if (this.failure) {
+			const error = new Error(this.failure.message) as Error & {
+				code: string;
+			};
+			error.code = this.failure.code;
+			throw error;
+		}
+		return this.skills;
+	}
+
+	async get(id: string): Promise<RemoteSkill | null> {
+		this.requested.push(id);
+		if (this.failure) {
+			const error = new Error(this.failure.message) as Error & {
+				code: string;
+			};
+			error.code = this.failure.code;
+			throw error;
+		}
+		return this.skills.find((skill) => skill.id === id) ?? null;
+	}
+}
+
+describe("the skills of the server", () => {
+	it("are listed by the registry", async () => {
+		const source = new FakeSource([
+			{
+				id: "shared-skill",
+				name: "shared-skill",
+				description: "the shared skill",
+				version: "1.2.0",
+			},
+		]);
+		const registry = createSkillRegistry();
+		registry.setRemoteSource(source);
+
+		const stats = await registry.refreshRemoteSkills();
+
+		expect(stats.state).toBe("populated");
+		expect(stats.count).toBe(1);
+		expect(registry.listRemote().map((skill) => skill.id)).toEqual(["shared-skill"]);
+		// The local count stays local.
+		expect(registry.list()).toHaveLength(0);
+	});
+
+	it("are not local skills", async () => {
+		const source = new FakeSource([
+			{ id: "shared-skill", name: "shared-skill", description: "d", version: "1.0.0" },
+		]);
+		const registry = createSkillRegistry();
+		registry.setRemoteSource(source);
+		await registry.refreshRemoteSkills();
+
+		expect(registry.list()).toHaveLength(0);
+		expect(registry.listRemote()).toHaveLength(1);
+	});
+
+	it("replace the cached skill when the version changed", async () => {
+		const source = new FakeSource([
+			{ id: "shared-skill", name: "shared-skill", description: "old", version: "1.0.0" },
+		]);
+		const registry = createSkillRegistry();
+		registry.setRemoteSource(source);
+		await registry.refreshRemoteSkills();
+		expect(registry.listRemote()[0].frontmatter.description).toBe("old");
+
+		// The server publishes a new version.
+		source.skills[0] = {
+			id: "shared-skill",
+			name: "shared-skill",
+			description: "new",
+			version: "1.1.0",
+		};
+		await registry.refreshRemoteSkills();
+
+		expect(registry.listRemote()[0].frontmatter.description).toBe("new");
+		expect(registry.listRemote()[0].frontmatter.version).toBe("1.1.0");
+	});
+
+	it("stay when the version is unknown", async () => {
+		const source = new FakeSource([
+			{ id: "shared-skill", name: "shared-skill", description: "known", version: "1.0.0" },
+		]);
+		const registry = createSkillRegistry();
+		registry.setRemoteSource(source);
+		await registry.refreshRemoteSkills();
+
+		// A record without a version is not evidence of a change.
+		source.skills[0] = {
+			id: "shared-skill",
+			name: "shared-skill",
+			description: "changed without a version",
+		};
+		await registry.refreshRemoteSkills();
+
+		expect(registry.listRemote()[0].frontmatter.description).toBe("known");
+	});
+
+	it("are loaded completely from the service", async () => {
+		const source = new FakeSource([
+			{
+				id: "shared-skill",
+				name: "shared-skill",
+				description: "the shared skill",
+				version: "1.0.0",
+				content: "the complete body of the skill",
+				contentComplete: true,
+			},
+		]);
+		const registry = createSkillRegistry();
+		registry.setRemoteSource(source);
+
+		const loaded = await registry.load("shared-skill");
+
+		expect(loaded).not.toBeNull();
+		expect(loaded?.body).toBe("the complete body of the skill");
+		expect(source.requested).toContain("shared-skill");
+	});
+
+	it("are not asked for again once the content is complete", async () => {
+		const source = new FakeSource([
+			{
+				id: "shared-skill",
+				name: "shared-skill",
+				description: "d",
+				version: "1.0.0",
+				content: "the body",
+				contentComplete: true,
+			},
+		]);
+		const registry = createSkillRegistry();
+		registry.setRemoteSource(source);
+
+		await registry.load("shared-skill");
+		const afterFirst = source.requested.length;
+		await registry.load("shared-skill");
+
+		expect(source.requested.length).toBe(afterFirst);
+	});
+
+	it("are reported as empty when the service holds nothing", async () => {
+		const registry = createSkillRegistry();
+		registry.setRemoteSource(new FakeSource([]));
+
+		const stats = await registry.refreshRemoteSkills();
+
+		expect(stats.state).toBe("empty");
+		expect(stats.count).toBe(0);
+	});
+
+	it("are reported as not configured without a service", async () => {
+		const registry = createSkillRegistry();
+
+		const stats = await registry.getRemoteStats();
+
+		expect(stats.state).toBe("not-configured");
+	});
+});
+
+describe("a service that does not answer", () => {
+	it("reports a refusal as denied", async () => {
+		const source = new FakeSource();
+		source.failure = { message: "unauthorized", code: "denied" };
+		const registry = createSkillRegistry();
+		registry.setRemoteSource(source);
+
+		const stats = await registry.refreshRemoteSkills();
+
+		expect(stats.state).toBe("denied");
+		expect(stats.error).toContain("unauthorized");
+	});
+
+	it("reports an unreachable service as unavailable", async () => {
+		const source = new FakeSource();
+		source.failure = { message: "connection refused", code: "unavailable" };
+		const registry = createSkillRegistry();
+		registry.setRemoteSource(source);
+
+		const stats = await registry.refreshRemoteSkills();
+
+		expect(stats.state).toBe("unavailable");
+		expect(stats.error).toContain("connection refused");
+	});
+
+	it("keeps the cached skills after a failed refresh", async () => {
+		const source = new FakeSource([
+			{ id: "shared-skill", name: "shared-skill", description: "d", version: "1.0.0" },
+		]);
+		const registry = createSkillRegistry();
+		registry.setRemoteSource(source);
+		await registry.refreshRemoteSkills();
+
+		source.failure = { message: "connection refused", code: "unavailable" };
+		const stats = await registry.refreshRemoteSkills();
+
+		expect(stats.state).toBe("unavailable");
+		// A failed refresh must not throw the cached skills away.
+		expect(registry.listRemote()).toHaveLength(1);
+	});
+
+	it("does not put a credential into the message", async () => {
+		const source = new FakeSource();
+		source.failure = {
+			message: "Bearer sk-abcdefghijklmnopqrstuvwxyz0123456789 refused",
+			code: "denied",
+		};
+		const registry = createSkillRegistry();
+		registry.setRemoteSource(source);
+
+		const stats = await registry.refreshRemoteSkills();
+
+		expect(stats.error).not.toContain("sk-abcdefghijklmnopqrstuvwxyz0123456789");
+	});
+});

package/packages/skills/test/vector-indexing.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Regression tests for the vector indexing of the skill registry.
+ *
+ * The registry used to start one embedding request per registered skill, all
+ * at the same time. A registry with a few hundred skills opened a few hundred
+ * connections at once, which starved every other request of the process.
+ *
+ * These tests use an injected indexer, so they neither reach the network nor
+ * touch a process-global module.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+	createSkillRegistry,
+	type SkillVectorIndexer,
+	type SkillVectorPoint,
+} from "../src/loader.js";
+import type { Skill } from "../src/types.js";
+
+/** An indexer that counts the requests it receives. */
+class CountingIndexer implements SkillVectorIndexer {
+	/** The number of texts of every embed call. */
+	readonly embedCalls: string[][] = [];
+	/** The points of every upsert call. */
+	readonly upsertCalls: SkillVectorPoint[][] = [];
+	/** The number of embed calls that were in flight at the same time. */
+	maxConcurrentEmbeds = 0;
+	private inFlight = 0;
+	/** When set, every embed call waits for this gate. */
+	gate: { promise: Promise<void>; release: () => void } | null = null;
+
+	async embed(texts: string[]): Promise<number[][]> {
+		this.inFlight += 1;
+		this.maxConcurrentEmbeds = Math.max(this.maxConcurrentEmbeds, this.inFlight);
+		this.embedCalls.push(texts);
+		try {
+			if (this.gate) await this.gate.promise;
+			return texts.map((text) => [text.length, 1, 2]);
+		} finally {
+			this.inFlight -= 1;
+		}
+	}
+
+	async upsert(points: SkillVectorPoint[]): Promise<void> {
+		this.upsertCalls.push(points);
+	}
+
+	/** The number of texts that were embedded. */
+	get embeddedCount(): number {
+		return this.embedCalls.reduce((total, texts) => total + texts.length, 0);
+	}
+}
+
+/** A skill with the given id and body. */
+function makeSkill(id: string, body = `body of ${id}`): Skill {
+	return {
+		id,
+		path: `/tmp/skills/${id}`,
+		frontmatter: {
+			name: id,
+			description: `description of ${id}`,
+			version: "1.0.0",
+		},
+		body,
+		references: [],
+		examples: [],
+		metadata: {},
+		loaded: false,
+	};
+}
+
+/** Wait until the registry has no queued skill left. */
+async function settle(registry: { isIndexing(): boolean }): Promise<void> {
+	for (let attempt = 0; attempt < 200 && registry.isIndexing(); attempt++) {
+		await new Promise((resolve) => setTimeout(resolve, 5));
+	}
+}
+
+describe("skill vector indexing", () => {
+	test("one embedding request carries many skills", async () => {
+		const indexer = new CountingIndexer();
+		const registry = createSkillRegistry({ indexer });
+
+		for (let i = 0; i < 100; i++) {
+			registry.register(makeSkill(`skill-${i}`));
+		}
+		await settle(registry);
+
+		expect(indexer.embeddedCount).toBe(100);
+		expect(indexer.embedCalls.length).toBeLessThanOrEqual(4);
+		expect(indexer.maxConcurrentEmbeds).toBe(1);
+		expect(indexer.upsertCalls.length).toBe(indexer.embedCalls.length);
+	});
+
+	test("the number of requests does not grow with the number of skills", async () => {
+		const small = new CountingIndexer();
+		const smallRegistry = createSkillRegistry({ indexer: small, batchSize: 8 });
+		for (let i = 0; i < 8; i++) smallRegistry.register(makeSkill(`small-${i}`));
+		await settle(smallRegistry);
+
+		const large = new CountingIndexer();
+		const largeRegistry = createSkillRegistry({ indexer: large, batchSize: 8 });
+		for (let i = 0; i < 80; i++) largeRegistry.register(makeSkill(`large-${i}`));
+		await settle(largeRegistry);
+
+		// Ten times the skills, ten times the requests - never ten times the
+		// skills in a single request.
+		expect(large.embedCalls.length).toBe(10);
+		expect(large.embedCalls.length).toBe(small.embedCalls.length * 10);
+	});
+
+	test("only one embedding request is in flight at a time", async () => {
+		const indexer = new CountingIndexer();
+		const registry = createSkillRegistry({ indexer, batchSize: 4 });
+
+		let release!: () => void;
+		indexer.gate = {
+			promise: new Promise<void>((resolve) => {
+				release = resolve;
+			}),
+			release: () => {},
+		};
+
+		for (let i = 0; i < 40; i++) {
+			registry.register(makeSkill(`gated-${i}`));
+		}
+		await new Promise((resolve) => setTimeout(resolve, 50));
+
+		// The queue waits for the first batch, so no second request started.
+		expect(indexer.embedCalls.length).toBe(1);
+
+		indexer.gate.release = release;
+		indexer.gate = null;
+		release();
+		await settle(registry);
+
+		expect(indexer.embeddedCount).toBe(40);
+		expect(indexer.maxConcurrentEmbeds).toBe(1);
+	});
+
+	test("a skill whose text did not change is not indexed again", async () => {
+		const indexer = new CountingIndexer();
+		const registry = createSkillRegistry({ indexer });
+
+		registry.register(makeSkill("stable"));
+		await settle(registry);
+		expect(indexer.embeddedCount).toBe(1);
+
+		// The same skill, registered again with the same text.
+		registry.register(makeSkill("stable"));
+		await settle(registry);
+		expect(indexer.embeddedCount).toBe(1);
+
+		// The same skill with a different body is indexed again.
+		registry.register(makeSkill("stable", "a different body"));
+		await settle(registry);
+		expect(indexer.embeddedCount).toBe(2);
+	});
+
+	test("the points carry the vector of their skill", async () => {
+		const indexer = new CountingIndexer();
+		const registry = createSkillRegistry({ indexer, batchSize: 2 });
+
+		registry.register(makeSkill("alpha"));
+		registry.register(makeSkill("beta"));
+		await settle(registry);
+
+		const points = indexer.upsertCalls.flat();
+		expect(points.length).toBe(2);
+		expect(points.map((point) => point.payload.name).sort()).toEqual(["alpha", "beta"]);
+		for (const point of points) {
+			expect(point.vector.length).toBe(3);
+		}
+	});
+
+	test("a registry without an index keeps no vectors", async () => {
+		const registry = createSkillRegistry({ indexer: null });
+
+		registry.register(makeSkill("unindexed"));
+		await settle(registry);
+
+		expect(registry.list().length).toBe(1);
+		expect(registry.isQdrantFailed()).toBe(false);
+	});
+
+	test("a failing index does not stop the other skills", async () => {
+		let calls = 0;
+		const indexer: SkillVectorIndexer = {
+			embed: async (texts: string[]) => {
+				calls += 1;
+				if (calls === 1) throw new Error("the index is unavailable");
+				return texts.map(() => [1, 2, 3]);
+			},
+			upsert: async () => {},
+		};
+		const registry = createSkillRegistry({ indexer, batchSize: 2 });
+
+		registry.register(makeSkill("first"));
+		registry.register(makeSkill("second"));
+		await settle(registry);
+
+		expect(registry.list().length).toBe(2);
+	});
+});

package/packages/sprint-planner/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/sprint-planner",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "type": "module",
   "description": "Sprint planning engine for pi-harness",
   "main": "dist/index.js",

package/packages/subscription-engine/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/subscription-engine",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/task-compiler/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/task-compiler",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "Task Compiler for pi-harness-runtime — produces deterministic task DAG from CompiledRequirement",
   "type": "module",
   "main": "./dist/index.js",

package/packages/telegram/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/telegram",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "pi-harness-runtime — Telegram inbound/outbound",
   "type": "module",
   "main": "./src/index.js",

package/packages/tencentdb-memory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moocoding/tencentdb-memory",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "TencentDB Agent Memory client - sync skills to centralized knowledge base",
   "type": "module",
   "main": "src/index.ts",

package/packages/tencentdb-sync/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/tencentdb-sync",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "Sync SKILL.md skills to TencentDB-Agent-Memory server (RFC-0105/0106)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/test-data-generator/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/test-data-generator",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "Test data generation for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/test-generator/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/test-generator",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "Auto-Test Generator — generate unit and E2E tests from source code (RFC-0013)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/todo-bd-sync/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moocoding/todo-bd-sync",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "Two-way sync between rpiv-todo overlay and bd issue tracker",
   "type": "module",
   "main": "src/index.ts",

package/packages/token-estimation/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/token-estimation",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "pi-harness-runtime — token-estimation",
   "type": "module",
   "main": "./dist/index.js",

package/packages/token-optimizer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/token-optimizer",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "Token Budget Optimizer — maximize prompt value within token limits (RFC-0011)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/tooling-preference/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/tooling-preference",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "pi-harness-runtime — JS/TS tooling preference (Biome vs ESLint/Prettier) proposal",
   "type": "module",
   "main": "./dist/index.js",

package/packages/trajectory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/trajectory",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "Trajectory capture for the write-review loop — persists cycle records for learning",
   "type": "module",
   "main": "./dist/src/index.js",

package/packages/tui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/tui",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "pi-harness-runtime — tui",
   "type": "module",
   "main": "./dist/index.js",

package/packages/two-phase-review/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/two-phase-review",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "pi-harness-runtime — two-phase implementation and review workflow (queue review signals, gate the phase, scope the diff)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/types",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "Shared TypeScript types for pi-harness-runtime packages",
   "type": "module",
   "main": "./dist/index.js",

package/packages/voice-api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/voice-api",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "type": "module",
   "description": "Voice-to-text API using Whisper for Telegram and LINE integration",
   "main": "./dist/index.js",

package/packages/webmcp-tester/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/webmcp-tester",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "WebMCP-powered E2E testing for pi-harness - natural language test scenarios",
   "type": "module",
   "main": "./dist/index.js",

package/packages/wiki/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/wiki",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "LLM Wiki integration for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/workflow-events/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/workflow-events",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/workspace-scanner/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/workspace-scanner",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/workspace-scanner/test/scanner.test.ts

@@ -1,5 +1,6 @@
+/// <reference types="node" />
 import { describe, it, beforeEach, afterEach } from "node:test";
-import { equal } from "node:assert";
+import { deepStrictEqual, equal } from "node:assert";
 import { join } from "node:path";
 import { mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -23,13 +24,13 @@ describe("WorkspaceScanner", () => {
 	it("skips git when requested", async () => {
 		const scanner = new WorkspaceScanner(testDir);
 		const snap = await scanner.scan({ skipGit: true });
-		equal(snap.git, null);
+		deepStrictEqual(snap.git, null);
 	});
 
 	it("skips config when requested", async () => {
 		const scanner = new WorkspaceScanner(testDir);
 		const snap = await scanner.scan({ skipConfig: true });
-		equal(snap.project, {});
+		deepStrictEqual(snap.project, {});
 		equal(snap.configFiles.length, 0);
 	});
 

package/packages/worktree/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/worktree",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "pi-harness-runtime — worktree",
   "type": "module",
   "main": "./dist/index.js",