pi-harness-runtime 1.1.152 → 1.1.153

package/harness/langchain/graph.ts

@@ -457,22 +457,22 @@ export async function buildRealLoopDeps(
 				});
 				const planOutput = lastMessage(plannerResponse) ?? "";
 
-				// Import and use Jev logger (async - logs to file + Telegram)
+				// Import and use planner logger (async - logs to file + Telegram)
 				try {
-					const { logJevDecision, parseJevDecision } = await import("./jev-logger.js");
-					const jevDecision = parseJevDecision(planOutput);
-					setJevProvider(jevDecision.provider);
-					await logJevDecision({
+					const { logPlannerDecision, parsePlannerDecision } = await import("./planner-logger.js");
+					const plannerDecision = parsePlannerDecision(planOutput);
+					setJevProvider(plannerDecision.provider);
+					await logPlannerDecision({
 						timestamp: new Date().toISOString(),
 						request,
-						provider: jevDecision.provider,
-						reason: jevDecision.reason,
-						userInput: jevDecision.userInput,
+						provider: plannerDecision.provider,
+						reason: plannerDecision.reason,
+						userInput: plannerDecision.userInput,
 						escalate: false,
 						raw: planOutput,
 					});
 				} catch (logErr) {
-					console.error("[JEV] Logger error:", (logErr as Error).message);
+					console.error("[PLANNER] Logger error:", (logErr as Error).message);
 				}
 
 				return planOutput;

package/harness/langchain/{jev-logger.ts → planner-logger.ts}

@@ -1,20 +1,21 @@
 /**
- * Jev Logger - Exclusive logging for Jev's decisions
+ * Planner Logger - Logs LangChain planner decisions
  *
- * Logs all Jev decisions:
+ * Logs planner output:
  * - Provider selection (minimax vs gpt)
  * - User input decisions
  * - Escalation triggers
  * - Reasoning
  *
- * Sends to both file and Telegram for real-time monitoring.
+ * NOTE: This logs the LangChain planner's output, not TypeSafe Jev service calls.
+ * The TypeSafe Jev service is tracked separately in the auto-continue system.
  */
 
 import { mkdirSync, appendFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 
-export interface JevDecision {
+export interface PlannerDecision {
 	timestamp: string;
 	request: string;
 	provider: "minimax" | "gpt";
@@ -27,12 +28,12 @@ export interface JevDecision {
 	escalateReason?: string;
 }
 
-export interface JevLogEntry extends JevDecision {
+export interface PlannerLogEntry extends PlannerDecision {
 	raw?: string; // Raw planner output for debugging
 }
 
 const LOG_DIR = join(homedir(), ".pi-harness-runtime", "logs");
-const LOG_FILE = join(LOG_DIR, "jev.log");
+const LOG_FILE = join(LOG_DIR, "planner.log");
 
 // Telegram config (loaded from environment)
 let TELEGRAM_BOT_TOKEN: string | undefined;
@@ -54,20 +55,20 @@ function ensureLogDir(): void {
 /**
  * Format decision for file log (detailed, multi-line)
  */
-function formatFileLog(entry: JevLogEntry): string {
+function formatFileLog(entry: PlannerLogEntry): string {
 	const lines = [
 		`═══════════════════════════════════════════════════════════════`,
-		`[JEV] ${entry.timestamp}`,
+		`[PLANNER] ${entry.timestamp}`,
 		`═══════════════════════════════════════════════════════════════`,
 		``,
 		`## Request`,
 		`${entry.request}`,
 		``,
-		`## Jev Provider Decision`,
+		`## Provider Decision`,
 		`Provider: ${entry.provider.toUpperCase()}`,
 		`Reason:   ${entry.reason}`,
 		``,
-		`## Jev User Input Decision`,
+		`## User Input Decision`,
 		`Type:     ${entry.userInput?.type ?? "none (proceed automatically)"}`,
 		entry.userInput?.question ? `Question: ${entry.userInput.question}` : ``,
 		``,
@@ -92,12 +93,12 @@ function formatFileLog(entry: JevLogEntry): string {
 /**
  * Format decision for Telegram (compact, single message)
  */
-function formatTelegramMessage(entry: JevLogEntry): string {
+function formatTelegramMessage(entry: PlannerLogEntry): string {
 	const providerIcon = entry.provider === "gpt" ? "🤖" : "⚡";
 	const escalateIcon = entry.escalate ? " ↑ ESCALATE" : "";
 
 	const parts = [
-		`${providerIcon} *JEV DECISION*`,
+		`${providerIcon} *PLANNER DECISION*`,
 		`\n*Provider:* ${entry.provider.toUpperCase()}${escalateIcon}`,
 		`\n*Reason:* ${entry.reason}`,
 	];
@@ -125,16 +126,16 @@ async function sendToTelegram(message: string): Promise<void> {
 	TELEGRAM_CHAT_ID = process.env.TELEGRAM_CHAT_ID ?? TELEGRAM_CHAT_ID;
 
 	if (!TELEGRAM_BOT_TOKEN || !TELEGRAM_CHAT_ID) {
-		console.log("[JEV] Telegram not configured - skipping");
+		console.log("[PLANNER] Telegram not configured - skipping");
 		return;
 	}
 
-	console.log(`[JEV] Telegram sending: ${TELEGRAM_BOT_TOKEN?.slice(0, 10)}... to ${TELEGRAM_CHAT_ID}`);
+	console.log(`[PLANNER] Telegram sending: ${TELEGRAM_BOT_TOKEN?.slice(0, 10)}... to ${TELEGRAM_CHAT_ID}`);
 	telegramQueue.push(message);
 
 	// Process queue sequentially
 	if (telegramSending) {
-		console.log("[JEV] Telegram already sending, queued");
+		console.log("[PLANNER] Telegram already sending, queued");
 		return;
 	}
 	telegramSending = true;
@@ -156,12 +157,12 @@ async function sendToTelegram(message: string): Promise<void> {
 			);
 
 			if (!response.ok) {
-				console.error(`[JEV] Telegram send failed: ${response.status}`);
+				console.error(`[PLANNER] Telegram send failed: ${response.status}`);
 			} else {
-				console.log("[JEV] Telegram sent successfully");
+				console.log("[PLANNER] Telegram sent successfully");
 			}
 		} catch (err) {
-			console.error(`[JEV] Telegram error:`, err);
+			console.error(`[PLANNER] Telegram error:`, err);
 		}
 		// Rate limit: 1 message per second
 		await new Promise((resolve) => setTimeout(resolve, 1000));
@@ -170,7 +171,7 @@ async function sendToTelegram(message: string): Promise<void> {
 	telegramSending = false;
 }
 
-export async function logJevDecision(decision: JevLogEntry): Promise<void> {
+export async function logPlannerDecision(decision: PlannerLogEntry): Promise<void> {
 	ensureLogDir();
 
 	// Always log to file (sync)
@@ -182,25 +183,25 @@ export async function logJevDecision(decision: JevLogEntry): Promise<void> {
 	const telegramMsg = formatTelegramMessage(decision);
 	// Fire-and-forget: don't await, let it run in background
 	sendToTelegram(telegramMsg).catch((err) => {
-		console.error("[JEV] Failed to send Telegram notification:", err);
+		console.error("[PLANNER] Failed to send Telegram notification:", err);
 	});
 	// Also await briefly for testing, then let process exit handle it
 	await new Promise((resolve) => setTimeout(resolve, 100));
 }
 
 /**
- * Parse Jev's decision from planner output
+ * Parse planner's decision from output
  * Looks for [JEVO] and [USER_INPUT] markers
  */
-export function parseJevDecision(planOutput: string): {
+export function parsePlannerDecision(planOutput: string): {
 	provider: "minimax" | "gpt";
 	reason: string;
-	userInput: JevDecision["userInput"];
+	userInput: PlannerDecision["userInput"];
 } {
 	const result: {
 		provider: "minimax" | "gpt";
 		reason: string;
-		userInput: JevDecision["userInput"];
+		userInput: PlannerDecision["userInput"];
 	} = {
 		provider: "minimax",
 		reason: "default (no explicit decision)",

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));
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-harness-runtime",
-  "version": "1.1.152",
+  "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.152",
+  "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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/agent-policy",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "description": "Agent policy runtime for pi-harness - enforces mandatory rule delivery and mutation gating",
   "type": "module",
   "main": "./dist/index.js",

package/packages/architecture-generator/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/architecture-generator",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "description": "Generate ADR and Mermaid diagrams from project analysis",
   "type": "module",
   "main": "./dist/index.js",

package/packages/auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/auth",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "description": "pi-harness-runtime — auth",
   "type": "module",
   "main": "./dist/index.js",

package/packages/autonomous-refactor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/autonomous-refactor",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "type": "module",
   "description": "Autonomous refactoring engine",
   "main": "dist/index.js",

package/packages/autonomous-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/autonomous-runtime",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "description": "Autonomous Operations Runtime — task inbox, lease management, and worker lifecycle (RFC-0101)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/cache-strategy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/cache-strategy",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "type": "module",
   "description": "Smart caching with TTL and invalidation strategies (RFC-0022)",
   "main": "dist/index.js",

package/packages/capability-registry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/capability-registry",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "description": "Capability Registry for pi-harness-runtime — tracks model capabilities and enables capability-based routing",
   "type": "module",
   "main": "./dist/index.js",

package/packages/checkpoint/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/checkpoint",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "description": "Enhanced checkpoint system with incremental snapshots, diff-based storage, and recovery strategies",
   "type": "module",
   "main": "./dist/index.js",

package/packages/cli-plugin-sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/cli-plugin-sdk",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "type": "module",
   "description": "CLI Plugin SDK for pi-harness — install, list, remove, update, invoke plugins",
   "main": "dist/index.js",

package/packages/clipboard/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/clipboard",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/clipboard-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/clipboard-plugin",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/code-generation/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/code-generation",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "description": "Code generation pipeline for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/code-review/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/code-review",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "description": "Automated code review engine for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/codex-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/codex-adapter",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "type": "module",
   "description": "OpenAI Codex provider adapter for pi-harness",
   "main": "dist/index.js",

package/packages/codex-watcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/codex-watcher",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "description": "Watches Codex CLI sessions and emits visible messages for PING-PONG monitoring",
   "type": "module",
   "main": "./dist/src/index.js",

package/packages/config-capture/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moocoding/config-capture",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "description": "Auto-capture API-fetched configuration values to AGENTS.md",
   "type": "module",
   "main": "src/index.ts",

package/packages/context-compiler/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/context-compiler",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "description": "Bounded context selection engine for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/context-discovery/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/context-discovery",
-  "version": "1.1.152",
+  "version": "1.1.153",
   "type": "module",
   "main": "src/index.ts",
   "exports": {