pi-harness-runtime 1.1.439 → 1.1.441

package/packages/learning-engine/test/engine.test.ts

@@ -1,331 +0,0 @@
-/**
- * Learning Engine Tests (RFC-0058)
- */
-
-import { describe, it, expect, beforeEach } from "@jest/globals";
-import { type LearningEngine, createLearningEngine } from "../src/index.js";
-import { containsSecret, calculateConfidence } from "../src/index.js";
-import type { LearningRequest, ProviderExecutionMetric } from "../src/index.js";
-
-describe("LearningEngine", () => {
-	let engine: LearningEngine;
-
-	beforeEach(() => {
-		engine = createLearningEngine();
-	});
-
-	describe("learn", () => {
-		it("extracts provider success patterns", () => {
-			const request: LearningRequest = {
-				jobId: "job-1",
-				events: [],
-				evaluation: [],
-				repairHistory: [],
-				providerMetrics: [
-					{
-						providerId: "claude",
-						taskType: "code-review",
-						successCount: 8,
-						failureCount: 2,
-						avgLatencyMs: 5000,
-						avgTokensUsed: 1000,
-					},
-					{
-						providerId: "gpt",
-						taskType: "code-review",
-						successCount: 5,
-						failureCount: 5,
-						avgLatencyMs: 4000,
-						avgTokensUsed: 800,
-					},
-				],
-			};
-
-			const result = engine.learn(request);
-
-			expect(result.experiences.length).toBeGreaterThan(0);
-			expect(result.summary.totalExtracted).toBeGreaterThan(0);
-		});
-
-		it("extracts repair patterns", () => {
-			const request: LearningRequest = {
-				jobId: "job-1",
-				events: [],
-				evaluation: [],
-				repairHistory: [
-					{
-						taskId: "task-1",
-						repairType: "retry",
-						success: true,
-						attempts: 2,
-					},
-					{
-						taskId: "task-2",
-						repairType: "retry",
-						success: true,
-						attempts: 1,
-					},
-					{
-						taskId: "task-3",
-						repairType: "retry",
-						success: false,
-						attempts: 3,
-					},
-				],
-				providerMetrics: [],
-			};
-
-			const result = engine.learn(request);
-
-			const retryPattern = result.experiences.find((e) =>
-				e.pattern.includes("retry"),
-			);
-			expect(retryPattern).toBeDefined();
-		});
-
-		it("does not approve experience automatically", () => {
-			const request: LearningRequest = {
-				jobId: "job-1",
-				events: [],
-				evaluation: [],
-				repairHistory: [],
-				providerMetrics: [],
-			};
-
-			const result = engine.learn(request);
-
-			// Experiences should be 'proposed', not 'approved'
-			for (const exp of result.experiences) {
-				expect(exp.status).toBe("proposed");
-			}
-		});
-
-		it("respects human approval", () => {
-			const request: LearningRequest = {
-				jobId: "job-1",
-				events: [],
-				evaluation: [],
-				repairHistory: [],
-				providerMetrics: [],
-				humanFeedback: [
-					{
-						jobId: "job-1",
-						taskId: "task-1",
-						feedback: "positive",
-						approved: true,
-						timestamp: new Date().toISOString(),
-					},
-				],
-			};
-
-			const result = engine.learn(request);
-
-			// Should have some approved experiences
-			expect(result.summary.approved).toBeGreaterThanOrEqual(0);
-		});
-
-		it("produces summary", () => {
-			const request: LearningRequest = {
-				jobId: "job-1",
-				events: [],
-				evaluation: [],
-				repairHistory: [],
-				providerMetrics: [],
-			};
-
-			const result = engine.learn(request);
-
-			expect(result.summary).toBeDefined();
-			expect(result.summary.totalExtracted).toBe(0);
-			expect(result.extractedAt).toBeDefined();
-		});
-	});
-
-	describe("approve/reject", () => {
-		it("approves experience and increases confidence", () => {
-			const experience = {
-				id: "exp-1",
-				scope: "global" as const,
-				pattern: "Test pattern",
-				recommendation: "Test recommendation",
-				confidence: 50,
-				evidenceRefs: [],
-				status: "proposed" as const,
-				createdAt: new Date().toISOString(),
-				updatedAt: new Date().toISOString(),
-				tags: ["test"],
-			};
-
-			const approved = engine.approve(experience);
-
-			expect(approved.status).toBe("approved");
-			expect(approved.confidence).toBe(60); // 50 + 10
-		});
-
-		it("rejects experience", () => {
-			const experience = {
-				id: "exp-1",
-				scope: "global" as const,
-				pattern: "Test pattern",
-				recommendation: "Test recommendation",
-				confidence: 50,
-				evidenceRefs: [],
-				status: "proposed" as const,
-				createdAt: new Date().toISOString(),
-				updatedAt: new Date().toISOString(),
-				tags: ["test"],
-			};
-
-			const rejected = engine.reject(experience);
-
-			expect(rejected.status).toBe("rejected");
-		});
-	});
-
-	describe("toOkfFormat", () => {
-		it("exports to OKF markdown format", () => {
-			const experience = {
-				id: "exp-1",
-				scope: "global" as const,
-				pattern: "Test pattern for export",
-				recommendation: "Test recommendation",
-				confidence: 75,
-				evidenceRefs: ["job-1", "job-2"],
-				status: "approved" as const,
-				createdAt: new Date().toISOString(),
-				updatedAt: new Date().toISOString(),
-				tags: ["test", "export"],
-			};
-
-			const okf = engine.toOkfFormat(experience);
-
-			expect(okf).toContain("---");
-			expect(okf).toContain("type: Engineering Lesson");
-			expect(okf).toContain("authority: approved");
-			expect(okf).toContain("confidence: 75");
-		});
-	});
-});
-
-describe("Secret Detection", () => {
-	describe("containsSecret", () => {
-		it("detects API key patterns", () => {
-			expect(containsSecret("api_key")).toBe(true);
-			expect(containsSecret("API-KEY")).toBe(true);
-			expect(containsSecret("myApiKey")).toBe(true);
-		});
-
-		it("detects password patterns", () => {
-			expect(containsSecret("password")).toBe(true);
-			expect(containsSecret("userPassword")).toBe(true);
-		});
-
-		it("detects token patterns", () => {
-			expect(containsSecret("token")).toBe(true);
-			expect(containsSecret("access_token")).toBe(true);
-			expect(containsSecret("refreshToken")).toBe(true);
-		});
-
-		it("does not flag normal strings", () => {
-			expect(containsSecret("username")).toBe(false);
-			expect(containsSecret("email")).toBe(false);
-			expect(containsSecret("comment")).toBe(false);
-		});
-	});
-
-	describe("calculateConfidence", () => {
-		it("increases with occurrences", () => {
-			const low = calculateConfidence({
-				occurrenceCount: 1,
-				consistentPositiveOutcomes: 1,
-				humanApprovalCount: 0,
-				frameworkCorroboration: 0,
-				contradictoryOutcomes: 0,
-				singleEventEvidence: true,
-				staleRepository: false,
-				changedProjectRules: false,
-			});
-
-			const high = calculateConfidence({
-				occurrenceCount: 5,
-				consistentPositiveOutcomes: 5,
-				humanApprovalCount: 0,
-				frameworkCorroboration: 0,
-				contradictoryOutcomes: 0,
-				singleEventEvidence: false,
-				staleRepository: false,
-				changedProjectRules: false,
-			});
-
-			expect(high).toBeGreaterThan(low);
-		});
-
-		it("decreases with contradictory outcomes", () => {
-			const noContra = calculateConfidence({
-				occurrenceCount: 5,
-				consistentPositiveOutcomes: 5,
-				humanApprovalCount: 0,
-				frameworkCorroboration: 0,
-				contradictoryOutcomes: 0,
-				singleEventEvidence: false,
-				staleRepository: false,
-				changedProjectRules: false,
-			});
-
-			const withContra = calculateConfidence({
-				occurrenceCount: 5,
-				consistentPositiveOutcomes: 5,
-				humanApprovalCount: 0,
-				frameworkCorroboration: 0,
-				contradictoryOutcomes: 2,
-				singleEventEvidence: false,
-				staleRepository: false,
-				changedProjectRules: false,
-			});
-
-			expect(withContra).toBeLessThan(noContra);
-		});
-
-		it("increases with human approval", () => {
-			const noApproval = calculateConfidence({
-				occurrenceCount: 3,
-				consistentPositiveOutcomes: 3,
-				humanApprovalCount: 0,
-				frameworkCorroboration: 0,
-				contradictoryOutcomes: 0,
-				singleEventEvidence: false,
-				staleRepository: false,
-				changedProjectRules: false,
-			});
-
-			const withApproval = calculateConfidence({
-				occurrenceCount: 3,
-				consistentPositiveOutcomes: 3,
-				humanApprovalCount: 1,
-				frameworkCorroboration: 0,
-				contradictoryOutcomes: 0,
-				singleEventEvidence: false,
-				staleRepository: false,
-				changedProjectRules: false,
-			});
-
-			expect(withApproval).toBeGreaterThan(noApproval);
-		});
-
-		it("bounds confidence between 0 and 100", () => {
-			const result = calculateConfidence({
-				occurrenceCount: 100,
-				consistentPositiveOutcomes: 100,
-				humanApprovalCount: 10,
-				frameworkCorroboration: 10,
-				contradictoryOutcomes: 0,
-				singleEventEvidence: false,
-				staleRepository: false,
-				changedProjectRules: false,
-			});
-
-			expect(result).toBeLessThanOrEqual(100);
-			expect(result).toBeGreaterThanOrEqual(0);
-		});
-	});
-});

