pi-harness-runtime 1.1.148 → 1.1.152

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [1.1.139](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.150...v1.1.139) (2026-10-05)
+
+
+### Features
+
+* **agent-policy:** Add mandatory policy delivery and mutation gating ([19d2399](https://github.com/ManotLuijiu/pi-harness-runtime/commit/19d23997d6de8e62bf97a67daf51b5cba42c9615))
+
 ### [1.1.138](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.147...v1.1.138) (2026-10-04)
 
 ### [1.1.75](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.95...v1.1.75) (2026-09-29)

package/harness/key-loader.ts

@@ -0,0 +1,84 @@
+/**
+ * Key Loader — Loads API keys from ~/.pi-harness-runtime/keys/ into process.env
+ *
+ * Usage:
+ *   import { loadKeys } from "./key-loader.js";
+ *   loadKeys(); // Loads all keys into process.env
+ *
+ * Environment variables set:
+ *   Telegram:    TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID, TELEGRAM_WEBHOOK_URL, TELEGRAM_WEBHOOK_SECRET
+ *   Models:      PLANNER_API_KEY, PLANNER_MODEL, PLANNER_BASE_URL
+ *                GLM_API_KEY
+ *                MINIMAX_API_KEY
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const KEYS_DIR = join(homedir(), ".pi-harness-runtime", "keys");
+
+const KEY_FILE_MAP: Record<string, string> = {
+	// Telegram notification keys
+	TELEGRAM_BOT_TOKEN: "telegram-bot-token.txt",
+	TELEGRAM_CHAT_ID: "telegram-chat-id.txt",
+	TELEGRAM_WEBHOOK_URL: "telegram-webhook-url.txt",
+	TELEGRAM_WEBHOOK_SECRET: "telegram-webhook-secret.txt",
+	// Model API keys (for daemon loop)
+	PLANNER_API_KEY: "planner-api-key.txt",
+	PLANNER_MODEL: "planner-model.txt",
+	PLANNER_BASE_URL: "planner-base-url.txt",
+	GLM_API_KEY: "glm-api-key.txt",
+	GLM_MODEL: "glm-model.txt",
+	GLM_BASE_URL: "glm-base-url.txt",
+	MINIMAX_API_KEY: "minimax-api-key.txt",
+	MINIMAX_MODEL: "minimax-model.txt",
+	MINIMAX_BASE_URL: "minimax-base-url.txt",
+};
+
+/**
+ * Load all keys from ~/.pi-harness-runtime/keys/ into process.env
+ * Only sets env vars that are not already set (allows CLI args to override)
+ */
+export function loadKeys(): void {
+	if (!existsSync(KEYS_DIR)) {
+		console.warn(`[key-loader] Keys directory not found: ${KEYS_DIR}`);
+		return;
+	}
+
+	let loadedCount = 0;
+	for (const [envVar, filename] of Object.entries(KEY_FILE_MAP)) {
+		// Skip if already set via environment
+		if (process.env[envVar]) {
+			console.log(`[key-loader] ${envVar} already set via env, skipping`);
+			continue;
+		}
+
+		const filePath = join(KEYS_DIR, filename);
+		if (existsSync(filePath)) {
+			const value = readFileSync(filePath, "utf8").trim();
+			if (value) {
+				process.env[envVar] = value;
+				loadedCount++;
+				console.log(`[key-loader] Loaded ${envVar} from ${filename}`);
+			}
+		}
+	}
+
+	if (loadedCount > 0) {
+		console.log(`[key-loader] Loaded ${loadedCount} key(s) from ${KEYS_DIR}`);
+	}
+}
+
+/**
+ * Get a specific key by name (without .txt extension)
+ */
+export function getKey(keyName: string): string | undefined {
+	const filePath = join(KEYS_DIR, `${keyName}.txt`);
+	if (existsSync(filePath)) {
+		return readFileSync(filePath, "utf8").trim();
+	}
+	return undefined;
+}
+
+export default loadKeys;

package/harness/langchain/agents.ts

@@ -37,9 +37,9 @@ export const ReviewVerdictSchema = z.object({
 	comments: z
 		.array(
 			z.object({
-				file: z.string().optional().describe("Affected file, if known"),
+				file: z.string().describe("Affected file, if known"),
 				comment: z.string().describe("Actionable change request"),
-				severity: z.enum(["critical", "major", "minor"]).optional(),
+				severity: z.enum(["critical", "major", "minor"]),
 			}),
 		)
 		.describe("Comments to send back to the coder (empty when approved)"),
@@ -92,16 +92,66 @@ permission to write code until finish without waiting for confirmation.
 // - If stuck, fail with a clear error, do not wait silently
 // - Output is consumed by the loop, not a human reading for guidance
 
-const PLANNER_PROMPT = `You are the Planning Agent (GPT) in an autonomous daemon loop.
+const PLANNER_PROMPT = `You are Jev - the intelligent Orchestrator in an autonomous daemon loop.
+
+## Your Role: Jev (Provider & Input Decision Engine)
+
+You make two types of decisions:
+
+### 1. Provider Selection (Who should handle this?)
+
+You have two agents available:
+- **MiniMax** (default): Fast, cheap, handles 90%+ of tasks
+- **GPT** (escalation): Powerful, for complex reasoning only
+
+**Use GPT only when task involves:**
+- Complex multi-file architecture decisions
+- Advanced concurrency/race condition debugging
+- Security-critical code requiring deep analysis
+- User explicitly requests: [use-gpt] or [use-gpt-only]
+- MiniMax reviewer says: "blocked" (escalate)
+
+**Default to MiniMax** for everything else.
+
+### 2. User Input Decision
+
+**Yes/No Choice** (type: "yesNo"): Binary decisions
+- "Should I use Option A or Option B?"
+- "Do you want me to proceed with this approach?"
+
+**Open Question** (type: "open"): Need descriptive input
+- "What would you like me to prioritize?"
+- "Describe your preferred coding style"
+
+**No User Input** (null): Proceed automatically
+
+## Your Task
 
 Given a feature request, produce a concise implementation plan: goals, non-goals,
-ordered steps, files to touch, risks, and a definition-of-done the GLM reviewer
-can check against.
+ordered steps, files to touch, risks, and a definition-of-done.
+
+## Output Format
+
+\`\`\`markdown
+# Implementation Plan
+...
+
+[JEVO]
+{"provider": "minimax" | "gpt", "reason": "..."}
+
+[USER_INPUT]
+{"type": "yesNo" | "open", "question": "...", "expectedFormat?": "..."}
+\`\`\`
+
+- [JEVO] is required - always specify your provider decision
+- [USER_INPUT] is optional - only if you need user input
+
+The loop will route based on your decisions.`;
 
-Output markdown only. Do NOT ask for confirmation. Do NOT output "Next Steps".
-The loop will route automatically.`;
+const CODER_PROMPT = `You are the Coding Agent in an autonomous daemon loop.
 
-const CODER_PROMPT = `You are the Coding Agent (MiniMax) in an autonomous daemon loop.
+Jev has selected the provider for this task based on task complexity.
+Write quality code regardless of which model is running.
 
 You receive a plan (and possibly review comments from a previous iteration) and
 edit the actual repository files using the available tools. Address every review
@@ -124,11 +174,11 @@ IMPORTANT:
 - If you cannot proceed, fail with a clear error message
 - Your output is consumed by the loop, not read by a human for guidance`;
 
-const REVIEWER_PROMPT = `You are the Master Code Review Agent (GLM) in an autonomous daemon loop.
+const REVIEWER_PROMPT = `You are the Master Code Review Agent in an autonomous daemon loop.
 
-You are the master reviewer. You review the MiniMax coder's output against the plan.
-Be strict: request changes only for real problems.  Output a structured verdict —
-the loop reads it automatically and routes MiniMax back to fix or approves.
+You review the coder's output against the plan. Be strict: request changes only for
+real problems. Output a structured verdict — the loop reads it automatically and
+routes the coder back to fix or approves.
 
 IMPORTANT:
 - Do NOT output "Next Steps" or "Looks good, waiting for approval"
@@ -136,7 +186,7 @@ IMPORTANT:
 - If you need clarification, fail with a clear error, do not wait silently
 - Respond via the structured schema`;
 
-const SUPERVISOR_PROMPT = `You are the Supervisor (GPT) in an autonomous daemon loop.
+const SUPERVISOR_PROMPT = `You are the Supervisor in an autonomous daemon loop.
 Coordinate the workflow automatically. The loop routes to the reviewer and back
 without human input.
 
@@ -283,7 +333,7 @@ export async function parallelReview(
 		comments: unknown[],
 		type: SpecialistType,
 	): {
-		file?: string;
+		file: string;
 		comment: string;
 		severity: "critical" | "major" | "minor";
 	}[] =>
@@ -294,7 +344,7 @@ export async function parallelReview(
 				severity?: "critical" | "major" | "minor";
 			};
 			return {
-				file: comment.file,
+				file: comment.file ?? "",
 				comment: `[${type}] ${comment.comment}`,
 				severity: comment.severity ?? "minor",
 			};

package/harness/langchain/daemon.ts

@@ -320,18 +320,18 @@ class InboxWatcher {
 		}
 	}
 
-	private _seedSeen(): void {
-		if (!existsSync(this.inboxDir)) return;
-		for (const file of readdirSync(this.inboxDir)) {
-			if (!file.endsWith(".md")) continue;
-			if (file.startsWith("ack-")) continue;
-			this.seen.set(file, {
-				taskId: file,
-				source: "inbox",
-				seenAt: new Date().toISOString(),
-			});
+		private _seedSeen(): void {
+				if (!existsSync(this.inboxDir)) return;
+				for (const file of readdirSync(this.inboxDir)) {
+						if (!file.endsWith(".md")) continue;
+						if (file.startsWith("ack-")) continue;
+						this.seen.set(file, {
+								taskId: file,
+								source: "inbox",
+								seenAt: new Date().toISOString(),
+						});
+				}
 		}
-	}
 
 	private _poll(onTask: (task: TriggeredTask) => void): void {
 		if (!this.running) return;
@@ -1123,7 +1123,7 @@ export class LoopDaemon {
 				);
 				if (!approved) {
 					log(`Human denied approval — parking task`);
-					this._notifyHumanReviewNeeded(
+					await this._notifyHumanReviewNeeded(
 						task,
 						"Human denied approval for task start",
 					);
@@ -1179,7 +1179,8 @@ export class LoopDaemon {
 				}
 				return undefined; // default MemorySaver
 			})();
-			const loop: WriteReviewLoop = buildWriteReviewLoop(deps, {
+			console.log(`[${loopId}] Using models - PLANNER=${process.env.PLANNER_MODEL} (${process.env.PLANNER_BASE_URL}), GLM=${process.env.GLM_MODEL} (${process.env.GLM_BASE_URL}), MINIMAX=${process.env.MINIMAX_MODEL} (${process.env.MINIMAX_BASE_URL})`);
+		const loop: WriteReviewLoop = buildWriteReviewLoop(deps, {
 				checkpointer,
 			});
 
@@ -1195,7 +1196,7 @@ export class LoopDaemon {
 							() =>
 								loop.invoke(
 									{ request: task.request },
-									{ configurable: { thread_id: loopId }, signal },
+									{ configurable: { thread_id: loopId }, signal, recursionLimit: 50 },
 								),
 							{
 								tickMs: 30_000,
@@ -1281,7 +1282,7 @@ export class LoopDaemon {
 					log("Task timed out — releasing lease and cleaning up");
 					this._releaseLease(task.taskId);
 					this.running.delete(task.taskId);
-					this._notifyHumanReviewNeeded(
+					await this._notifyHumanReviewNeeded(
 						task,
 						`Task timed out after ${this.config.taskTimeoutMs}ms — manual review needed`,
 					);
@@ -1398,18 +1399,18 @@ export class LoopDaemon {
 
 			// ── Notify on blocked / max-iterations ─────────────────────────────
 			if (verdict === "blocked") {
-				this._notifyHumanReviewNeeded(
+				await this._notifyHumanReviewNeeded(
 					task,
 					`Loop blocked: ${finalState.review?.summary ?? "no details"}`,
 				);
 			} else if (verdict === "changes_requested") {
-				this._notifyHumanReviewNeeded(
+				await this._notifyHumanReviewNeeded(
 					task,
 					`${iterations} iteration(s) exhausted with changes still requested: ${finalState.review?.comments.map((c) => c.comment).join("; ") ?? "no details"}`,
 				);
 			} else {
 				// approved
-				this._notifyReadyForClient(task);
+				await this._notifyReadyForClient(task);
 			}
 
 			// ── Notify agent of loop completion (TUI todo count) ───────────────
@@ -1535,19 +1536,33 @@ export class LoopDaemon {
 
 	// ─── Notifications ────────────────────────────────────────────────────
 
-	private _notifyHumanReviewNeeded(task: TriggeredTask, reason: string): void {
+	private async _notifyHumanReviewNeeded(task: TriggeredTask, reason: string): Promise<void> {
 		if (!this.notificationCenter) return;
 		console.log(`[daemon] Notifying HumanReviewNeeded: ${reason}`);
-		this.notificationCenter
-			.notify("HumanReviewNeeded", {
+		try {
+			const results = await this.notificationCenter.notify("HumanReviewNeeded", {
 				jobId: task.taskId,
 				requirement: task.request,
 				taskId: task.taskId,
 				error: reason,
-			})
-			.catch((err) => {
-				console.warn(`[daemon] Notification failed: ${err}`);
 			});
+			for (const result of results) {
+				if (!result.success) {
+					// Redact sensitive data — do not log token, chat ID, or full payload
+					const category = result.error?.includes("401") || result.error?.includes("403")
+						? "auth"
+						: result.error?.includes("400")
+							? "bad_request"
+							: result.error?.includes("429")
+								? "rate_limit"
+								: "unknown";
+					console.warn(`[daemon] Notification failed to ${result.channel} (${category}): ${result.error}`);
+				}
+			}
+		}
+		catch (err) {
+			console.warn(`[daemon] Notification threw: ${err}`);
+		}
 	}
 
 	private _closeBdIssue(taskId: string, verdict: string): void {
@@ -1571,18 +1586,31 @@ export class LoopDaemon {
 		}
 	}
 
-	private _notifyReadyForClient(task: TriggeredTask): void {
+	private async _notifyReadyForClient(task: TriggeredTask): Promise<void> {
 		if (!this.notificationCenter) return;
 		console.log(`[daemon] Notifying ReadyForClient`);
-		this.notificationCenter
-			.notify("ReadyForClient", {
+		try {
+			const results = await this.notificationCenter.notify("ReadyForClient", {
 				jobId: task.taskId,
 				requirement: task.request,
 				taskId: task.taskId,
-			})
-			.catch((err) => {
-				console.warn(`[daemon] Notification failed: ${err}`);
 			});
+			for (const result of results) {
+				if (!result.success) {
+					const category = result.error?.includes("401") || result.error?.includes("403")
+						? "auth"
+						: result.error?.includes("400")
+							? "bad_request"
+							: result.error?.includes("429")
+								? "rate_limit"
+								: "unknown";
+					console.warn(`[daemon] Notification failed to ${result.channel} (${category}): ${result.error}`);
+				}
+			}
+		}
+		catch (err) {
+			console.warn(`[daemon] Notification threw: ${err}`);
+		}
 	}
 
 	/**

package/harness/langchain/graph.ts

@@ -26,6 +26,17 @@ import {
 	type ReviewVerdict,
 	ReviewVerdictSchema,
 } from "./agents.js";
+
+// ─── Module-level state for Jev provider selection ──────────────────────────
+let _currentProvider: "minimax" | "gpt" = "minimax";
+
+export function setJevProvider(provider: "minimax" | "gpt"): void {
+	_currentProvider = provider;
+}
+
+export function getJevProvider(): "minimax" | "gpt" {
+	return _currentProvider;
+}
 import { readFileSync } from "node:fs";
 import { WriteReviewBlackboard } from "../../packages/write-review/src/blackboard.js";
 import { getApprovedPatternStore } from "../../packages/trajectory/src/index.js";
@@ -64,8 +75,26 @@ const LoopState = Annotation.Root({
 		reducer: (_prev, next) => next,
 		default: () => ({}),
 	}),
+	/** User input request - when Jev decides to ask the user.
+	 *  null = no user input needed (continue automatically)
+	 *  { type: "yesNo", question, choices? } = binary choice
+	 *  { type: "open", question, expectedFormat? } = free text response */
+	userInput: Annotation<UserInput | null>({
+		reducer: (_prev, next) => next,
+		default: () => null,
+	}),
+	/** User's response to the question */
+	userResponse: Annotation<string | null>({
+		reducer: (_prev, next) => next,
+		default: () => null,
+	}),
 });
 
+/** User input types that Jev can request */
+export type UserInput =
+	| { type: "yesNo"; question: string; yesLabel?: string; noLabel?: string }
+	| { type: "open"; question: string; expectedFormat?: string };
+
 export type LoopState = typeof LoopState.State;
 
 // ─── Dependencies (inject real agents or dry-run stubs) ─────────────────────
@@ -419,16 +448,35 @@ export async function buildRealLoopDeps(
 		maxIterations: options.maxIterations ?? 3,
 		onStep,
 		plan: async (request) => {
-			// P1-2: detect autonomy signal in the request and unlock full autonomous mode
-			_directive = isAutonomyRequest(request) ? autonomyDirective() : "";
-			return lastMessage(
-				await planner.invoke({
+				// P1-2: detect autonomy signal in the request and unlock full autonomous mode
+				_directive = isAutonomyRequest(request) ? autonomyDirective() : "";
+				const plannerResponse = await planner.invoke({
 					messages: [
 						{ role: "user", content: _directive + withScoreboard(request) },
 					],
-				}),
-			);
-		},
+				});
+				const planOutput = lastMessage(plannerResponse) ?? "";
+
+				// Import and use Jev logger (async - logs to file + Telegram)
+				try {
+					const { logJevDecision, parseJevDecision } = await import("./jev-logger.js");
+					const jevDecision = parseJevDecision(planOutput);
+					setJevProvider(jevDecision.provider);
+					await logJevDecision({
+						timestamp: new Date().toISOString(),
+						request,
+						provider: jevDecision.provider,
+						reason: jevDecision.reason,
+						userInput: jevDecision.userInput,
+						escalate: false,
+						raw: planOutput,
+					});
+				} catch (logErr) {
+					console.error("[JEV] Logger error:", (logErr as Error).message);
+				}
+
+				return planOutput;
+			},
 		write: async (plan, review) => {
 			const userMsg = review
 				? `## Plan\n${plan}\n\n## Review comments to address\n${review.comments