pi-harness-runtime 1.1.50 → 1.1.77

package/harness/langchain/daemon.ts

@@ -27,8 +27,16 @@
  */
 
 import { randomUUID } from "node:crypto";
-import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import {
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	writeFileSync,
+} from "node:fs";
+import { execSync } from "node:child_process";
 import { join } from "node:path";
+import { homedir } from "node:os";
 
 import { LeaseManager } from "../../packages/autonomous-runtime/src/lease.js";
 import type { ApprovalClass } from "../../packages/autonomous-runtime/src/types.js";
@@ -47,11 +55,21 @@ import {
 } from "../../packages/event-bus/src/herdr-bus.js";
 import { NotificationCenter } from "../../packages/notification/dist/notification-center.js";
 
-import { invokeWithSurgeRetry, type SurgePolicy } from "./surge.js";
+import {
+	invokeWithSurgeRetry,
+	invokeWithGLMRetry,
+	SurgeScheduler,
+	type SurgePolicy,
+} from "./surge.js";
 import type { LoopWidget } from "./widget.js";
 import { StatusLineManager, isPiLensAvailable } from "./status-line.js";
 import { createLoopCheckpointer } from "./checkpointer.js";
 
+import {
+	getTrajectoryStore,
+	getApprovedPatternStore,
+} from "../../packages/trajectory/src/index.js";
+
 import {
 	buildDryRunDeps,
 	buildRealLoopDeps,
@@ -819,7 +837,7 @@ export class LoopDaemon {
 			surgePolicy: config.surgePolicy,
 			taskTimeoutMs: config.taskTimeoutMs,
 			checkpointer: config.checkpointer,
-			sources: config.sources ?? ["inbox", "bus"],
+			sources: config.sources ?? ["inbox", "bus"], // bd-tasks is opt-in: add it only for harness-managed bd issues
 			workspace: config.workspace ?? getHerdrWorkspace(),
 			notificationConfig: config.notificationConfig ?? undefined,
 			tunnelCommand: config.tunnelCommand,
@@ -974,6 +992,8 @@ export class LoopDaemon {
 			console.error(
 				`[daemon] Task ${task.taskId} failed: ${err instanceof Error ? err.message : String(err)}`,
 			);
+			// Release lease so the task can be picked up again on next poll
+			this._releaseLease(task.taskId);
 			this.running.delete(task.taskId);
 		});
 	}
@@ -1025,6 +1045,7 @@ export class LoopDaemon {
 					: await buildRealLoopDeps({
 							maxIterations: this.config.maxIterations,
 							blackboardDir: this.bus.getWorkspace(),
+							request: task.request,
 						}));
 
 			// Inject transition publishing into onStep (also drives the widget)
@@ -1035,6 +1056,11 @@ export class LoopDaemon {
 				this._updateWidget(step, state);
 			};
 
+			// ── Trajectory capture (M7a) ──────────────────────────────────────────
+			const store = getTrajectoryStore();
+			const trajId = store.start(task.request);
+			const trajStartMs = Date.now();
+
 			// ── Run the graph (surge-aware: 529/overloaded pauses auto-resume) ──
 			log(
 				`Starting write-review loop (maxIterations=${this.config.maxIterations})`,
@@ -1055,24 +1081,77 @@ export class LoopDaemon {
 			})();
 			const loop: WriteReviewLoop = buildWriteReviewLoop(deps, { checkpointer });
 
