pi-harness-runtime 1.1.439 → 1.1.441

package/packages/health-monitor/test/health.test.ts

@@ -1,231 +0,0 @@
-/**
- * Health Monitor Tests
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import {
-	DEFAULT_CONFIG,
-	determineStatus,
-	createReport,
-	aggregateHealth,
-	determineRecoveryAction,
-	resetRecoveryAttempts,
-	runHealthCheck,
-	calculateUptime,
-} from "../src/index.js";
-import type { ComponentHealth, HealthStatus } from "../src/index.js";
-
-const healthy: ComponentHealth = {
-	component: "provider-adapter",
-	status: "healthy",
-	lastCheck: new Date().toISOString(),
-	responseTimeMs: 50,
-	errorRate: 0,
-};
-
-const degraded: ComponentHealth = {
-	component: "skill-registry",
-	status: "degraded",
-	lastCheck: new Date().toISOString(),
-	responseTimeMs: 3000,
-	errorRate: 0.05,
-};
-
-const unhealthy: ComponentHealth = {
-	component: "memory-engine",
-	status: "unhealthy",
-	lastCheck: new Date().toISOString(),
-	responseTimeMs: 15000,
-	errorRate: 0.5,
-	details: "Connection refused",
-};
-
-describe("DEFAULT_CONFIG", () => {
-	it("has sensible defaults", () => {
-		expect(DEFAULT_CONFIG.checkIntervalMs).toBe(30_000);
-		expect(DEFAULT_CONFIG.degradedThreshold).toBe(2000);
-		expect(DEFAULT_CONFIG.unhealthyThreshold).toBe(10_000);
-		expect(DEFAULT_CONFIG.maxErrorRate).toBe(0.1);
-		expect(DEFAULT_CONFIG.autoRecover).toBe(false);
-		expect(DEFAULT_CONFIG.maxRecoveryAttempts).toBe(3);
-	});
-});
-
-describe("determineStatus", () => {
-	it("healthy for fast responses", () =>
-		expect(determineStatus(50, 0, DEFAULT_CONFIG)).toBe("healthy"));
-
-	it("degraded for slow responses", () =>
-		expect(determineStatus(5000, 0, DEFAULT_CONFIG)).toBe("degraded"));
-
-	it("unhealthy for very slow responses", () =>
-		expect(determineStatus(15000, 0, DEFAULT_CONFIG)).toBe("unhealthy"));
-
-	it("unhealthy for high error rate", () =>
-		expect(determineStatus(50, 0.5, DEFAULT_CONFIG)).toBe("unhealthy"));
-
-	it("uses custom config", () => {
-		const config = { ...DEFAULT_CONFIG, degradedThreshold: 100 };
-		expect(determineStatus(150, 0, config)).toBe("degraded");
-	});
-});
-
-describe("aggregateHealth", () => {
-	it("unknown for empty", () => expect(aggregateHealth([])).toBe("unknown"));
-	it("healthy when all healthy", () =>
-		expect(aggregateHealth(["healthy", "healthy"])).toBe("healthy"));
-	it("degraded when any degraded", () =>
-		expect(aggregateHealth(["healthy", "degraded"])).toBe("degraded"));
-	it("unhealthy when any unhealthy", () =>
-		expect(aggregateHealth(["healthy", "unhealthy"])).toBe("unhealthy"));
-	it("unhealthy takes precedence", () =>
-		expect(aggregateHealth(["degraded", "unhealthy"])).toBe("unhealthy"));
-});
-
-describe("createReport", () => {
-	it("sets overall status", () => {
-		const report = createReport([healthy, degraded], DEFAULT_CONFIG);
-		expect(report.overall).toBe("degraded");
-		expect(report.components).toHaveLength(2);
-	});
-
-	it("sets timestamp", () => {
-		const report = createReport([], DEFAULT_CONFIG);
-		expect(report.timestamp).toBeDefined();
-	});
-
-	it("calculates uptime", () => {
-		const report = createReport([], DEFAULT_CONFIG);
-		expect(report.uptime).toBeGreaterThanOrEqual(0);
-	});
-
-	it("unhealthy overall when component unhealthy", () => {
-		const report = createReport([healthy, unhealthy], DEFAULT_CONFIG);
-		expect(report.overall).toBe("unhealthy");
-	});
-});
-
-describe("determineRecoveryAction", () => {
-	beforeEach(() => {
-		resetRecoveryAttempts("memory-engine");
-		resetRecoveryAttempts("skill-registry");
-	});
-
-	it("null for healthy", () => {
-		expect(
-			determineRecoveryAction("provider-adapter", "healthy", DEFAULT_CONFIG),
-		).toBeNull();
-	});
-
-	it("null when autoRecover false", () => {
-		expect(
-			determineRecoveryAction("memory-engine", "unhealthy", DEFAULT_CONFIG),
-		).toBeNull();
-	});
-
-	it("restart for unhealthy when autoRecover true", () => {
-		const config = { ...DEFAULT_CONFIG, autoRecover: true };
-		const action = determineRecoveryAction(
-			"memory-engine",
-			"unhealthy",
-			config,
-		);
-		expect(action?.type).toBe("restart");
-		expect(action?.target).toBe("memory-engine");
-	});
-
-	it("retry for degraded with backoff", () => {
-		const config = { ...DEFAULT_CONFIG, autoRecover: true };
-		const action = determineRecoveryAction(
-			"skill-registry",
-			"degraded",
-			config,
-		);
-		expect(action?.type).toBe("retry");
-		expect(action?.config.backoffMs ?? 0).toBeGreaterThan(0);
-	});
-
-	it("alert after max attempts", () => {
-		const config = { ...DEFAULT_CONFIG, autoRecover: true };
-		for (let i = 0; i < DEFAULT_CONFIG.maxRecoveryAttempts; i++) {
-			determineRecoveryAction("memory-engine", "unhealthy", config);
-		}
-		const action = determineRecoveryAction(
-			"memory-engine",
-			"unhealthy",
-			config,
-		);
-		expect(action?.type).toBe("alert");
-	});
-});
-
-describe("resetRecoveryAttempts", () => {
-	it("clears counter", () => {
-		const config = { ...DEFAULT_CONFIG, autoRecover: true };
-		determineRecoveryAction("memory-engine", "unhealthy", config);
-		resetRecoveryAttempts("memory-engine");
-		const action = determineRecoveryAction(
-			"memory-engine",
-			"unhealthy",
-			config,
-		);
-		expect(action?.config.attempt).toBe(1);
-	});
-});
-
-describe("runHealthCheck", () => {
-	it("healthy when check passes", async () => {
-		const result = await runHealthCheck(
-			"provider-adapter",
-			async () => true,
-			DEFAULT_CONFIG,
-		);
-		expect(result.status).toBe("healthy");
-		expect(result.responseTimeMs).toBeGreaterThanOrEqual(0);
-	});
-
-	it("unhealthy when check throws", async () => {
-		const result = await runHealthCheck(
-			"memory-engine",
-			async () => {
-				throw new Error("fail");
-			},
-			DEFAULT_CONFIG,
-		);
-		expect(result.status).toBe("unhealthy");
-		expect(result.details).toContain("fail");
-	});
-
-	it("unhealthy when check returns false", async () => {
-		const result = await runHealthCheck(
-			"skill-registry",
-			async () => false,
-			DEFAULT_CONFIG,
-		);
-		expect(result.status).toBe("unhealthy");
-	});
-
-	it("records response time", async () => {
-		const result = await runHealthCheck(
-			"quota-manager",
-			async () => {
-				await new Promise((r) => setTimeout(r, 10));
-				return true;
-			},
-			DEFAULT_CONFIG,
-		);
-		expect(result.responseTimeMs).toBeGreaterThanOrEqual(5);
-	});
-});
-
-describe("calculateUptime", () => {
-	it("100 for healthy", () => {
-		const report = createReport([healthy], DEFAULT_CONFIG);
-		expect(calculateUptime(report)).toBe(100);
-	});
-
-	it("95 for unhealthy", () => {
-		const report = createReport([unhealthy], DEFAULT_CONFIG);
-		expect(calculateUptime(report)).toBe(95);
-	});
-});

package/packages/intent-analyzer/test/analyzer.test.ts

@@ -1,72 +0,0 @@
-import { describe, it } from "node:test";
-import { IntentAnalyzer } from "../src/analyzer.js";
-import { equal } from "node:assert";
-
-describe("IntentAnalyzer", () => {
-	const analyzer = new IntentAnalyzer();
-
-	it("detects bug_fix from fix keyword", () => {
-		const result = analyzer.analyze("fix the login bug on line 42");
-		equal(result.kind, "bug_fix");
-	});
-
-	it("detects feature from add keyword", () => {
-		const result = analyzer.analyze("add dark mode support");
-		equal(result.kind, "feature");
-	});
-
-	it("detects refactor from refactor keyword", () => {
-		const result = analyzer.analyze("refactor the auth module");
-		equal(result.kind, "refactor");
-	});
-
-	it("detects testing from test keyword", () => {
-		const result = analyzer.analyze("write tests for the payment module");
-		equal(result.kind, "testing");
-	});
-
-	it("detects deployment from deploy keyword", () => {
-		const result = analyzer.analyze("deploy to production");
-		equal(result.kind, "deployment");
-	});
-
-	it("detects security from security keyword", () => {
-		const result = analyzer.analyze("fix the auth vulnerability");
-		equal(result.kind, "security");
-	});
-
-	it("detects performance from optimize keyword", () => {
-		const result = analyzer.analyze("optimize the database query");
-		equal(result.kind, "performance");
-	});
-
-	it("detects architecture from architecture keyword", () => {
-		const result = analyzer.analyze("review the architecture design");
-		equal(result.kind, "architecture");
-	});
-
-	it("detects migration from migrate keyword", () => {
-		const result = analyzer.analyze("migrate to TypeScript");
-		equal(result.kind, "migration");
-	});
-
-	it("falls back to general for unknown text", () => {
-		const result = analyzer.analyze("hello world");
-		equal(result.kind, "general");
-	});
-
-	it("returns matched signals", () => {
-		const result = analyzer.analyze("fix the authentication bug");
-		equal(
-			result.signals.some((s) => s.keyword === "fix"),
-			true,
-		);
-	});
-
-	it("analyzeBatch returns multiple intents", () => {
-		const results = analyzer.analyzeBatch(["fix bug", "add feature"]);
-		equal(results.length, 2);
-		equal(results[0].kind, "bug_fix");
-		equal(results[1].kind, "feature");
-	});
-});

package/packages/intent-analyzer/test/ping-pong.test.ts

@@ -1,96 +0,0 @@
-import { describe, it } from "node:test";
-import { equal, ok } from "node:assert";
-import {
-	PingPongDecisionEngine,
-	analyzePingPongDecision,
-	scanCodebaseComplexity,
-} from "../src/ping-pong.js";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-describe("PingPongDecisionEngine", () => {
-	const engine = new PingPongDecisionEngine();
-
-	it("runs PING-PONG for explicit plan-code-review phrasing", () => {
-		const result = engine.analyze(
-			"Good plan, then write down plan to wiki/ then I will ask Minimax to write code then you review",
-		);
-
-		equal(result.decision, "run_ping_pong");
-		ok(result.reasons.some((reason) => reason.includes("explicit PING-PONG")));
-	});
-
-	it("runs PING-PONG for complex runtime implementation work", () => {
-		const result = engine.analyze("implement daemon graph loop recovery across packages", {
-			codebase: {
-				fileCount: 1200,
-				packageCount: 12,
-				frameworkSignalCount: 8,
-				hasTests: true,
-				hasCiOrRelease: true,
-			},
-		});
-
-		equal(result.decision, "run_ping_pong");
-		ok(result.score >= result.thresholds.run);
-	});
-
-	it("keeps analysis-only questions inline", () => {
-		const result = engine.analyze("analyze why the loop is quiet, do not edit code");
-
-		equal(result.decision, "handle_inline");
-		equal(result.score, 0);
-	});
-
-	it("can suggest PING-PONG for borderline code work", () => {
-		const result = engine.analyze("add tests for parser", {
-			codebase: { hasTests: true },
-		});
-
-		equal(result.decision, "suggest_ping_pong");
-		ok(result.score >= result.thresholds.suggest);
-		ok(result.score < result.thresholds.run);
-	});
-
-	it("allows explicit skip to override code-change wording", () => {
-		const result = engine.analyze("fix the daemon bug but skip ping-pong for now");
-
-		equal(result.decision, "handle_inline");
-		equal(result.score, 0);
-	});
-});
-
-describe("scanCodebaseComplexity", () => {
-	it("extracts package, test, and release signals", () => {
-		const root = mkdtempSync(join(tmpdir(), "ping-pong-scan-"));
-		try {
-			mkdirSync(join(root, "packages", "alpha"), { recursive: true });
-			mkdirSync(join(root, "packages", "beta"), { recursive: true });
-			mkdirSync(join(root, "test"), { recursive: true });
-			writeFileSync(
-				join(root, "package.json"),
-				JSON.stringify({ scripts: { build: "tsc", release: "standard-version" } }),
-			);
-			writeFileSync(join(root, "tsconfig.json"), "{}", "utf8");
-			writeFileSync(join(root, "test", "demo.test.ts"), "", "utf8");
-
-			const result = scanCodebaseComplexity(root);
-
-			ok(result.fileCount >= 3);
-			equal(result.packageCount, 2);
-			ok(result.frameworkSignalCount >= 2);
-			equal(result.hasTests, true);
-			equal(result.hasCiOrRelease, true);
-		} finally {
-			rmSync(root, { recursive: true, force: true });
-		}
-	});
-});
-
-describe("analyzePingPongDecision", () => {
-	it("uses the default engine", () => {
-		const result = analyzePingPongDecision("ping-pong this implementation");
-		equal(result.decision, "run_ping_pong");
-	});
-});

package/packages/jev-judge/tests/auto-continue-context.test.ts

@@ -1,280 +0,0 @@
-/**
- * Decision context tests.
- *
- * Jev has to see the question it decides about, and the deterministic policy
- * has to decide what is actually allowed. A clarification is never an
- * approval, and an action that needs an explicit authorization or that
- * cannot be undone is never approved autonomously.
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-	applyDecisionPolicy,
-	buildDecisionState,
-	createTaskState,
-	isEligibleForDecision,
-	DEFAULT_CAUTION_THRESHOLD,
-	DEFAULT_PROCEED_THRESHOLD,
-	MAX_LISTED_TASKS,
-	MAX_QUESTION_CHARS,
-	type DecisionContext,
-} from "../src/auto-continue.js";
-
-function context(overrides: Partial<DecisionContext> = {}): DecisionContext {
-	return {
-		question: {
-			requestId: "q-123",
-			text: "Want me to implement the toggle buttons now?",
-			kind: "approval",
-			proposedAction: "implement the toggle buttons",
-			consequence: "the button files change",
-			requiresExplicitAuthorization: false,
-			destructive: false,
-			external: false,
-			reversible: true,
-		},
-		currentTask: "Build the toggle",
-		completionRatio: 0.5,
-		totalTasks: 4,
-		completedTasks: 2,
-		blockers: [],
-		nextTasks: ["Build the toggle", "Write the test"],
-		validationStatus: "no pending final tier",
-		waitedMinutes: 6,
-		deadlineMinutes: 30,
-		...overrides,
-	};
-}
-
-describe("decision threshold", () => {
-	it("is not eligible before the threshold", () => {
-		expect(isEligibleForDecision(4.9, 5)).toBe(false);
-		expect(isEligibleForDecision(5, 5)).toBe(true);
-		expect(isEligibleForDecision(30, 5)).toBe(true);
-	});
-});
-
-describe("decision state", () => {
-	it("carries the question, the kind and the risk of the action", () => {
-		const state = buildDecisionState(
-			createTaskState(["a"], ["b"], new Date(), new Date(), context()),
-		) as any;
-
-		expect(state.pending_question.request_id).toBe("q-123");
-		expect(state.pending_question.kind).toBe("approval");
-		expect(state.pending_question.text).toContain("toggle buttons");
-		expect(state.pending_question.proposed_action).toBe(
-			"implement the toggle buttons",
-		);
-		expect(state.pending_question.consequence_of_approval).toBe(
-			"the button files change",
-		);
-		expect(state.pending_question.destructive).toBe(false);
-		expect(state.pending_question.reversible).toBe(true);
-	});
-
-	it("carries the bounded task and risk context", () => {
-		const state = buildDecisionState(
-			createTaskState(["a"], ["b"], new Date(), new Date(), context()),
-		) as any;
-
-		expect(state.decision_context.current_task).toBe("Build the toggle");
-		expect(state.decision_context.completion_ratio).toBe(0.5);
-		expect(state.decision_context.validation_status).toBe(
-			"no pending final tier",
-		);
-		expect(state.decision_context.waited_minutes).toBe(6);
-		expect(state.decision_context.deadline_minutes).toBe(30);
-		expect(state.decision_context.next_tasks).toHaveLength(2);
-	});
-
-	it("bounds the task lists and the question text", () => {
-		const many = Array.from({ length: 50 }, (_, i) => `task ${i}`);
-		const state = buildDecisionState(
-			createTaskState(
-				many,
-				many,
-				new Date(),
-				new Date(),
-				context({
-					question: {
-						requestId: "q-123",
-						text: "x".repeat(MAX_QUESTION_CHARS + 500),
-						kind: "approval",
-					},
-					nextTasks: many,
-				}),
-			),
-		) as any;
-
-		expect(state.task_summary.completed_list).toHaveLength(MAX_LISTED_TASKS);
-		expect(state.task_summary.remaining_list).toHaveLength(MAX_LISTED_TASKS);
-		expect(state.decision_context.next_tasks).toHaveLength(MAX_LISTED_TASKS);
-		expect(state.pending_question.text).toHaveLength(MAX_QUESTION_CHARS);
-	});
-
-	it("has no question when there is none", () => {
-		const state = buildDecisionState(
-			createTaskState(["a"], ["b"], new Date(), new Date()),
-		) as any;
-
-		expect(state.pending_question).toBeNull();
-	});
-});
-
-describe("decision policy", () => {
-	it("never turns a clarification into an approval", () => {
-		const result = applyDecisionPolicy(
-			"approve",
-			context({
-				question: {
-					requestId: "q-1",
-					text: "Do you mean the toggle or the switch?",
-					kind: "clarification",
-				},
-			}),
-			{ confidence: 0.99 },
-		);
-
-		expect(result.outcome).toBe("wait");
-		expect(result.appliedRule).toBe("clarification-never-approved");
-	});
-
-	it("approves a benign approval question so the timeout can work", () => {
-		// The timeout exists for routine, reversible work: an agent that
-		// proposes work is not a hard authorization block.
-		const result = applyDecisionPolicy(
-			"approve",
-			context({
-				question: {
-					requestId: "q-1",
-					text: "Want me to implement the toggle buttons now?",
-					kind: "approval",
-					requiresExplicitAuthorization: false,
-					destructive: false,
-					reversible: true,
-				},
-			}),
-			{ confidence: 0.9 },
-		);
-
-		expect(result.outcome).toBe("approve");
-		expect(result.appliedRule).toBeUndefined();
-	});
-
-	it("never approves an action that needs an explicit authorization", () => {
-		const result = applyDecisionPolicy(
-			"approve",
-			context({
-				question: {
-					requestId: "q-1",
-					text: "Shall I deploy to production?",
-					kind: "explicit",
-					requiresExplicitAuthorization: true,
-				},
-			}),
-			{ confidence: 0.99 },
-		);
-
-		expect(result.outcome).toBe("wait");
-		expect(result.appliedRule).toBe("explicit-authorization-required");
-	});
-
-	it("never approves an irreversible destructive action", () => {
-		const result = applyDecisionPolicy(
-			"approve",
-			context({
-				question: {
-					requestId: "q-1",
-					text: "Shall I drop the production table?",
-					kind: "approval",
-					destructive: true,
-					reversible: false,
-				},
-			}),
-			{ confidence: 0.99 },
-		);
-
-		expect(result.outcome).toBe("wait");
-		expect(result.appliedRule).toBe("irreversible-action");
-	});
-
-	it("proceeds with caution when a destructive action is reversible", () => {
-		const result = applyDecisionPolicy(
-			"approve",
-			context({
-				question: {
-					requestId: "q-1",
-					text: "Shall I regenerate the snapshots?",
-					kind: "approval",
-					destructive: true,
-					reversible: true,
-				},
-			}),
-			{ confidence: 0.99 },
-		);
-
-		expect(result.outcome).toBe("proceed_with_caution");
-		expect(result.appliedRule).toBe("destructive-action");
-	});
-
-	it("waits when the confidence is below the threshold", () => {
-		const result = applyDecisionPolicy("approve", context(), {
-			confidence: 0.4,
-			confidenceThreshold: 0.7,
-		});
-
-		expect(result.outcome).toBe("wait");
-		expect(result.appliedRule).toBe("confidence-below-threshold");
-	});
-
-	it("keeps the configured caution range out of the approval threshold", () => {
-		// A cautious approval needs the caution threshold, not the higher
-		// approval threshold: the configured range must really proceed.
-		const result = applyDecisionPolicy("proceed_with_caution", context(), {
-			confidence: 0.6,
-			confidenceThreshold: DEFAULT_PROCEED_THRESHOLD,
-			cautionThreshold: DEFAULT_CAUTION_THRESHOLD,
-		});
-
-		expect(result.outcome).toBe("proceed_with_caution");
-		expect(result.appliedRule).toBeUndefined();
-	});
-
-	it("waits for a cautious approval below the caution threshold", () => {
-		const result = applyDecisionPolicy("proceed_with_caution", context(), {
-			confidence: 0.4,
-			confidenceThreshold: DEFAULT_PROCEED_THRESHOLD,
-			cautionThreshold: DEFAULT_CAUTION_THRESHOLD,
-		});
-
-		expect(result.outcome).toBe("wait");
-		expect(result.appliedRule).toBe("confidence-below-threshold");
-	});
-
-	it("keeps the approval threshold for a full approval", () => {
-		const result = applyDecisionPolicy("approve", context(), {
-			confidence: 0.6,
-			confidenceThreshold: DEFAULT_PROCEED_THRESHOLD,
-			cautionThreshold: DEFAULT_CAUTION_THRESHOLD,
-		});
-
-		expect(result.outcome).toBe("wait");
-		expect(result.appliedRule).toBe("confidence-below-threshold");
-	});
-
-	it("approves a low risk approval with a high confidence", () => {
-		const result = applyDecisionPolicy("approve", context(), {
-			confidence: 0.9,
-			confidenceThreshold: 0.7,
-		});
-
-		expect(result.outcome).toBe("approve");
-		expect(result.appliedRule).toBeUndefined();
-	});
-
-	it("keeps a wait and a reject decision", () => {
-		expect(applyDecisionPolicy("wait", context()).outcome).toBe("wait");
-		expect(applyDecisionPolicy("reject", context()).outcome).toBe("reject");
-	});
-});