package/packages/logging/test/buffer.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { LogBuffer } from "../src/buffer.js";
-import type { LogRecord } from "../src/types.js";
-
-function record(level: LogRecord["level"], id: number): LogRecord {
-	return {
-		ts: "2026-10-24T00:00:00.000Z",
-		level,
-		source: "test",
-		event: `event-${id}`,
-	};
-}
-
-describe("LogBuffer", () => {
-	test("takes records in order and respects the batch size", () => {
-		const buffer = new LogBuffer({ maxSize: 10, maxBatchSize: 2 });
-		buffer.push(record("info", 1));
-		buffer.push(record("info", 2));
-		buffer.push(record("info", 3));
-
-		const batch = buffer.takeBatch();
-		expect(batch).toHaveLength(2);
-		expect(batch[0].event).toBe("event-1");
-		expect(buffer.size).toBe(1);
-	});
-
-	test("drops the least severe record when full", () => {
-		const buffer = new LogBuffer({ maxSize: 2, maxBatchSize: 10 });
-		buffer.push(record("error", 1));
-		buffer.push(record("info", 2));
-		buffer.push(record("debug", 3));
-
-		expect(buffer.dropped).toBe(1);
-		const batch = buffer.takeBatch();
-		expect(batch.map((item) => item.event)).toEqual(["event-1", "event-3"]);
-	});
-
-	test("peekAll does not consume the buffer", () => {
-		const buffer = new LogBuffer({ maxSize: 10, maxBatchSize: 10 });
-		buffer.push(record("info", 1));
-		expect(buffer.peekAll()).toHaveLength(1);
-		expect(buffer.size).toBe(1);
-	});
-});

