pi-harness-runtime 1.1.49 → 1.1.71-3

package/packages/trajectory/src/store.ts

@@ -0,0 +1,285 @@
+/**
+ * TrajectoryStore — persists Trajectory records to `~/.pi-harness/trajectories/`.
+ *
+ * Format: newline-delimited JSON (NDJSON), one Trajectory per line.
+ * - Append-only writes (no locking needed for single-daemon writes)
+ * - Grep-friendly for manual inspection
+ * - Compact: no document overhead like JSON-array-with-commas
+ *
+ * File naming: `YYYY-MM/YYYY-MM-DD.ndjson`
+ * - Daily rotation keeps files small and manageable
+ * - Directory by month for easy archival
+ *
+ * Directory structure:
+ *   ~/.pi-harness/trajectories/
+ *     2025-07/
+ *       2025-07-14.ndjson
+ *       2025-07-15.ndjson
+ */
+
+import {
+	appendFileSync,
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { randomUUID } from "node:crypto";
+import type {
+	Trajectory,
+	TrajectorySummary,
+	TrajectoryStats,
+	TrajectoryClassification,
+	TrajectoryLabel,
+} from "./types.js";
+export type {
+	Trajectory,
+	TrajectorySummary,
+	TrajectoryStats,
+	TrajectoryClassification,
+	TrajectoryLabel,
+} from "./types.js";
+
+const DEFAULT_TRAJ_DIR = ".pi-harness/trajectories";
+
+function getTrajDir(dir?: string): string {
+	const base = dir ?? DEFAULT_TRAJ_DIR;
+	// Absolute paths (starting with / or ~) are used as-is
+	if (base.startsWith("/") || base.startsWith("~")) return base;
+	return join(homedir(), base);
+}
+
+function getDatePath(
+	dir: string,
+	timestamp: Date = new Date(),
+): { dir: string; file: string } {
+	const y = timestamp.getFullYear();
+	const m = String(timestamp.getMonth() + 1).padStart(2, "0");
+	const d = String(timestamp.getDate()).padStart(2, "0");
+	return {
+		dir: join(dir, `${y}-${m}`),
+		file: join(dir, `${y}-${m}`, `${y}-${m}-${d}.ndjson`),
+	};
+}
+
+/** Ensure the directory and daily file exist. */
+function ensureFile(file: string): void {
+	mkdirSync(dirname(file), { recursive: true });
+}
+
+/** Parse a single NDJSON line, skipping malformed lines. */
+function parseLine(line: string): Trajectory | null {
+	try {
+		return JSON.parse(line) as Trajectory;
+	} catch {
+		return null;
+	}
+}
+
+/** Read all trajectory files for a given directory. */
+function readTrajDir(dir: string): Trajectory[] {
+	if (!existsSync(dir)) return [];
+	const trajectories: Trajectory[] = [];
+	for (const entry of readdirSync(dir)) {
+		if (!entry.endsWith(".ndjson")) continue;
+		const content = readFileSync(join(dir, entry), "utf8");
+		for (const line of content.split("\n")) {
+			if (!line.trim()) continue;
+			const t = parseLine(line);
+			if (t) trajectories.push(t);
+		}
+	}
+	return trajectories;
+}
+
+/**
+ * TrajectoryStore — append-only persistence for write-review cycle records.
+ *
+ * Usage:
+ * ```ts
+ * const store = new TrajectoryStore();
+ *
+ * // At cycle start
+ * const id = store.start("fix the login bug");
+ *
+ * // At cycle finish
+ * store.append({
+ *   id,
+ *   taskRequest: "fix the login bug",
+ *   createdAt: new Date(startMs).toISOString(),
+ *   durationMs: Date.now() - startMs,
+ *   iterations: 2,
+ *   verdict: "approved",
+ *   reason: "reviewer approved",
+ *   plan: "...",
+ *   code: "...",
+ *   files: ["auth.ts"],
+ *   comments: [],
+ *   summary: "looks good",
+ *   classified: false,
+ * });
+ * ```
+ */
+export class TrajectoryStore {
+	private readonly _trajDir: string;
+
+	constructor(trajDir?: string) {
+		this._trajDir = getTrajDir(trajDir);
+	}
+
+	/** List all trajectories, newest first. */
+	list(): Trajectory[] {
+		if (!existsSync(this._trajDir)) return [];
+
+		const all: Trajectory[] = [];
+		for (const monthDir of readdirSync(this._trajDir)) {
+			const monthPath = join(this._trajDir, monthDir);
+			if (!existsSync(monthPath)) continue;
+			all.push(...readTrajDir(monthPath));
+		}
+		// Sort newest first
+		all.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+		return all;
+	}
+
+	/** Summaries only (lightweight list). */
+	listSummaries(): TrajectorySummary[] {
+		return this.list().map((t) => ({
+			id: t.id,
+			taskRequest: t.taskRequest,
+			createdAt: t.createdAt,
+			durationMs: t.durationMs,
+			iterations: t.iterations,
+			verdict: t.verdict,
+			reason: t.reason,
+			files: t.files,
+			classified: t.classified,
+		}));
+	}
+
+	/** Append a completed trajectory record. */
+	append(trajectory: Trajectory): void {
+		const { file } = getDatePath(this._trajDir, new Date(trajectory.createdAt));
+		ensureFile(file);
+		appendFileSync(file, JSON.stringify(trajectory) + "\n", "utf8");
+	}
+
+	/** Start a new trajectory — returns a UUID for the cycle. */
+	start(_request: string): string {
+		return randomUUID();
+	}
+
+	/** Build aggregate statistics. */
+	stats(): TrajectoryStats {
+		const all = this.list();
+		if (all.length === 0) {
+			return {
+				total: 0,
+				byVerdict: { approved: 0, blocked: 0, changes_requested: 0 },
+				byLabel: { converged: 0, stuck: 0, blocked: 0, "max-iterations": 0 },
+				avgIterations: 0,
+				avgDurationMs: 0,
+				byFile: {} as Record<string, number>,
+			};
+		}
+
+		const byVerdict: TrajectoryStats["byVerdict"] = {
+			approved: 0,
+			blocked: 0,
+			changes_requested: 0,
+		};
+		const byLabel: TrajectoryStats["byLabel"] = {
+			converged: 0,
+			stuck: 0,
+			blocked: 0,
+			"max-iterations": 0,
+		};
+		const byFile = {} as Record<string, number>;
+		let totalIterations = 0;
+		let totalDuration = 0;
+
+		for (const t of all) {
+			byVerdict[t.verdict] = (byVerdict[t.verdict] ?? 0) + 1;
+			totalIterations += t.iterations;
+			totalDuration += t.durationMs;
+
+			// Derive label from reason string
+			const label = classifyLabel(t);
+			byLabel[label] = (byLabel[label] ?? 0) + 1;
+
+			// Count files
+			for (const file of t.files) {
+				byFile[file] = (byFile[file] ?? 0) + 1;
+			}
+		}
+
+		return {
+			total: all.length,
+			byVerdict,
+			byLabel,
+			avgIterations: Math.round(totalIterations / all.length),
+			avgDurationMs: Math.round(totalDuration / all.length),
+			byFile,
+		};
+	}
+
+	/** Classify a single trajectory. */
+	classify(trajectory: Trajectory): TrajectoryClassification {
+		const label = classifyLabel(trajectory);
+		let confidence = 0.9;
+		let pattern: string | undefined;
+		let recommendation: string;
+
+		if (label === "converged") {
+			recommendation =
+				trajectory.iterations <= 2
+					? "Fast convergence — good pattern"
+					: "Slow but successful — consider review depth";
+		} else if (label === "stuck") {
+			confidence = 0.7;
+			pattern = "same-file-repeated";
+			recommendation =
+				"Loop stuck on same file. Consider pre-flight file analysis or splitting the task.";
+		} else if (label === "max-iterations") {
+			recommendation =
+				"Hit iteration cap. Increase maxIterations or simplify the task scope.";
+		} else {
+			recommendation = "Reviewer blocked — escalate to human.";
+		}
+
+		return {
+			trajectoryId: trajectory.id,
+			label,
+			confidence,
+			pattern,
+			recommendation,
+		};
+	}
+
+	/** Get trajectories by verdict (for training set building). */
+	byVerdict(verdict: Trajectory["verdict"]): Trajectory[] {
+		return this.list().filter((t) => t.verdict === verdict);
+	}
+}
+
+/** Derive a TrajectoryLabel from a Trajectory's reason string. */
+function classifyLabel(t: Trajectory): TrajectoryLabel {
+	const r = t.reason.toLowerCase();
+	if (r.includes("converged")) return "converged";
+	if (r.includes("max iterations")) return "max-iterations";
+	if (r.includes("stuck")) return "stuck";
+	if (t.verdict === "blocked") return "blocked";
+	return "converged"; // fallback
+}
+
+/** Singleton factory — one store per process. */
+let _store: TrajectoryStore | undefined;
+export function getTrajectoryStore(): TrajectoryStore {
+	if (!_store) _store = new TrajectoryStore();
+	return _store;
+}
+export function resetTrajectoryStore(): void {
+	_store = undefined;
+}

package/packages/trajectory/src/types.ts

@@ -0,0 +1,84 @@
+/**
+ * Trajectory types — structured write-review cycle records for learning.
+ *
+ * Each completed loop cycle produces one Trajectory entry. These are persisted
+ * to `~/.pi-harness/trajectories/` as newline-delimited JSON (NDJSON), one
+ * record per line. Simple, append-only, and grep-friendly.
+ */
+
+// Note: Verdict/Comment types imported in store.ts from write-review
+
+export interface Comment {
+	file?: string;
+	comment: string;
+	severity: "minor" | "major" | "critical";
+}
+
+/** A completed write-review loop cycle. */
+export interface Trajectory {
+	/** Stable UUID — generated at cycle start, persisted in state. */
+	id: string;
+	/** Original user request that triggered the loop. */
+	taskRequest: string;
+	/** ISO-8601 timestamp when the cycle started. */
+	createdAt: string;
+	/** Wall-clock duration in milliseconds. */
+	durationMs: number;
+	/** Number of write-review rounds completed. */
+	iterations: number;
+	/** Final verdict from the GPT reviewer. */
+	verdict: "approved" | "blocked" | "changes_requested";
+	/** Human-readable termination reason (from finishNode). */
+	reason: string;
+	/** Plan produced by the GPT planner. */
+	plan: string;
+	/** Final code output from the MiniMax coder. */
+	code: string;
+	/** Files mentioned in comments across all review iterations. */
+	files: string[];
+	/** All comments from the final review iteration. */
+	comments: Comment[];
+	/** Final review summary. */
+	summary: string;
+	/** Whether this trajectory was used for training/classification. */
+	classified: boolean;
+}
+
+/** Lightweight summary for list/aggregate queries. */
+export interface TrajectorySummary {
+	id: string;
+	taskRequest: string;
+	createdAt: string;
+	durationMs: number;
+	iterations: number;
+	verdict: Trajectory["verdict"];
+	reason: string;
+	files: string[];
+	classified: boolean;
+}
+
+/** Classification label applied by the trajectory classifier. */
+export type TrajectoryLabel =
+	| "converged"
+	| "stuck"
+	| "blocked"
+	| "max-iterations";
+
+/** Classification result for a trajectory. */
+export interface TrajectoryClassification {
+	trajectoryId: string;
+	label: TrajectoryLabel;
+	confidence: number; // 0–1
+	pattern?: string; // e.g. "same-file-repeated"
+	recommendation: string;
+}
+
+/** Aggregated statistics across a set of trajectories. */
+export interface TrajectoryStats {
+	total: number;
+	byVerdict: Record<Trajectory["verdict"], number>;
+	byLabel: Record<TrajectoryLabel, number>;
+	avgIterations: number;
+	avgDurationMs: number;
+	byFile: Record<string, number>; // file → comment count
+}

package/packages/trajectory/test/store.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=store.test.d.ts.map

package/packages/trajectory/test/store.test.ts

@@ -0,0 +1,250 @@
+import { describe, it, beforeEach } from "node:test";
+import assert from "node:assert";
+import { rmSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { TrajectoryStore, resetTrajectoryStore } from "../src/store.js";
+
+const TEST_DIR = join(homedir(), ".pi-harness-test-trajectories");
+
+function freshStore(): TrajectoryStore {
+	rmSync(TEST_DIR, { force: true, recursive: true });
+	mkdirSync(TEST_DIR, { recursive: true });
+	return new TrajectoryStore(TEST_DIR);
+}
+
+describe("TrajectoryStore", () => {
+	beforeEach(() => {
+		rmSync(TEST_DIR, { force: true, recursive: true });
+		mkdirSync(TEST_DIR, { recursive: true });
+		resetTrajectoryStore();
+	});
+
+	it("start() returns a UUID", () => {
+		const store = freshStore();
+		const id = store.start("test task");
+		assert.match(id, /^[0-9a-f-]{36}$/);
+	});
+
+	it("append() writes NDJSON to the correct daily file", () => {
+		const store = freshStore();
+		const id = "test-id-123";
+		const now = new Date();
+
+		store.append({
+			id,
+			taskRequest: "fix the login bug",
+			createdAt: now.toISOString(),
+			durationMs: 5000,
+			iterations: 2,
+			verdict: "approved",
+			reason: "reviewer approved",
+			plan: "# Plan\n1. Fix it",
+			code: "// fixed",
+			files: ["auth.ts"],
+			comments: [{ file: "auth.ts", comment: "looks good", severity: "minor" }],
+			summary: "looks good",
+			classified: false,
+		});
+
+		// Should have created a daily file
+		const files = readdirSync(TEST_DIR);
+		assert.ok(files.length > 0, "should create at least one directory");
+
+		// Navigate to the daily file
+		const monthDir = files[0];
+		const monthFiles = readdirSync(join(TEST_DIR, monthDir));
+		assert.ok(monthFiles.length > 0, "should create daily ndjson file");
+
+		const content = readFileSync(join(TEST_DIR, monthDir, monthFiles[0]), "utf8");
+		const record = JSON.parse(content.split("\n").find((l) => l.trim())!);
+		assert.strictEqual(record.id, id);
+		assert.strictEqual(record.verdict, "approved");
+		assert.strictEqual(record.iterations, 2);
+	});
+
+	it("list() returns records newest-first", () => {
+		const store = freshStore();
+
+		const id1 = store.start("task 1");
+		store.append({
+			id: id1,
+			taskRequest: "task 1",
+			createdAt: "2025-07-01T10:00:00.000Z",
+			durationMs: 1000,
+			iterations: 1,
+			verdict: "approved",
+			reason: "ok",
+			plan: "p1",
+			code: "c1",
+			files: [],
+			comments: [],
+			summary: "s1",
+			classified: false,
+		});
+
+		const id2 = store.start("task 2");
+		store.append({
+			id: id2,
+			taskRequest: "task 2",
+			createdAt: "2025-07-02T10:00:00.000Z",
+			durationMs: 2000,
+			iterations: 2,
+			verdict: "changes_requested",
+			reason: "converged: only minor comments",
+			plan: "p2",
+			code: "c2",
+			files: [],
+			comments: [],
+			summary: "s2",
+			classified: false,
+		});
+
+		const all = store.list();
+		assert.strictEqual(all.length, 2);
+		assert.strictEqual(all[0].id, id2, "newest first");
+		assert.strictEqual(all[1].id, id1);
+	});
+
+	it("stats() aggregates correctly", () => {
+		const store = freshStore();
+
+		store.append({
+			id: "s1",
+			taskRequest: "t1",
+			createdAt: "2025-07-01T10:00:00.000Z",
+			durationMs: 1000,
+			iterations: 1,
+			verdict: "approved",
+			reason: "reviewer approved",
+			plan: "p",
+			code: "c",
+			files: ["a.ts"],
+			comments: [],
+			summary: "s",
+			classified: false,
+		});
+
+		store.append({
+			id: "s2",
+			taskRequest: "t2",
+			createdAt: "2025-07-01T11:00:00.000Z",
+			durationMs: 3000,
+			iterations: 3,
+			verdict: "changes_requested",
+			reason: "max iterations (3) reached with changes still requested",
+			plan: "p",
+			code: "c",
+			files: ["a.ts", "b.ts"],
+			comments: [],
+			summary: "s",
+			classified: false,
+		});
+
+		const stats = store.stats();
+		assert.strictEqual(stats.total, 2);
+		assert.strictEqual(stats.byVerdict.approved, 1);
+		assert.strictEqual(stats.byVerdict.changes_requested, 1);
+		assert.strictEqual(stats.avgIterations, 2);
+		assert.strictEqual(stats.avgDurationMs, 2000);
+		assert.strictEqual(stats.byFile["a.ts"], 2);
+		assert.strictEqual(stats.byFile["b.ts"], 1);
+		assert.strictEqual(stats.byLabel["max-iterations"], 1);
+		assert.strictEqual(stats.byLabel["converged"], 1);
+	});
+
+	it("classify() returns correct label for converged", () => {
+		const store = freshStore();
+		const cls = store.classify({
+			id: "x",
+			taskRequest: "x",
+			createdAt: new Date().toISOString(),
+			durationMs: 1000,
+			iterations: 1,
+			verdict: "approved",
+			reason: "reviewer approved",
+			plan: "",
+			code: "",
+			files: [],
+			comments: [],
+			summary: "",
+			classified: false,
+		});
+		assert.strictEqual(cls.label, "converged");
+		assert.strictEqual(cls.trajectoryId, "x");
+	});
+
+	it("classify() returns stuck for same-file reason", () => {
+		const store = freshStore();
+		const cls = store.classify({
+			id: "y",
+			taskRequest: "y",
+			createdAt: new Date().toISOString(),
+			durationMs: 1000,
+			iterations: 2,
+			verdict: "changes_requested",
+			reason: "stuck: same file (auth.ts) flagged for 3 comment(s)",
+			plan: "",
+			code: "",
+			files: ["auth.ts"],
+			comments: [],
+			summary: "",
+			classified: false,
+		});
+		assert.strictEqual(cls.label, "stuck");
+		assert.strictEqual(cls.pattern, "same-file-repeated");
+		assert.ok(cls.confidence < 1.0);
+	});
+
+	it("byVerdict() filters correctly", () => {
+		const store = freshStore();
+		store.append({
+			id: "v1",
+			taskRequest: "v1",
+			createdAt: "2025-07-01T10:00:00.000Z",
+			durationMs: 1000,
+			iterations: 1,
+			verdict: "approved",
+			reason: "ok",
+			plan: "",
+			code: "",
+			files: [],
+			comments: [],
+			summary: "",
+			classified: false,
+		});
+		store.append({
+			id: "v2",
+			taskRequest: "v2",
+			createdAt: "2025-07-02T10:00:00.000Z",
+			durationMs: 1000,
+			iterations: 1,
+			verdict: "blocked",
+			reason: "blocked",
+			plan: "",
+			code: "",
+			files: [],
+			comments: [],
+			summary: "",
+			classified: false,
+		});
+
+		const approved = store.byVerdict("approved");
+		assert.strictEqual(approved.length, 1);
+		assert.strictEqual(approved[0].id, "v1");
+
+		const blocked = store.byVerdict("blocked");
+		assert.strictEqual(blocked.length, 1);
+		assert.strictEqual(blocked[0].id, "v2");
+	});
+
+	it("stats() handles empty store gracefully", () => {
+		rmSync(TEST_DIR, { force: true, recursive: true });
+		mkdirSync(TEST_DIR, { recursive: true });
+		// Remove the month dir so the store sees an empty directory
+		const store = freshStore();
+		const stats = store.stats();
+		assert.strictEqual(stats.total, 0);
+		assert.strictEqual(stats.avgIterations, 0);
+	});
+});

package/packages/tui/package.json

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

package/packages/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/types",
-  "version": "1.1.49",
+  "version": "1.1.71-3",
   "description": "Shared TypeScript types for pi-harness-runtime packages",
   "type": "module",
   "main": "./src/index.js",

package/packages/workflow-events/package.json

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

package/packages/workspace-scanner/package.json

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

package/packages/worktree/package.json

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

package/packages/write-review/package.json

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