pi-harness-runtime 1.1.152 → 1.1.154

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

@@ -78,6 +78,48 @@ import {
 
 // --- Jev Auto-Continue: Agent autonomous decision-making --------------------
 // Lazy import - only loads when packages/jev-judge exists and API key available
+
+/**
+ * Get tasks from bd (beads) for Jev decision context.
+ * Returns { completed, remaining } arrays of task descriptions.
+ */
+async function getTaskContext(): Promise<{
+	completed: string[];
+	remaining: string[];
+	total: number;
+}> {
+	try {
+		const { execSync } = await import("node:child_process");
+		// Get open (pending + in_progress) tasks
+		const output = execSync("bd list --json 2>/dev/null", {
+			encoding: "utf8",
+			timeout: 5000,
+		});
+		const tasks = JSON.parse(output) as Array<{ title?: string; status?: string }>;
+
+		const completed: string[] = [];
+		const remaining: string[] = [];
+
+		for (const task of tasks ?? []) {
+			if (!task.title) continue;
+			if (task.status === "closed" || task.status === "done") {
+				completed.push(task.title);
+			} else {
+				remaining.push(task.title);
+			}
+		}
+
+		return {
+			completed,
+			remaining,
+			total: completed.length + remaining.length,
+		};
+	} catch {
+		// bd not available or error - return empty context
+		return { completed: [], remaining: [], total: 0 };
+	}
+}
+
 async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 	try {
 		// Check if Jev API key is available (env var or keys file)
@@ -103,18 +145,38 @@ 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
 		let waitingForUserSince: Date | null = null;
 		let lastUserMessage: Date | null = null;
+		let autoContinueTimer: NodeJS.Timeout | null = null;
+		let _inferenceInProgress = false; // Track for overlap prevention
+		let _sessionId = Date.now().toString(36); // Track session for cancellation
 
 		// 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) {
@@ -145,29 +207,64 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 		const MIN_WAIT_MINUTES = 5; // Minimum wait before auto-continue
 
 		const checkAndAutoContinue = async () => {
+			// Prevent overlap if inference is already in progress
+			if (_inferenceInProgress) {
+				console.log("[auto-continue] Inference in progress, skipping this check");
+				return;
+			}
+
 			if (!waitingForUserSince) return;
 
+			// Capture session ID at check time for post-inference validation
+			const checkSessionId = _sessionId;
+
 			const waitMinutes = (Date.now() - waitingForUserSince.getTime()) / 60000;
 			if (waitMinutes < MIN_WAIT_MINUTES) return;
 
 			console.log(`[auto-continue] Checking after ${waitMinutes.toFixed(0)} minutes wait...`);
 
 			try {
+				// Mark inference as in progress to prevent overlap
+				_inferenceInProgress = true;
+
 				const judge = new mod.AutoContinueJudge({
-					apiKey: process.env.TYPESAFE_API_KEY || process.env.OPENROUTER_API_KEY!,
+					apiKey: resolvedApiKey,
 					proceedThreshold: 0.7,
 					maxWaitMinutes: 30,
 				});
 
+				// Get real task context from bd
+				const taskContext = await getTaskContext();
+
+				// Guard against empty task list
+				if (taskContext.total === 0) {
+					console.log("[auto-continue] No tasks to decide on — skipping");
+					_inferenceInProgress = false;
+					return;
+				}
+
 				const taskState = mod.createTaskState(
-					[], // completed tasks
-					[], // remaining tasks
+					taskContext.completed,
+					taskContext.remaining,
 					lastUserMessage || undefined,
 					new Date(Date.now() - waitMinutes * 60000),
 				);
 
 				const decision = await judge.decide(taskState);
 
+				// Check session validity and user response before applying
+				if (checkSessionId !== _sessionId) {
+					console.log("[auto-continue] Session changed during inference — cancelling");
+					_inferenceInProgress = false;
+					return;
+				}
+
+				if (!waitingForUserSince) {
+					console.log("[auto-continue] User responded during inference — cancelling");
+					_inferenceInProgress = false;
+					return;
+				}
+
 				console.log(
 					`[auto-continue] Decision: ${decision.action} (${(decision.probability * 100).toFixed(0)}% confidence)`,
 				);
@@ -197,7 +294,7 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 		};
 
 		// Start periodic check
-		setInterval(checkAndAutoContinue, AUTO_CONTINUE_INTERVAL_MS);
+		autoContinueTimer = setInterval(checkAndAutoContinue, AUTO_CONTINUE_INTERVAL_MS);
 
 		console.error("[auto-continue] Jev Auto-Continue initialized");
 	} catch {
@@ -336,7 +433,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 +453,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.154",
   "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.154",
   "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.154",
   "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.154",
   "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.154",
   "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.154",
   "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.154",
   "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.154",
   "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.154",
   "description": "Capability Registry for pi-harness-runtime — tracks model capabilities and enables capability-based routing",
   "type": "module",
   "main": "./dist/index.js",