package/packages/logging/test/classification.test.ts

@@ -1,137 +0,0 @@
-/**
- * What may leave the machine.
- *
- * The local log file keeps everything; the centralized archive keeps the
- * structured, sanitized events an operator needs.
- */
-
-import { describe, expect, test } from "bun:test";
-import {
-	DEFAULT_CLASSIFICATION_POLICY,
-	classifyRecord,
-	isSanitizedMessage,
-	prepareRemoteRecord,
-} from "../src/classification.js";
-import { LogShipper } from "../src/shipper.js";
-import type { LogBatch, LogRecord, LogTransport } from "../src/types.js";
-
-function record(overrides: Partial<LogRecord> = {}): LogRecord {
-	return {
-		ts: "2026-10-24T09:00:00.000Z",
-		level: "info",
-		source: "harness.test",
-		event: "service.started",
-		...overrides,
-	};
-}
-
-describe("event classification", () => {
-	test("keeps structured service events remote", () => {
-		expect(classifyRecord(record({ event: "service.started" }))).toBe("remote");
-		expect(classifyRecord(record({ event: "harness.service-diagnostics.check" }))).toBe("remote");
-		expect(classifyRecord(record({ event: "validation.tier.run" }))).toBe("remote");
-	});
-
-	test("keeps the catch-all local log mirror local", () => {
-		expect(classifyRecord(record({ event: "harness.log" }))).toBe("local");
-	});
-
-	test("keeps prompt and response events local", () => {
-		expect(classifyRecord(record({ event: "prompt.received" }))).toBe("local");
-		expect(classifyRecord(record({ event: "assistant.response" }))).toBe("local");
-	});
-
-	test("keeps unknown events local by default", () => {
-		expect(classifyRecord(record({ event: "something.new" }))).toBe("local");
-	});
-});
-
-describe("message policy", () => {
-	test("keeps a short sanitized message", () => {
-		expect(isSanitizedMessage("service started in 12 ms", DEFAULT_CLASSIFICATION_POLICY)).toBe(true);
-	});
-
-	test("drops a multi line message", () => {
-		expect(isSanitizedMessage("line one\nline two", DEFAULT_CLASSIFICATION_POLICY)).toBe(false);
-	});
-
-	test("drops a message with an absolute path", () => {
-		expect(
-			isSanitizedMessage("failed to read /home/tester/project/file.ts", DEFAULT_CLASSIFICATION_POLICY),
-		).toBe(false);
-	});
-
-	test("drops a message with a URL that has a query string", () => {
-		expect(
-			isSanitizedMessage("GET https://api.example.com/v1?token=abc failed", DEFAULT_CLASSIFICATION_POLICY),
-		).toBe(false);
-	});
-
-	test("drops a very long message", () => {
-		expect(isSanitizedMessage("x".repeat(500), DEFAULT_CLASSIFICATION_POLICY)).toBe(false);
-	});
-});
-
-describe("remote preparation", () => {
-	test("removes the fields with a private key name", () => {
-		const prepared = prepareRemoteRecord(
-			record({
-				fields: { durationMs: 12, prompt: "private", output: "private", reason: "ok" },
-			}),
-		);
-
-		expect(prepared?.fields?.prompt).toBeUndefined();
-		expect(prepared?.fields?.output).toBeUndefined();
-		expect(prepared?.fields?.durationMs).toBe(12);
-		expect(prepared?.fields?.reason).toBe("ok");
-	});
-
-	test("returns null for a local event", () => {
-		expect(prepareRemoteRecord(record({ event: "harness.log", message: "anything" }))).toBeNull();
-	});
-
-	test("drops the message but keeps the event", () => {
-		const prepared = prepareRemoteRecord(
-			record({ event: "service.started", message: "failed at /home/tester/x/y.ts" }),
-		);
-
-		expect(prepared?.message).toBeUndefined();
-		expect(prepared?.event).toBe("service.started");
-	});
-});
-
-describe("shipper integration", () => {
-	test("does not ship a local-only record", async () => {
-		const batches: LogBatch[] = [];
-		const transport: LogTransport = {
-			name: "recorder",
-			async send(batch: LogBatch): Promise<void> {
-				batches.push(batch);
-			},
-		};
-		const shipper = new LogShipper({ transports: [transport], flushIntervalMs: 0 });
-
-		shipper.info("harness", "log", "a private local log line");
-		await shipper.flush();
-
-		expect(batches).toHaveLength(0);
-		expect(shipper.getStats().localOnly).toBe(1);
-	});
-
-	test("ships a structured record", async () => {
-		const batches: LogBatch[] = [];
-		const transport: LogTransport = {
-			name: "recorder",
-			async send(batch: LogBatch): Promise<void> {
-				batches.push(batch);
-			},
-		};
-		const shipper = new LogShipper({ transports: [transport], flushIntervalMs: 0 });
-
-		shipper.info("harness.service-diagnostics", "service.check", "service is up", { durationMs: 3 });
-		await shipper.flush();
-
-		expect(batches).toHaveLength(1);
-		expect(batches[0].records[0].event).toBe("service.check");
-	});
-});

