pi-harness-runtime 1.1.150 → 1.1.153

package/harness/service-diagnostics.ts

@@ -0,0 +1,217 @@
+/**
+ * Service Diagnostics - Structured logging for harness services
+ *
+ * Logs service events to ~/.pi-harness-runtime/logs/services.jsonl
+ * with structured data for observability.
+ */
+
+import { appendFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+export type ServiceLevel = "info" | "warn" | "error" | "debug";
+export type ServiceName = "jev" | "honcho" | "qdrant";
+
+export interface ServiceEvent {
+	ts: string;
+	level: ServiceLevel;
+	service: ServiceName;
+	operation: string;
+	phase: "start" | "completed" | "failed";
+	sessionId?: string;
+	requestId?: string;
+	durationMs?: number;
+	[key: string]: unknown;
+}
+
+const LOG_DIR = join(homedir(), ".pi-harness-runtime", "logs");
+const LOG_FILE = join(LOG_DIR, "services.jsonl");
+let _initialized = false;
+
+function ensureLogDir(): void {
+	if (_initialized) return;
+	if (!existsSync(LOG_DIR)) {
+		mkdirSync(LOG_DIR, { recursive: true });
+	}
+	_initialized = true;
+}
+
+/**
+ * Log a structured service event.
+ * Sensitive fields (keys, tokens, full content) are never logged.
+ */
+export function logServiceEvent(event: ServiceEvent): void {
+	ensureLogDir();
+
+	// Redact sensitive fields
+	const safeEvent = redactSensitive(event);
+
+	try {
+		appendFileSync(LOG_FILE, JSON.stringify(safeEvent) + "\n");
+	} catch {
+		// Silently fail if logging fails - don't crash the service
+	}
+}
+
+/**
+ * Redact sensitive fields from event data.
+ * Never log: apiKey, token, secret, chatId, content, vectors, embeddings
+ */
+function redactSensitive(event: ServiceEvent): Record<string, unknown> {
+	const sensitiveKeys = [
+		"apiKey",
+		"token",
+		"secret",
+		"bearerToken",
+		"chatId",
+		"content",
+		"vectors",
+		"embeddings",
+		"prompt",
+		"messages",
+		"raw",
+	];
+
+	const result: Record<string, unknown> = { ...event };
+
+	for (const key of Object.keys(result)) {
+		if (sensitiveKeys.some((sk) => key.toLowerCase().includes(sk.toLowerCase()))) {
+			result[key] = "[REDACTED]";
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Create a service status tracker.
+ */
+export class ServiceStatus {
+	private _configured = false;
+	private _initialized = false;
+	private _connected = false;
+	private _lastSuccessAt: string | null = null;
+	private _lastFailureAt: string | null = null;
+	private _lastErrorCode: string | null = null;
+	private _requests = 0;
+	private _successes = 0;
+	private _failures = 0;
+	private _featureEnabled = false;
+	private _service: ServiceName;
+
+	constructor(service: ServiceName) {
+		this._service = service;
+	}
+
+	get configured() { return this._configured; }
+	get initialized() { return this._initialized; }
+	get connected() { return this._connected; }
+	get lastSuccessAt() { return this._lastSuccessAt; }
+	get lastFailureAt() { return this._lastFailureAt; }
+	get lastErrorCode() { return this._lastErrorCode; }
+	get requests() { return this._requests; }
+	get successes() { return this._successes; }
+	get failures() { return this._failures; }
+	get featureEnabled() { return this._featureEnabled; }
+
+	setConfigured(v: boolean): this {
+		this._configured = v;
+		logServiceEvent({
+			ts: new Date().toISOString(),
+			level: "info",
+			service: this._service,
+			operation: "config_checked",
+			phase: "completed",
+			configured: v,
+		});
+		return this;
+	}
+
+	setInitialized(v: boolean): this {
+		this._initialized = v;
+		if (v) {
+			logServiceEvent({
+				ts: new Date().toISOString(),
+				level: "info",
+				service: this._service,
+				operation: "initialized",
+				phase: "completed",
+			});
+		}
+		return this;
+	}
+
+	setConnected(v: boolean): this {
+		this._connected = v;
+		logServiceEvent({
+			ts: new Date().toISOString(),
+			level: "info",
+			service: this._service,
+			operation: "connected",
+			phase: v ? "completed" : "failed",
+			connected: v,
+		});
+		return this;
+	}
+
+	setFeatureEnabled(v: boolean): this {
+		this._featureEnabled = v;
+		return this;
+	}
+
+	recordSuccess(operation: string, durationMs?: number, extra?: Record<string, unknown>): void {
+		this._requests++;
+		this._successes++;
+		this._lastSuccessAt = new Date().toISOString();
+		logServiceEvent({
+			ts: new Date().toISOString(),
+			level: "info",
+			service: this._service,
+			operation,
+			phase: "completed",
+			durationMs,
+			requests: this._requests,
+			successes: this._successes,
+			...extra,
+		});
+	}
+
+	recordFailure(operation: string, errorCode: string, extra?: Record<string, unknown>): void {
+		this._requests++;
+		this._failures++;
+		this._lastFailureAt = new Date().toISOString();
+		this._lastErrorCode = errorCode;
+		logServiceEvent({
+			ts: new Date().toISOString(),
+			level: "error",
+			service: this._service,
+			operation,
+			phase: "failed",
+			errorCode,
+			requests: this._requests,
+			failures: this._failures,
+			...extra,
+		});
+	}
+
+	toJSON(): Record<string, unknown> {
+		return {
+			service: this._service,
+			configured: this._configured,
+			initialized: this._initialized,
+			connected: this._connected,
+			lastSuccessAt: this._lastSuccessAt,
+			lastFailureAt: this._lastFailureAt,
+			lastErrorCode: this._lastErrorCode,
+			requests: this._requests,
+			successes: this._successes,
+			failures: this._failures,
+			featureEnabled: this._featureEnabled,
+		};
+	}
+}
+
+// Export service status instances
+export const jevStatus = new ServiceStatus("jev");
+export const honchoStatus = new ServiceStatus("honcho");
+export const qdrantStatus = new ServiceStatus("qdrant");

package/index.ts

@@ -103,6 +103,11 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 			return;
 		}
 
+		// Resolve the actual API key: env takes priority, file is fallback
+		const resolvedApiKey = process.env.TYPESAFE_API_KEY ||
+			process.env.OPENROUTER_API_KEY ||
+			readFileSync(`${keysDir}/jev-api-key.txt`, "utf8").trim();
+
 		const mod = await import("./packages/jev-judge/src/auto-continue.js");
 
 		// Track waiting state
@@ -111,10 +116,22 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 
 		// Detect when agent asks for continuation
 		pi.on("message_end", async (event) => {
-			const msg = event.message as { role?: string; content?: string } | undefined;
+			const msg = event.message as { role?: string; content?: string | Array<{ type?: string; text?: string }> } | undefined;
 			if (!msg || msg.role !== "assistant") return;
 
-			const content = typeof msg.content === "string" ? msg.content : "";
+			// Extract text from array content (TextContent blocks) or legacy string
+			let content = "";
+			if (typeof msg.content === "string") {
+				content = msg.content;
+			} else if (Array.isArray(msg.content)) {
+				// Extract text from TextContent blocks only; ignore thinking/tool calls
+				content = msg.content
+					.filter((block): block is { type: "text"; text: string } =>
+						block.type === "text" && typeof block.text === "string"
+					)
+					.map(block => block.text)
+					.join("\n");
+			}
 			const hasContinuation = /continue|proceed|next phase|next step/i.test(content);
 
 			if (hasContinuation && !waitingForUserSince) {
@@ -154,7 +171,7 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 
 			try {
 				const judge = new mod.AutoContinueJudge({
-					apiKey: process.env.TYPESAFE_API_KEY || process.env.OPENROUTER_API_KEY!,
+					apiKey: resolvedApiKey,
 					proceedThreshold: 0.7,
 					maxWaitMinutes: 30,
 				});
@@ -336,7 +353,7 @@ async function initHoncho(pi: { events: { emit(name: string, data: unknown): voi
 	const keyPath = `${home}/.pi-harness-runtime/keys/honcho-api-key.txt`;
 
 	if (!existsSync(keyPath)) {
-		logStartup("[pi-harness] Honcho memory not configured:");
+		logStartup("[pi-harness] Honcho not configured:");
 		logStartup("[pi-harness]   Get key: https://app.honcho.dev/api-keys");
 		logStartup(`[pi-harness]   Then: echo "{api-key}" > ~/.pi-harness-runtime/keys/honcho-api-key.txt`);
 		return;
@@ -356,12 +373,19 @@ async function initHoncho(pi: { events: { emit(name: string, data: unknown): voi
 				name: "honcho",
 				definition: {
 					url: "https://mcp.honcho.dev",
-					auth: { header: `Bearer ${apiKey}` },
+					auth: "bearer" as const,
+					bearerToken: apiKey,
 				},
 			};
+
+			// Emit registration request — pi-mcp-adapter will respond with
+			// pi-mcp-adapter:runtime-register-result event on completion
 			pi.events.emit("pi-mcp-adapter:runtime-register:v1", request);
+			console.log("[honcho] MCP registration emitted (awaiting adapter ack)");
 		});
-		logStartup("[pi-harness] Honcho memory ready (peer/user memory via mcp.honcho.dev)");
+
+		// Report pending state — actual memory active requires explicit lifecycle
+		logStartup("[pi-harness] Honcho registered (awaiting adapter connection)");
 	} catch (err) {
 		logStartup("[pi-harness] Honcho: init failed:", err instanceof Error ? err.message : String(err));
 	}
@@ -648,6 +672,27 @@ async function initFileCopyHelper(pi: ExtensionAPI): Promise<void> {
 	}
 }
 
+// --- agent-policy: Mandatory rule delivery and mutation gating ------------------
+// Lazy import - only loads when packages/agent-policy exists
+// This replaces firstAgentStart-only injection with:
+// - System prompt injection on EVERY agent start (not just first)
+// - Policy receipt tracking per session
+// - Mutation gating until policy revision is confirmed received
+// - harness_rules tool for rule retrieval and acknowledgement
+async function initAgentPolicy(pi: ExtensionAPI): Promise<void> {
+	try {
+		const { registerAgentPolicy } = await import("./packages/agent-policy/src/extension.js");
+		registerAgentPolicy(pi, {
+			harnessRulesPath: new URL("./AGENTS.md", import.meta.url),
+			requireReceiptBeforeMutation: true,
+			lspMode: "pi-lens",
+		});
+		logStartup("[pi-harness] Agent policy initialized");
+	} catch (err) {
+		logStartup(`[pi-harness] Agent policy init failed: ${err}`);
+	}
+}
+
 // --- SSH detach interceptor: Auto-transform bare ssh ... & to detached pattern ---
 // Prevents 2000+ second hangs when SSH background commands aren't detached.
 // Intercepts every bash tool call before execution and rewrites risky SSH commands.
@@ -1173,6 +1218,9 @@ export default function (pi: ExtensionAPI) {
 	// --- file-copy-helper: Inject cp rule when mimicking files -------------
 	void initFileCopyHelper(pi);
 
+	// --- agent-policy: Mandatory rule delivery and mutation gating -------------
+	void initAgentPolicy(pi);
+
 	// --- ssh-detach-interceptor: Auto-fix bare ssh & → nohup pattern ---------
 	void initSshDetachInterceptor(pi);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-harness-runtime",
-  "version": "1.1.150",
+  "version": "1.1.153",
   "description": "[BETA] Codex-style /usage status + autonomous coding harness for pi. Not production ready — expect breaking changes.",
   "type": "module",
   "scripts": {

package/packages/a2a-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/a2a-adapter",
-  "version": "1.1.150",
+  "version": "1.1.153",
   "type": "module",
   "description": "Google Agent-to-Agent (A2A) protocol adapter for pi-harness",
   "main": "dist/index.js",

package/packages/agent-policy/dist/extension.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Agent Policy Extension
+ *
+ * Registers the policy runtime with Pi's event system:
+ * - before_agent_start: inject system contract
+ * - tool_call: gate mutations until policy received
+ * - harness_rules tool: retrieve and acknowledge rules
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AgentPolicyConfig } from "./types.js";
+/**
+ * Register the agent policy runtime with Pi.
+ */
+export declare function registerAgentPolicy(pi: ExtensionAPI, config: AgentPolicyConfig): void;
+/**
+ * Register with default configuration pointing to harness AGENTS.md.
+ */
+export declare function registerDefault(pi: ExtensionAPI): void;
+//# sourceMappingURL=extension.d.ts.map

package/packages/agent-policy/dist/extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../src/extension.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,YAAY,EAIb,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EACV,iBAAiB,EAElB,MAAM,YAAY,CAAC;AAapB;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,YAAY,EAChB,MAAM,EAAE,iBAAiB,GACxB,IAAI,CA8SN;AA8DD;;GAEG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAQtD"}