pi-harness-runtime 0.5.0 → 0.6.3-beta.13

package/harness/partial-recovery.ts

@@ -4,14 +4,20 @@
  * Persist and recover incomplete agent outputs.
  * Never loses partial response text.
  *
+ * Integration with CompactOrchestrator:
+ * - Saves partial artifacts during compact
+ * - Loads partial artifacts on retry
+ * - Merges partials for context injection
+ *
  * Artifact Layout:
  *   harness/partial/
- *     task_004/
- *       partial_001.md
- *       partial_002.md
- *       merged.md
- *       recovery_status.json
- *       files.json
+ *     job_xxx/
+ *       task_004/
+ *         partial_001.md
+ *         partial_002.md
+ *         merged.md
+ *         recovery_status.json
+ *         files.json
  */
 
 import {
@@ -24,6 +30,7 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { continuePromptGenerator } from "./continue-prompt.js";
 
 export interface PartialResponse {
 	id: string;
@@ -63,6 +70,8 @@ export class PartialRecovery {
 		this.loadExistingPartials();
 	}
 
+	// ─── Public API ───────────────────────────────────────────────────────────
+
 	/**
 	 * Save a partial response
 	 */
@@ -95,6 +104,21 @@ export class PartialRecovery {
 		return partial;
 	}
 
+	/**
+	 * Save partial from compact result
+	 */
+	saveFromCompact(summary: string, remainingWork: string[]): void {
+		const content = [
+			"## Compaction Summary",
+			summary,
+			"",
+			"## Remaining Work",
+			...remainingWork.map((w) => `- ${w}`),
+		].join("\n");
+
+		this.savePartial(content, "compaction", { type: "compact_summary" });
+	}
+
 	/**
 	 * Get all partial responses
 	 */
@@ -148,6 +172,27 @@ export class PartialRecovery {
 		return merged;
 	}
 
+	/**
+	 * Generate continue prompt from partials
+	 */
+	generateContinuePrompt(): string {
+		if (this.partials.length === 0) {
+			return "continue";
+		}
+
+		const merged = this.merge({ method: "markdown_sections" });
+		const recentWork = this.extractRecentWork(merged);
+
+		return continuePromptGenerator.generate({
+			taskId: this.taskId,
+			requirement: "Continue from partial work",
+			whatWasCompleted: this.extractCompletedWork(merged),
+			whatNeedsToBeDone: recentWork,
+			partialFiles: this.extractFileReferences(merged),
+			decisions: this.extractDecisions(merged),
+		});
+	}
+
 	/**
 	 * Load partials from a continuation prompt
 	 */
@@ -404,4 +449,83 @@ export class PartialRecovery {
 
 		return unique.join("\n");
 	}
+
+	private extractRecentWork(merged: string): string[] {
+		const work: string[] = [];
+
+		// Look for bullet points and remaining work
+		const lines = merged.split("\n");
+		for (const line of lines) {
+			if (line.match(/^[-*]\s/) && !line.includes("[completed]")) {
+				work.push(line.replace(/^[-*]\s/, "").trim());
+			}
+		}
+
+		return work.slice(0, 10);
+	}
+
+	private extractCompletedWork(merged: string): string[] {
+		const completed: string[] = [];
+
+		const lines = merged.split("\n");
+		for (const line of lines) {
+			if (line.match(/^[-*]\s/) && line.includes("[completed]")) {
+				completed.push(
+					line
+						.replace(/^[-*]\s/, "")
+						.replace("[completed]", "")
+						.trim(),
+				);
+			}
+		}
+
+		return completed.slice(0, 10);
+	}
+
+	private extractFileReferences(merged: string): string[] {
+		const files: string[] = [];
+
+		// Look for file paths
+		const patterns = [
+			/[A-Za-z]:\\[\w\\]+(?:\.\w+)?/g, // Windows
+			/\/[\w./-]+(?:\.\w+)?/g, // Unix
+		];
+
+		for (const pattern of patterns) {
+			for (const match of merged.matchAll(pattern)) {
+				if (match[0] && !files.includes(match[0])) {
+					files.push(match[0]);
+				}
+			}
+		}
+
+		return files.slice(0, 20);
+	}
+
+	private extractDecisions(merged: string): string[] {
+		const decisions: string[] = [];
+
+		// Look for decision markers
+		const lines = merged.split("\n");
+		for (const line of lines) {
+			if (line.match(/(?:decision|decided|chose|using):/i)) {
+				decisions.push(line.replace(/^[-*]\s*/, "").trim());
+			}
+		}
+
+		return decisions.slice(0, 5);
+	}
+}
+
+// ─── Factory ────────────────────────────────────────────────────────────────
+
+/**
+ * Create a PartialRecovery manager for a task
+ */
+export function createPartialRecovery(
+	jobId: string,
+	taskId: string,
+	rootDir?: string,
+): PartialRecovery {
+	return new PartialRecovery(jobId, taskId, rootDir);
 }

package/harness/session-memory.ts

@@ -0,0 +1,401 @@
+/**
+ * Session Memory — Persistent Knowledge Extraction
+ *
+ * Extracts key facts and decisions to persistent storage.
+ * On resume, re-injects memory as context without re-sending full history.
+ *
+ * Based on the reference implementation's sessionMemoryCompact pattern.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { CompactableMessage } from "../packages/types/src/runtime-types.js";
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+export interface SessionMemory {
+	jobId: string;
+	extractedFacts: string[];
+	decisions: Decision[];
+	filesModified: FileReference[];
+	testsStatus: TestResult[];
+	artifacts: Record<string, string>;
+	lastUpdated: string;
+}
+
+export interface Decision {
+	text: string;
+	rationale?: string;
+	timestamp: string;
+}
+
+export interface FileReference {
+	path: string;
+	action: "created" | "modified" | "deleted";
+	timestamp: string;
+}
+
+export interface TestResult {
+	name: string;
+	passed: boolean;
+	timestamp: string;
+}
+
+// ─── Session Memory Manager ─────────────────────────────────────────────────
+
+export class SessionMemoryManager {
+	private memory: SessionMemory;
+	private readonly memoryPath: string;
+	private readonly maxFacts = 50;
+	private readonly maxDecisions = 20;
+
+	constructor(jobId: string, rootDir?: string) {
+		this.memoryPath = join(
+			rootDir ?? join(process.env.HOME ?? ".", ".pi", "harness", jobId),
+			"session-memory.json",
+		);
+
+		this.memory = this.load() ?? {
+			jobId,
+			extractedFacts: [],
+			decisions: [],
+			filesModified: [],
+			testsStatus: [],
+			artifacts: {},
+			lastUpdated: new Date().toISOString(),
+		};
+	}
+
+	// ─── Public API ───────────────────────────────────────────────────────────
+
+	/**
+	 * Extract key facts from recent messages
+	 */
+	extractFacts(messages: CompactableMessage[]): void {
+		for (const msg of messages) {
+			const content = msg.content;
+
+			// File creation patterns
+			for (const match of content.matchAll(
+				/(?:created|created file|created module):?\s*([^\n.]+)/gi,
+			)) {
+				if (match[1]) {
+					this.addFileReference(match[1].trim(), "created");
+				}
+			}
+
+			// File modification patterns
+			for (const match of content.matchAll(
+				/(?:modified|updated|changed):?\s*([^\n.]+)/gi,
+			)) {
+				if (match[1] && !/(?:file|module|code)/i.test(match[0])) {
+					this.addFileReference(match[1].trim(), "modified");
+				}
+			}
+
+			// Test result patterns
+			for (const match of content.matchAll(
+				/(?:test|spec):?\s*([^\n.]+)\s*(passed|failed|pass|fail)/gi,
+			)) {
+				if (match[1] && match[2]) {
+					this.addTestResult(match[1].trim(), /^pass$/i.test(match[2]));
+				}
+			}
+
+			// Decision patterns
+			for (const match of content.matchAll(
+				/(?:decided|choosing|chose|decision|approach|using):?\s*([^\n.]+)/gi,
+			)) {
+				if (match[1] && match[1].length > 10) {
+					this.recordDecision(match[1].trim());
+				}
+			}
+
+			// Key facts patterns
+			for (const match of content.matchAll(
+				/(?:important|key|note|facts?:)\s*([^\n]+)/gi,
+			)) {
+				if (match[1] && match[1].length > 20) {
+					this.recordFact(match[1].trim());
+				}
+			}
+		}
+
+		this.memory.lastUpdated = new Date().toISOString();
+		this.save();
+	}
+
+	/**
+	 * Add a decision to memory
+	 */
+	recordDecision(text: string, rationale?: string): void {
+		// Avoid exact duplicates
+		if (this.memory.decisions.some((d) => d.text === text)) {
+			return;
+		}
+
+		this.memory.decisions.push({
+			text,
+			rationale,
+			timestamp: new Date().toISOString(),
+		});
+
+		// Trim to max
+		if (this.memory.decisions.length > this.maxDecisions) {
+			this.memory.decisions = this.memory.decisions.slice(-this.maxDecisions);
+		}
+
+		this.save();
+	}
+
+	/**
+	 * Add a fact to memory
+	 */
+	recordFact(fact: string): void {
+		// Avoid duplicates
+		if (this.memory.extractedFacts.includes(fact)) {
+			return;
+		}
+
+		this.memory.extractedFacts.push(fact);
+
+		// Trim to max
+		if (this.memory.extractedFacts.length > this.maxFacts) {
+			this.memory.extractedFacts = this.memory.extractedFacts.slice(
+				-this.maxFacts,
+			);
+		}
+
+		this.save();
+	}
+
+	/**
+	 * Add a file reference
+	 */
+	addFileReference(
+		path: string,
+		action: "created" | "modified" | "deleted",
+	): void {
+		// Avoid exact duplicates
+		if (this.memory.filesModified.some((f) => f.path === path)) {
+			return;
+		}
+
+		this.memory.filesModified.push({
+			path,
+			action,
+			timestamp: new Date().toISOString(),
+		});
+
+		this.save();
+	}
+
+	/**
+	 * Add a test result
+	 */
+	addTestResult(name: string, passed: boolean): void {
+		this.memory.testsStatus.push({
+			name,
+			passed,
+			timestamp: new Date().toISOString(),
+		});
+		this.save();
+	}
+
+	/**
+	 * Store an artifact (e.g., generated code snippet)
+	 */
+	storeArtifact(key: string, content: string): void {
+		this.memory.artifacts[key] = content;
+		this.save();
+	}
+
+	/**
+	 * Get memory for re-injection as context
+	 */
+	getMemoryForContext(): string {
+		const parts: string[] = [];
+
+		// Files modified
+		if (this.memory.filesModified.length > 0) {
+			parts.push("## Files Modified");
+			for (const file of this.memory.filesModified.slice(-10)) {
+				parts.push(`- [${file.action}] ${file.path}`);
+			}
+			parts.push("");
+		}
+
+		// Key decisions
+		if (this.memory.decisions.length > 0) {
+			parts.push("## Key Decisions");
+			for (const decision of this.memory.decisions.slice(-5)) {
+				parts.push(`- ${decision.text}`);
+				if (decision.rationale) {
+					parts.push(`  Reason: ${decision.rationale}`);
+				}
+			}
+			parts.push("");
+		}
+
+		// Extracted facts
+		if (this.memory.extractedFacts.length > 0) {
+			parts.push("## Key Facts");
+			for (const fact of this.memory.extractedFacts.slice(-10)) {
+				parts.push(`- ${fact}`);
+			}
+			parts.push("");
+		}
+
+		// Test status
+		if (this.memory.testsStatus.length > 0) {
+			const passed = this.memory.testsStatus.filter((t) => t.passed).length;
+			const total = this.memory.testsStatus.length;
+			parts.push(`## Tests: ${passed}/${total} passed`);
+			parts.push("");
+		}
+
+		if (parts.length === 0) {
+			return "";
+		}
+
+		return ["## Session Memory", "", ...parts.slice(0, -1)].join("\n");
+	}
+
+	/**
+	 * Get compact-worthy content (for session memory compaction)
+	 */
+	getCompactContent(): string {
+		const lines: string[] = [];
+
+		if (this.memory.filesModified.length > 0) {
+			lines.push("Files modified:");
+			for (const file of this.memory.filesModified) {
+				lines.push(`  ${file.action}: ${file.path}`);
+			}
+		}
+
+		if (this.memory.decisions.length > 0) {
+			lines.push("Decisions:");
+			for (const d of this.memory.decisions) {
+				lines.push(`  - ${d.text}`);
+			}
+		}
+
+		if (this.memory.extractedFacts.length > 0) {
+			lines.push("Facts:");
+			for (const f of this.memory.extractedFacts) {
+				lines.push(`  - ${f}`);
+			}
+		}
+
+		return lines.join("\n");
+	}
+
+	/**
+	 * Get test summary
+	 */
+	getTestSummary(): string {
+		const passed = this.memory.testsStatus.filter((t) => t.passed).length;
+		const total = this.memory.testsStatus.length;
+		return `${passed}/${total}`;
+	}
+
+	/**
+	 * Check if all tests passed
+	 */
+	allTestsPassed(): boolean {
+		return (
+			this.memory.testsStatus.length > 0 &&
+			this.memory.testsStatus.every((t) => t.passed)
+		);
+	}
+
+	/**
+	 * Clear memory (e.g., after successful task completion)
+	 */
+	clear(): void {
+		this.memory.extractedFacts = [];
+		this.memory.decisions = [];
+		this.memory.filesModified = [];
+		this.memory.testsStatus = [];
+		this.memory.artifacts = {};
+		this.memory.lastUpdated = new Date().toISOString();
+		this.save();
+	}
+
+	/**
+	 * Get raw memory object
+	 */
+	getMemory(): SessionMemory {
+		return { ...this.memory };
+	}
+
+	/**
+	 * Update from another memory object (for merge on resume)
+	 */
+	merge(other: Partial<SessionMemory>): void {
+		if (other.extractedFacts) {
+			for (const fact of other.extractedFacts) {
+				if (!this.memory.extractedFacts.includes(fact)) {
+					this.memory.extractedFacts.push(fact);
+				}
+			}
+		}
+
+		if (other.decisions) {
+			for (const decision of other.decisions) {
+				if (!this.memory.decisions.some((d) => d.text === decision.text)) {
+					this.memory.decisions.push(decision);
+				}
+			}
+		}
+
+		if (other.filesModified) {
+			for (const file of other.filesModified) {
+				if (!this.memory.filesModified.some((f) => f.path === file.path)) {
+					this.memory.filesModified.push(file);
+				}
+			}
+		}
+
+		this.memory.lastUpdated = new Date().toISOString();
+		this.save();
+	}
+
+	// ─── Private Methods ──────────────────────────────────────────────────
+
+	private load(): SessionMemory | null {
+		if (!existsSync(this.memoryPath)) {
+			return null;
+		}
+		try {
+			return JSON.parse(readFileSync(this.memoryPath, "utf-8"));
+		} catch {
+			return null;
+		}
+	}
+
+	private save(): void {
+		const dir = this.memoryPath.substring(0, this.memoryPath.lastIndexOf("/"));
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+		writeFileSync(
+			this.memoryPath,
+			JSON.stringify(this.memory, null, 2),
+			"utf-8",
+		);
+	}
+}
+
+// ─── Factory ────────────────────────────────────────────────────────────────
+
+/**
+ * Create a SessionMemoryManager for a job
+ */
+export function createSessionMemoryManager(
+	jobId: string,
+	rootDir?: string,
+): SessionMemoryManager {
+	return new SessionMemoryManager(jobId, rootDir);
+}