package/packages/logging/test/config.test.ts

@@ -1,97 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { resolveLogSinkConfig } from "../src/config.js";
-
-const created: string[] = [];
-
-function tempDir(): string {
-	const dir = mkdtempSync(join(tmpdir(), "log-config-"));
-	created.push(dir);
-	return dir;
-}
-
-afterEach(() => {
-	while (created.length > 0) {
-		rmSync(created.pop() as string, { recursive: true, force: true });
-	}
-});
-
-describe("resolveLogSinkConfig", () => {
-	test("PI_LOG_SINK=off disables logging completely", () => {
-		const config = resolveLogSinkConfig({ env: { PI_LOG_SINK: "off" }, keysDir: tempDir() });
-		expect(config.enabled).toBe(false);
-		expect(config.transports).toHaveLength(0);
-		expect(config.spoolDir).toBeUndefined();
-	});
-
-	test("auto mode stays local when nothing is configured", () => {
-		const config = resolveLogSinkConfig({ env: {}, keysDir: tempDir() });
-		expect(config.enabled).toBe(true);
-		expect(config.transports).toHaveLength(0);
-		expect(config.spoolDir).toBeTruthy();
-	});
-
-	test("auto mode picks up R2 credentials from the key files", () => {
-		const keysDir = tempDir();
-		writeFileSync(join(keysDir, "r2-bucket-name.txt"), "logs-bucket\n");
-		writeFileSync(join(keysDir, "r2-access-key-id.txt"), "AKIAEXAMPLE\n");
-		writeFileSync(join(keysDir, "r2-secret-access-key.txt"), "secret\n");
-		writeFileSync(join(keysDir, "r2-account-id.txt"), "account\n");
-
-		const config = resolveLogSinkConfig({ env: {}, keysDir });
-		expect(config.transports).toHaveLength(1);
-		expect(config.transports[0].name).toBe("r2");
-	});
-
-	test("auto mode picks up an explicit webhook url", () => {
-		const config = resolveLogSinkConfig({
-			env: { PI_LOG_WEBHOOK_URL: "http://127.0.0.1:8443/api/logs" },
-			keysDir: tempDir(),
-		});
-		expect(config.transports).toHaveLength(1);
-		expect(config.transports[0].name).toBe("webhook");
-	});
-
-	test("r2+webhook keeps R2 as the first transport", () => {
-		const keysDir = tempDir();
-		writeFileSync(join(keysDir, "r2-bucket-name.txt"), "logs-bucket\n");
-		writeFileSync(join(keysDir, "r2-access-key-id.txt"), "AKIAEXAMPLE\n");
-		writeFileSync(join(keysDir, "r2-secret-access-key.txt"), "secret\n");
-		writeFileSync(join(keysDir, "r2-endpoint.txt"), "https://example.r2.cloudflarestorage.com\n");
-
-		const config = resolveLogSinkConfig({
-			env: { PI_LOG_SINK: "r2+webhook", PI_LOG_WEBHOOK_URL: "http://127.0.0.1:8443/api/logs" },
-			keysDir,
-		});
-		expect(config.transports.map((transport) => transport.name)).toEqual(["r2", "webhook"]);
-	});
-
-	test("r2 without credentials is skipped and reported", () => {
-		const config = resolveLogSinkConfig({ env: { PI_LOG_SINK: "r2" }, keysDir: tempDir() });
-		expect(config.transports).toHaveLength(0);
-		expect(config.notes.join(" ")).toContain("credentials are incomplete");
-	});
-
-	test("sampling and buffer settings come from the environment", () => {
-		const config = resolveLogSinkConfig({
-			env: {
-				PI_LOG_LEVEL: "warn",
-				PI_LOG_SAMPLE_RATE: "0.5",
-				PI_LOG_RATE_LIMIT: "5",
-				PI_LOG_BUFFER_SIZE: "42",
-				PI_LOG_BATCH_SIZE: "7",
-				PI_LOG_FLUSH_INTERVAL_MS: "1000",
-			},
-			keysDir: tempDir(),
-		});
-
-		expect(config.sampling.minLevel).toBe("warn");
-		expect(config.sampling.sampleRate).toBe(0.5);
-		expect(config.sampling.rateLimitPerMinute).toBe(5);
-		expect(config.buffer.maxSize).toBe(42);
-		expect(config.buffer.maxBatchSize).toBe(7);
-		expect(config.flushIntervalMs).toBe(1000);
-	});
-});