+			// Persistent scheduler: attempt counter survives across multiple loop.invoke()
+			// calls within the same task. This enables true exponential escalation
+			// for the 2nd, 3rd, ... surge — attempt 1 waits ~3min, attempt 2 waits ~6min, etc.
+			const surgeScheduler = new SurgeScheduler(this.config.surgePolicy);
+
 			const invokeTask = (signal?: AbortSignal) =>
 				invokeWithSurgeRetry(
 					() =>
-						loop.invoke(
-							{ request: task.request },
-							{ configurable: { thread_id: loopId }, signal },
+						invokeWithGLMRetry(
+							() =>
+								loop.invoke(
+									{ request: task.request },
+									{ configurable: { thread_id: loopId }, signal },
+								),
+							{
+								tickMs: 30_000,
+								onGLMQuota: (signal) => {
+									const secs = Math.max(
+										0,
+										Math.round((signal.resetAtEpoch - Date.now()) / 1000),
+									);
+									const mins = Math.floor(secs / 60);
+									const remSecs = secs % 60;
+									const countdown =
+										mins > 0
+											? ` (resets in ${mins}m ${remSecs}s)`
+											: ` (resets in ${remSecs}s)`;
+									log(`GLM quota exhausted${countdown}`);
+									this.widget?.setSurgePause(new Date(signal.resetAt));
+									this.statusLine?.updateLoopStatus(
+										`[Q] GLM quota — resets${countdown}`,
+									);
+								},
+								onGLMRetry: () => {
+									log("GLM quota window reached — retrying loop");
+								},
+							},
 						),
 					{
 						policy: this.config.surgePolicy,
+						scheduler: surgeScheduler,
 						onSurge: ({ attempt, delayMs }) =>
 							log(
 								`Provider surge (529) — resume in ${Math.round(delayMs / 1000)}s (attempt ${attempt})`,
 							),
-						onExhausted: () => {
-							this._notifyHumanReviewNeeded(
-								task,
-								"Provider surged past max surge attempts — task failed",
+						onExhausted: async () => {
+							// Escalating backoff: when all internal surge retries are exhausted,
+							// sleep for N × 3min (N = number of surges seen so far), then retry.
+							// Surge 1: sleep 3min → retry. Surge 2: sleep 6min → retry. etc.
+							const p = {
+								...{
+									multiplier: 2,
+									minDelayMs: 30_000,
+									maxDelayMs: 15 * 60_000,
+									jitterRatio: 0.2,
+									maxAttempts: 5,
+								},
+								...this.config.surgePolicy,
+							};
+							const baseDelayMs = 3 * 60_000; // midpoint of "recovers within 1-5 minutes"
+							const surgeCount = surgeScheduler.attempts; // how many surges already handled
+							const waitMs = Math.min(
+								baseDelayMs * surgeCount,
+								p.maxDelayMs ?? 15 * 60_000,
 							);
+							const waitMins = Math.round(waitMs / 60_000);
+							log(
+								`All ${p.maxAttempts} surge retries exhausted (${surgeCount} surges seen) — escalating wait to ${waitMins}m before retrying.`,
+							);
+							await new Promise<void>((resolve) => setTimeout(resolve, waitMs));
+							return true; // signal: handled, please retry
 						},
 					},
 				);
@@ -1085,6 +1164,8 @@ export class LoopDaemon {
 					ac.abort();
 				}, this.config.taskTimeoutMs);
 				try {
+					// NOTE: If timeout wins, finalState will be undefined. We handle
+					// this below so we don't crash on finalState.review.
 					finalState = await Promise.race([
 						invokeTask(ac.signal),
 						timeoutPromise(this.config.taskTimeoutMs),
@@ -1092,6 +1173,18 @@ export class LoopDaemon {
 				} finally {
 					clearTimeout(timeout);
 				}
+				// Handle timeout case: timeoutPromise resolved first, finalState is undefined.
+				// Must not fall through to finalState.review access (would throw).
+				if (finalState === undefined) {
+					log("Task timed out — releasing lease and cleaning up");
+					this._releaseLease(task.taskId);
+					this.running.delete(task.taskId);
+					this._notifyHumanReviewNeeded(
+						task,
+						`Task timed out after ${this.config.taskTimeoutMs}ms — manual review needed`,
+					);
+					return;
+				}
 			} else {
 				finalState = await invokeTask();
 			}
@@ -1101,6 +1194,60 @@ export class LoopDaemon {
 
 			log(`Loop finished: ${verdict} after ${iterations} iteration(s)`);
 
+			// ── Trajectory append (M7a) ───────────────────────────────────────────
+			const rawComments = finalState.review?.comments ?? [];
+			const comments = rawComments.map((c) => ({
+				file: c.file ?? undefined,
+				comment: c.comment,
+				severity: (c.severity ?? "minor") as "minor" | "major" | "critical",
+			}));
+			const files = [
+				...new Set(rawComments.map((c) => c.file).filter(Boolean) as string[]),
+			];
+			const reason =
+				verdict === "approved"
+					? "reviewer approved"
+					: verdict === "blocked"
+						? "reviewer blocked the task"
+						: iterations >= this.config.maxIterations
+							? `max iterations (${iterations}) reached with changes still requested`
+							: comments.length > 0 && comments.every((c) => c.severity === "minor")
+								? `converged: only minor comments (${comments.length})`
+								: `stuck: changes still requested after ${iterations} iteration(s)`;
+
+			// M7c: Build the trajectory record and classify convergence
+			const trajRecord = {
+				id: trajId,
+				taskRequest: task.request,
+				createdAt: new Date(trajStartMs).toISOString(),
+				durationMs: Date.now() - trajStartMs,
+				iterations,
+				verdict: verdict as "approved" | "blocked" | "changes_requested",
+				reason,
+				plan: finalState.plan ?? "",
+				code: finalState.code ?? "",
+				files,
+				comments,
+				summary: finalState.review?.summary ?? "",
+				classified: false as boolean,
+			};
+			const classification = store.classify(trajRecord);
+			log(
+				`[M7c] Trajectory "${classification.label}" ` +
+					`(confidence ${Math.round(classification.confidence * 100)}%) — ` +
+					classification.recommendation,
+			);
+
+			// Persist the trajectory record
+			store.append(trajRecord);
+
+			// M7b: Record approved patterns so the reviewer learns from success
+			if (verdict === "approved") {
+				const approvedPatterns = getApprovedPatternStore();
+				approvedPatterns.approve(comments);
+				log(`[M7b] Recorded ${comments.length} approved pattern(s)`);
+			}
+
 			// Update widget on loop completion
 			if (this.widget) {
 				this.widget.setComplete(
@@ -1161,6 +1308,14 @@ export class LoopDaemon {
 				// approved
 				this._notifyReadyForClient(task);
 			}
+
+			// ── Notify agent of loop completion (TUI todo count) ───────────────
+			this._writeLoopCompletion(task, verdict, iterations);
+
+			// ── Close bd issue on loop completion ───────────────────────────────
+			if (task.source === "bd-tasks") {
+				this._closeBdIssue(task.taskId, verdict);
+			}
 		} finally {
 			this._releaseLease(task.taskId);
 			this.running.delete(task.taskId);
@@ -1222,9 +1377,17 @@ export class LoopDaemon {
 				w.startIteration(state.iteration, this.config.maxIterations);
 				break;
 			}
+			case "glmq": {
+				// GLM quota hit — show countdown to reset
+				const resetAt =
+					state.iteration > 0
+						? new Date(state.iteration) // passthrough from onGLMQuota
+						: undefined;
+				w.setSurgePause(resetAt);
+				break;
+			}
 			case "review": {
-				w.setPhase("reviewing", "GPT reviewing");
-				this.statusLine?.updateLoopStatus("[R] reviewing");
+				w.setPhase("reviewing", "GLM reviewing");
 				// Process review comments — one record per file
 				const comments = state.review?.comments ?? [];
 				if (comments.length === 0) break;
@@ -1284,6 +1447,27 @@ export class LoopDaemon {
 			});
 	}
 
+	private _closeBdIssue(taskId: string, verdict: string): void {
+		// Close the bd issue when the loop finishes.
+		// approved → close as done. changes_requested (exhausted) → close as done.
+		// blocked → leave open for human review.
+		const reason =
+			verdict === "approved"
+				? "approved"
+				: verdict === "blocked"
+					? undefined // leave blocked issues open
+					: "completed";
+		if (!reason) return;
+		try {
+			execSync(`bd close ${taskId} --reason "${reason}" 2>/dev/null`, {
+				encoding: "utf8",
+				timeout: 5_000,
+			});
+		} catch {
+			// best-effort — don't fail the task over a missing bd
+		}
+	}
+
 	private _notifyReadyForClient(task: TriggeredTask): void {
 		if (!this.notificationCenter) return;
 		console.log(`[daemon] Notifying ReadyForClient`);
@@ -1298,6 +1482,40 @@ export class LoopDaemon {
 			});
 	}
 
+	/**
+	 * Write a loop-completion event to ~/.pi-harness-runtime/loop-completions/.
+	 * The harness extension (pi-harness-runtime package in the pi-coding-agent process)
+	 * watches this directory and calls pi.sendUserMessage() to update the TUI todo count.
+	 *
+	 * File format:
+	 *   <taskId>.json  {"taskId","request","verdict","iterations","finishedAt"}
+	 */
+	private _writeLoopCompletion(
+		task: TriggeredTask,
+		verdict: string,
+		iterations: number,
+	): void {
+		const dir = join(homedir(), ".pi-harness-runtime", "loop-completions");
+		try {
+			if (!existsSync(dir)) {
+				mkdirSync(dir, { recursive: true });
+			}
+			const payload = JSON.stringify({
+				taskId: task.taskId,
+				request: task.request,
+				verdict,
+				iterations,
+				finishedAt: new Date().toISOString(),
+			});
+			// Use taskId as filename; .json extension so it reads as JSON
+			const safeId = task.taskId.replace(/[^a-zA-Z0-9_-]/g, "_");
+			writeFileSync(join(dir, `${safeId}.json`), payload, "utf8");
+		} catch (err) {
+			// Best-effort: never fail the loop over a notification write
+			console.warn(`[daemon] Failed to write loop completion: ${err}`);
+		}
+	}
+
 	private _buildChannels(cfg: NonNullable<DaemonConfig["notificationConfig"]>) {
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		const channels: any[] = [];

package/harness/langchain/file-tools.d.ts

@@ -0,0 +1,97 @@
+/**
+ * File system tools for the coder agent — read and write files on disk.
+ *
+ * These tools let the MiniMax coder edit the actual repository instead of
+ * just outputting code blocks. Tools are plain Node.js fs wrappers; the
+ * agent receives structured JSON results it can act on.
+ *
+ * Wiki: wiki/multi-agent-langchain.md §file-tools
+ */
+import { z } from "zod";
+/**
+ * Read the contents of a file.
+ *
+ * Use this before editing to see the current code.
+ * Returns the full file contents as a string.
+ */
+export declare const readFile: import("langchain").DynamicStructuredTool<z.ZodObject<{
+    path: z.ZodString;
+    encoding: z.ZodOptional<z.ZodEnum<{
+        ascii: "ascii";
+        base64: "base64";
+        "utf-16": "utf-16";
+        "utf-8": "utf-8";
+    }>>;
+}, z.core.$strip>, {
+    path: string;
+    encoding?: "ascii" | "base64" | "utf-16" | "utf-8" | undefined;
+}, {
+    path: string;
+    encoding?: "ascii" | "base64" | "utf-16" | "utf-8" | undefined;
+}, string, unknown, "read_file">;
+/**
+ * Write or overwrite a file on disk.
+ *
+ * Creates parent directories if they don't exist.
+ * The caller (an agent) is responsible for ensuring the content is correct.
+ */
+export declare const writeFile: import("langchain").DynamicStructuredTool<z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+    append: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, {
+    path: string;
+    content: string;
+    append?: boolean | undefined;
+}, {
+    path: string;
+    content: string;
+    append?: boolean | undefined;
+}, string, unknown, "write_file">;
+/**
+ * List files in a directory (non-recursive).
+ *
+ * Useful for discovering the project structure.
+ */
+export declare const listDir: import("langchain").DynamicStructuredTool<z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strip>, {
+    path: string;
+}, {
+    path: string;
+}, string, unknown, "list_directory">;
+/** All file system tools, ready to pass to `createCoderAgent`. */
+export declare const fileTools: (import("langchain").DynamicStructuredTool<z.ZodObject<{
+    path: z.ZodString;
+    encoding: z.ZodOptional<z.ZodEnum<{
+        ascii: "ascii";
+        base64: "base64";
+        "utf-16": "utf-16";
+        "utf-8": "utf-8";
+    }>>;
+}, z.core.$strip>, {
+    path: string;
+    encoding?: "ascii" | "base64" | "utf-16" | "utf-8" | undefined;
+}, {
+    path: string;
+    encoding?: "ascii" | "base64" | "utf-16" | "utf-8" | undefined;
+}, string, unknown, "read_file"> | import("langchain").DynamicStructuredTool<z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+    append: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, {
+    path: string;
+    content: string;
+    append?: boolean | undefined;
+}, {
+    path: string;
+    content: string;
+    append?: boolean | undefined;
+}, string, unknown, "write_file"> | import("langchain").DynamicStructuredTool<z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strip>, {
+    path: string;
+}, {
+    path: string;
+}, string, unknown, "list_directory">)[];
+//# sourceMappingURL=file-tools.d.ts.map

package/harness/langchain/file-tools.ts

@@ -10,8 +10,14 @@
 
 import { tool } from "langchain";
 import { z } from "zod";
-import { readFileSync, writeFileSync, existsSync, statSync } from "node:fs";
-import { join, isAbsolute, resolve } from "node:path";
+import {
+	mkdirSync,
+	readFileSync,
+	writeFileSync,
+	existsSync,
+	statSync,
+} from "node:fs";
+import { dirname, join, isAbsolute, resolve } from "node:path";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -104,9 +110,11 @@ export const writeFile = tool(
 	}) => {
 		try {
 			const resolved = resolvePath(path, process.cwd());
+			// P1-4: create parent directories before writing (fixes ENOENT on nested paths)
+			mkdirSync(dirname(resolved), { recursive: true });
 			const mode = append ? "a" : "w";
-			// Normalize content: convert literal \n sequences to actual newlines
-			const normalized = content.replace(/\\n/g, "\n");
+			// P1-4: stop corrupting literal \\n sequences in code files
+			const normalized = content; // drop the replace(); agents use actual \n in strings
 			writeFileSync(resolved, normalized, { encoding: "utf-8", flag: mode });
 			const stats = statSync(resolved);
 			return JSON.stringify({
@@ -125,8 +133,8 @@ export const writeFile = tool(
 	{
 		name: "write_file",
 		description:
-			"Write or overwrite a file on disk. Creates parent directories if needed. " +
-			"Use literal \\n in the content string for newlines. " +
+			"Write or overwrite a file on disk. Creates parent directories automatically. " +
+			"Use actual newline characters in the content string. " +
 			"Set append=true to add to the end of an existing file. " +
 			"Returns JSON with ok, path, size, and action fields.",
 		schema: z.object({