pi-harness-runtime 1.1.49 → 1.1.71-3

package/CHANGELOG.md

@@ -2,60 +2,81 @@
 
 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.18](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.13...v1.1.18) (2026-08-24)
+### [1.1.71-1](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.69...v1.1.71-1) (2026-09-19)
 
 
+### Features
+
+* add jev-judge package for structured decision making ([810a6d8](https://github.com/ManotLuijiu/pi-harness-runtime/commit/810a6d81ae5803d28a471a3cd059197e953c9707))
+
+### [1.1.71-0](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.69...v1.1.71-0) (2026-09-19)
+
+### [1.1.70](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.69...v1.1.70) (2026-09-19)
+
+### [1.1.69](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.68...v1.1.69) (2026-09-14)
+
+### [1.1.68](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.76...v1.1.68) (2026-09-14)
+
+
+### Bug Fixes
+
+* **interceptor:** guard foreground daemon-over-SSH hangs with timeout ([57770b5](https://github.com/ManotLuijiu/pi-harness-runtime/commit/57770b5f477d9885836cc1b0dddee612a5c55d18))
+
+### [1.1.19](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.61...v1.1.19) (2026-09-10)
+
+### Features
+
+* add ping-pong intent middleware ([c2b4f4b](https://github.com/ManotLuijiu/pi-harness-runtime/commit/c2b4f4b86fdd22c151dd1dee1cab5fa3dbcfdcd5))
+
+### Bug Fixes
+
+* improve langchain daemon and surge test ([42245b4](https://github.com/ManotLuijiu/pi-harness-runtime/commit/42245b4364c3516c70df82fedbfe63e1b0cadd8e))
+
+### [1.1.18](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.13...v1.1.18) (2026-08-24)
+
 ### Features
 
 * **glm-quota:** add robust GLM quota countdown with auto-resume ([cb78a2b](https://github.com/ManotLuijiu/pi-harness-runtime/commit/cb78a2bdf5ecf79fc028030d43e3ce40767253cb))
 * **glm:** add structured logging for GLM quota events ([09e692e](https://github.com/ManotLuijiu/pi-harness-runtime/commit/09e692ec17b9c21a448c72f081d18fb35b8636ae))
 
-
 ### Bug Fixes
 
 * **glm:** improve footer status display with specific 5h quota and reset time ([ab991c3](https://github.com/ManotLuijiu/pi-harness-runtime/commit/ab991c329bdb4097e77503d3d7f574edc6cdc1c4))
 
 ### [1.1.17](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.13...v1.1.17) (2026-08-24)
 
-
 ### Features
 
 * **glm-quota:** add robust GLM quota countdown with auto-resume ([cb78a2b](https://github.com/ManotLuijiu/pi-harness-runtime/commit/cb78a2bdf5ecf79fc028030d43e3ce40767253cb))
 * **glm:** add structured logging for GLM quota events ([09e692e](https://github.com/ManotLuijiu/pi-harness-runtime/commit/09e692ec17b9c21a448c72f081d18fb35b8636ae))
 
-
 ### Bug Fixes
 
 * **glm:** improve footer status display with specific 5h quota and reset time ([ab991c3](https://github.com/ManotLuijiu/pi-harness-runtime/commit/ab991c329bdb4097e77503d3d7f574edc6cdc1c4))
 
 ### [1.1.16](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.13...v1.1.16) (2026-08-24)
 
-
 ### Features
 
 * **glm-quota:** add robust GLM quota countdown with auto-resume ([cb78a2b](https://github.com/ManotLuijiu/pi-harness-runtime/commit/cb78a2bdf5ecf79fc028030d43e3ce40767253cb))
 * **glm:** add structured logging for GLM quota events ([09e692e](https://github.com/ManotLuijiu/pi-harness-runtime/commit/09e692ec17b9c21a448c72f081d18fb35b8636ae))
 
-
 ### Bug Fixes
 
 * **glm:** improve footer status display with specific 5h quota and reset time ([ab991c3](https://github.com/ManotLuijiu/pi-harness-runtime/commit/ab991c329bdb4097e77503d3d7f574edc6cdc1c4))
 
 ### [1.1.15](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.13...v1.1.15) (2026-08-24)
 
-
 ### Features
 
 * **glm-quota:** add robust GLM quota countdown with auto-resume ([cb78a2b](https://github.com/ManotLuijiu/pi-harness-runtime/commit/cb78a2bdf5ecf79fc028030d43e3ce40767253cb))
 
-
 ### Bug Fixes
 
 * **glm:** improve footer status display with specific 5h quota and reset time ([ab991c3](https://github.com/ManotLuijiu/pi-harness-runtime/commit/ab991c329bdb4097e77503d3d7f574edc6cdc1c4))
 
 ### [1.1.14](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.13...v1.1.14) (2026-08-24)
 
-
 ### Features
 
 * **glm-quota:** add robust GLM quota countdown with auto-resume ([cb78a2b](https://github.com/ManotLuijiu/pi-harness-runtime/commit/cb78a2bdf5ecf79fc028030d43e3ce40767253cb))

package/README.md

@@ -155,6 +155,125 @@ bd --version
 # Tasks: 4/4 done [x]
 ```
 
+## LangChain Multi-Agent Loop (Autonomous Write-Review)
+
+A **human-on-the-loop** autonomous system where multiple AI agents collaborate on code:
+
+- **GPT** → writes the plan
+- **MiniMax** → writes the code
+- **GPT/GLM** → reviews the code
+- Loop repeats until approved or max iterations hit
+
+### Quick Start
+
+```bash
+# One-shot (human triggers once)
+bun harness/langchain/run.ts --mode graph --request "implement feature X"
+
+# Dry-run (no API keys, uses stubs)
+bun harness/langchain/run.ts --mode graph --request "fix bug Y" --dry-run
+
+# Daemon mode (auto-triggers on new tasks — stays running)
+bun harness/langchain/run.ts --daemon
+```
+
+### Daemon Mode (Auto-Trigger)
+
+The daemon runs as a **standalone long-running process** and watches for new tasks:
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  Terminal 1: pi-coding-agent (GPT/MiniMax/GLM — your coding agent) │
+│  Terminal 2: bun harness/langchain/run.ts --daemon                 │
+│  Terminal 3: (optional) second agent                             │
+│  Terminal N: (optional) more agents                            │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+**How it works:**
+
+1. You interact with coding agents in their terminals
+2. Agents create tasks via `bd create ...` or inbox files
+3. Daemon detects new pending tasks automatically
+4. Loop runs: plan → write → review → fix (autonomous, no human relay)
+5. Human is notified only at approval gates or when blocked
+
+**Stop the daemon:** `Ctrl+C` or `kill $(pid)`
+
+### Multi-Agent Roles
+
+Request format in task or inbox file:
+
+```
+[planner: gpt] [reviewer: GLM] [coder: MiniMax] implement feature X
+```
+
+Default (from env vars):
+
+| Role | Default | Env Var |
+| ------ | --------- | --------- |
+| Planner | GPT | `PLANNER_*` |
+| Coder | MiniMax | `MINIMAX_*` |
+| Reviewer | GPT | `GLM_*` |
+
+### Architecture
+
+```
+Triggers:
+  bd tasks ─┐
+  inbox ────┼──► Daemon ──► LeaseManager ──► LangGraph Loop
+  bus event ─┤         (watchers)              │
+  cron ──────┘                                    │
+                                                 │
+Loop (LangGraph):                           publish
+  START → plan(GPT) → write(MiniMax) → review(GPT) ──► HerdrEventBus
+                                ↓                              │
+                         changes_requested?                    │
+                              ↓ yes              no         │
+                        fix(MiniMax)            approved ──► Notification
+                              ↓                              │
+                         review(GPT) ─────────────────────────►
+```
+
+### Key Design Invariants
+
+| # | Invariant |
+| --- | --- |
+| I1 | No step waits for a human unless an approval gate fires |
+| I2 | Agents talk directly via graph state + events (no human relay) |
+| I3 | Exactly one daemon processes a task at a time (lease-based) |
+| I4 | Every transition is observable via HerdrEventBus |
+| I5 | Loop always terminates: maxIterations, blocked verdict, or error |
+| I6 | Crash-safe: loop state survives daemon restarts (checkpointer) |
+| I7 | Human gates are config-driven, default to "notify don't block" |
+
+### Files
+
+```
+harness/langchain/
+├── run.ts              # CLI entry point (modes: graph, supervisor, daemon)
+├── daemon.ts           # Core daemon: watchers + lease + loop orchestration
+├── graph.ts            # LangGraph state machine (plan→write→review→fix)
+├── agents.ts           # Agent factory (planner, reviewer, coder)
+├── model-router.ts     # Smart model routing per request tags
+├── ping-pong-middleware.ts  # Decision engine: complex? → loop. simple? → one-shot
+├── checkpointer.ts     # Crash-safe state persistence
+├── inbox-watcher.ts    # Watches inbox dir for new task files
+├── bus-watcher.ts     # Watches HerdrEventBus for task.proposed events
+├── cron-watcher.ts    # Stub for scheduled task triggers
+├── status-line.ts     # Real-time loop status display
+├── surge.ts           # Peak-hour surge detection
+└── widget.ts          # TUI widget for loop progress
+```
+
+### Wiki Docs
+
+| Doc | Description |
+| ----- | ------------- |
+| `wiki/auto-trigger-multi-agent.md` | Full daemon spec, event contracts, acceptance tests |
+| `wiki/multi-agent-langchain.md` | LangChain/LangGraph design notes |
+| `wiki/ping-pong-shared-state.md` | Shared state between agents |
+
 ## Architecture
 
 ```

package/harness/langchain/agents.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Multi-Agent definitions — GPT (planner) + GLM (master reviewer) + MiniMax (coder).
+ *
+ * Ping-pong loop:
+ *   Planner (GPT)  →  plan
+ *   Coder (MiniMax)  →  code
+ *   Reviewer (GLM)   →  verdict: approved | changes_requested | blocked
+ *
+ * The GLM reviewer is the master. If GLM approves → loop ends.  If GLM requests
+ * changes → MiniMax addresses them → GLM reviews again.  After maxIterations or
+ * smart-stop, the loop terminates.
+ *
+ * Verdict values intentionally match the existing harness LoopVerdict type
+ * ("approved" | "changes_requested" | "blocked") so this module can feed the
+ * existing blackboard / HerdrEventBus infrastructure.
+ *
+ * Wiki: wiki/multi-agent-langchain.md
+ */
+import { z } from "zod";
+import { type ModelOptions } from "./models.js";
+export declare const ReviewVerdictSchema: z.ZodObject<{
+    verdict: z.ZodEnum<{
+        approved: "approved";
+        blocked: "blocked";
+        changes_requested: "changes_requested";
+    }>;
+    summary: z.ZodString;
+    comments: z.ZodArray<z.ZodObject<{
+        file: z.ZodOptional<z.ZodString>;
+        comment: z.ZodString;
+        severity: z.ZodOptional<z.ZodEnum<{
+            critical: "critical";
+            major: "major";
+            minor: "minor";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ReviewVerdict = z.infer<typeof ReviewVerdictSchema>;
+export declare function isAutonomyRequest(request: string): boolean;
+/** Directive injected into every system prompt when autonomy signal is detected. */
+export declare function autonomyDirective(): string;
+export declare function createPlannerAgent(opts?: ModelOptions): import("langchain").ReactAgent<import("langchain").AgentTypeConfig<import("langchain").ResponseFormatUndefined, undefined, import("langchain").AnyAnnotationRoot, readonly import("langchain").AnyAgentMiddleware[], readonly [], readonly []>>;
+export declare function createCoderAgent(opts?: ModelOptions): import("langchain").ReactAgent<import("langchain").AgentTypeConfig<import("langchain").ResponseFormatUndefined, undefined, import("langchain").AnyAnnotationRoot, readonly import("langchain").AnyAgentMiddleware[], readonly (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">)[], readonly []>>;
+export declare function createReviewerAgent(opts?: ModelOptions): import("langchain").ReactAgent<import("langchain").AgentTypeConfig<{
+    verdict: "approved" | "blocked" | "changes_requested";
+    summary: string;
+    comments: {
+        file?: string | undefined;
+        comment: string;
+        severity?: "critical" | "major" | "minor" | undefined;
+    }[];
+}, undefined, import("langchain").AnyAnnotationRoot, readonly import("langchain").AnyAgentMiddleware[], readonly [], readonly []>>;
+export type PlannerAgent = ReturnType<typeof createPlannerAgent>;
+export type CoderAgent = ReturnType<typeof createCoderAgent>;
+export type ReviewerAgent = ReturnType<typeof createReviewerAgent>;
+export type SupervisorAgent = ReturnType<typeof createSupervisor>;
+/** Extract the last assistant message text from an agent result. */
+export declare function lastMessage(agentResult: {
+    messages: Array<{
+        content: unknown;
+    }>;
+}): string;
+export declare function buildDelegationTools(opts?: {
+    coder?: CoderAgent;
+    reviewer?: ReviewerAgent;
+}): {
+    delegateToCoder: import("langchain").DynamicStructuredTool<z.ZodObject<{
+        instruction: z.ZodString;
+        reviewComments: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, {
+        instruction: string;
+        reviewComments?: string | undefined;
+    }, {
+        instruction: string;
+        reviewComments?: string | undefined;
+    }, string, unknown, "delegate_to_coder">;
+    delegateToReviewer: import("langchain").DynamicStructuredTool<z.ZodObject<{
+        plan: z.ZodString;
+        code: z.ZodString;
+    }, z.core.$strip>, {
+        plan: string;
+        code: string;
+    }, {
+        plan: string;
+        code: string;
+    }, string, unknown, "delegate_to_reviewer">;
+};
+export declare function createSupervisor(opts?: {
+    plannerModel?: ModelOptions;
+    coder?: CoderAgent;
+    reviewer?: ReviewerAgent;
+}): import("langchain").ReactAgent<import("langchain").AgentTypeConfig<import("langchain").ResponseFormatUndefined, undefined, import("langchain").AnyAnnotationRoot, readonly import("langchain").AnyAgentMiddleware[], readonly [import("langchain").DynamicStructuredTool<z.ZodObject<{
+    instruction: z.ZodString;
+    reviewComments: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    instruction: string;
+    reviewComments?: string | undefined;
+}, {
+    instruction: string;
+    reviewComments?: string | undefined;
+}, string, unknown, "delegate_to_coder">, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    plan: z.ZodString;
+    code: z.ZodString;
+}, z.core.$strip>, {
+    plan: string;
+    code: string;
+}, {
+    plan: string;
+    code: string;
+}, string, unknown, "delegate_to_reviewer">], readonly []>>;
+//# sourceMappingURL=agents.d.ts.map

package/harness/langchain/agents.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=agents.test.d.ts.map

package/harness/langchain/agents.test.ts

@@ -1,4 +1,3 @@
-
 import { describe, it } from "node:test";
 import assert from "node:assert";
 import { isAutonomyRequest } from "./agents.js";

package/harness/langchain/agents.ts

@@ -1,14 +1,14 @@
 /**
- * Multi-Agent definitions — GPT (planner/reviewer/supervisor) + MiniMax (coder).
+ * Multi-Agent definitions — GPT (planner) + GLM (master reviewer) + MiniMax (coder).
  *
- * This is a TypeScript port of the "supervisor + agents-as-tools" pattern from
- * Mohamad-Hachem/MultiAgent_Wedding_Planner_With_Langchain (agents.py):
+ * Ping-pong loop:
+ *   Planner (GPT)  →  plan
+ *   Coder (MiniMax)  →  code
+ *   Reviewer (GLM)   →  verdict: approved | changes_requested | blocked
  *
- *   Python (agents.py)              →  TypeScript (this file)
- *   ------------------------------------------------------------------
- *   subagent1 = create_agent(...)   →  coderAgent = createAgent({ model: minimax ... })
- *   @tool delegate_to_subagent1     →  delegateToCoder = tool(... { name: "delegate_to_coder" })
- *   main_agent(tools=[delegates])   →  supervisor = createAgent({ tools: [delegateToCoder, ...] })
+ * The GLM reviewer is the master. If GLM approves → loop ends.  If GLM requests
+ * changes → MiniMax addresses them → GLM reviews again.  After maxIterations or
+ * smart-stop, the loop terminates.
  *
  * Verdict values intentionally match the existing harness LoopVerdict type
  * ("approved" | "changes_requested" | "blocked") so this module can feed the
@@ -95,8 +95,8 @@ permission to write code until finish without waiting for confirmation.
 const PLANNER_PROMPT = `You are the Planning Agent (GPT) in an autonomous daemon loop.
 
 Given a feature request, produce a concise implementation plan: goals, non-goals,
-ordered steps, files to touch, risks, and a definition-of-done the reviewer can
-check against.
+ordered steps, files to touch, risks, and a definition-of-done the GLM reviewer
+can check against.
 
 Output markdown only. Do NOT ask for confirmation. Do NOT output "Next Steps".
 The loop will route automatically.`;
@@ -124,10 +124,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 Code Review Agent (GPT) in an autonomous daemon loop.
+const REVIEWER_PROMPT = `You are the Master Code Review Agent (GLM) in an autonomous daemon loop.
 
-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.
+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.
 
 IMPORTANT:
 - Do NOT output "Next Steps" or "Looks good, waiting for approval"
@@ -146,6 +147,188 @@ IMPORTANT:
 - Do NOT output a summary for a human — the loop reads the verdict
 - Keep iterating until approved or truly blocked, then output a verdict`;
 
+// ─── ADK ParallelAgent Pattern: Specialist Reviewers ─────────────────────────
+// ADK equivalent: ParallelAgent([SecurityAuditor, StyleEnforcer, PerfAnalyst])
+// This runs 3 specialist reviews in parallel via Promise.all.
+// Each specialist focuses on one dimension — faster and more thorough than
+// one monolithic reviewer.
+
+export type SpecialistType = "security" | "style" | "performance";
+
+const SPECIALIST_PROMPTS: Record<SpecialistType, string> = {
+	security: `You are a Security Auditor in an autonomous code review loop.
+
+FOCUS: Find real security vulnerabilities only. Do NOT flag style, formatting, or performance issues.
+
+Check for:
+- SQL injection, command injection, path traversal
+- Hardcoded secrets, API keys, passwords in code
+- Insecure deserialization, XXE, SSRF
+- Authentication/authorization bypass patterns
+- Unsafe eval/Function/exec with user input
+- Missing input validation on security-sensitive operations
+- Insecure file operations, TOCTOU
+- Weak crypto, improper SSL/TLS usage
+
+Output a structured verdict. Do NOT say "looks good overall" — give a precise security assessment.`,
+
+	style: `You are a Code Style and Maintainability Auditor in an autonomous code review loop.
+
+FOCUS: Check style, readability, and maintainability only. Do NOT flag security vulnerabilities or performance issues.
+
+Check for:
+- Consistent naming conventions (camelCase vs snake_case)
+- Missing or inconsistent JSDoc/type annotations
+- Overly complex functions (cyclomatic complexity)
+- Magic numbers without named constants
+- Deeply nested callbacks / callback hell
+- Missing error handling or empty catch blocks
+- Unused imports or variables
+- Inconsistent error handling patterns
+
+Output a structured verdict. Focus on real maintainability problems, not personal preferences.`,
+
+	performance: `You are a Performance Analyst in an autonomous code review loop.
+
+FOCUS: Find real performance and scalability problems only. Do NOT flag style or security (unless it causes a performance issue).
+
+Check for:
+- N+1 query patterns (DB, HTTP, file I/O)
+- Synchronous blocking operations in async code
+- Memory leaks (unbounded arrays, missing cleanup)
+- Expensive operations in hot paths (loops, regex in loops)
+- Missing pagination or cursor-based iteration
+- Unbounded recursion without memoization
+- Inefficient data structures (array search vs Map/Set)
+- Missing caching where repeated computation occurs
+
+Output a structured verdict. Flag only real performance problems, not premature optimizations.`,
+};
+
+/** Create a specialist reviewer agent for parallel review. */
+export function createSpecialistReviewer(
+	type: SpecialistType,
+	opts: ModelOptions = {},
+) {
+	return createAgent({
+		model: createReviewerModel(opts),
+		tools: [],
+		systemPrompt: SPECIALIST_PROMPTS[type],
+		responseFormat: ReviewVerdictSchema,
+	});
+}
+
+/**
+ * ADK ParallelAgent equivalent: run multiple specialist reviews in parallel.
+ * Returns aggregated verdict — approved only if ALL specialists pass.
+ */
+export async function parallelReview(
+	specialists: {
+		security: ReturnType<typeof createSpecialistReviewer>;
+		style: ReturnType<typeof createSpecialistReviewer>;
+		performance: ReturnType<typeof createSpecialistReviewer>;
+	},
+	plan: string,
+	code: string,
+	writtenFiles: Record<string, string>,
+): Promise<ReviewVerdict> {
+	const codeSection =
+		Object.keys(writtenFiles).length > 0
+			? Object.entries(writtenFiles)
+					.map(([path, content]) => `## ${path}\n\n\`\`\`\n${content}\n\`\`\`\n`)
+					.join("\n\n")
+			: `## Code\n\n\`\`\`\n${code}\n\`\`\`\n`;
+
+	const prompt = `## Plan\n${plan}\n\n${codeSection}`;
+
+	// ── ADK ParallelAgent: fan-out 3 specialists simultaneously ──
+	const [secResult, styleResult, perfResult] = await Promise.all([
+		specialists.security.invoke({
+			messages: [{ role: "user", content: prompt }],
+		}),
+		specialists.style.invoke({
+			messages: [{ role: "user", content: prompt }],
+		}),
+		specialists.performance.invoke({
+			messages: [{ role: "user", content: prompt }],
+		}),
+	]);
+
+	// Parse each specialist result
+	const parseResult = (
+		r: unknown,
+		_specialist: SpecialistType,
+	): { verdict: string; summary: string; comments: unknown[] } => {
+		if (typeof r === "object" && r !== null && "structuredResponse" in r) {
+			const sr = (
+				r as {
+					structuredResponse: {
+						verdict: string;
+						summary: string;
+						comments: unknown[];
+					};
+				}
+			).structuredResponse;
+			return { verdict: sr.verdict, summary: sr.summary, comments: sr.comments };
+		}
+		return { verdict: "approved", summary: "", comments: [] };
+	};
+
+	const sec = parseResult(secResult, "security");
+	const style = parseResult(styleResult, "style");
+	const perf = parseResult(perfResult, "performance");
+
+	// ── ADK ParallelAgent: gather results and synthesize ──
+	const buildLabeledComments = (
+		comments: unknown[],
+		type: SpecialistType,
+	): {
+		file?: string;
+		comment: string;
+		severity: "critical" | "major" | "minor";
+	}[] =>
+		(comments ?? []).map((c) => {
+			const comment = c as {
+				file?: string;
+				comment: string;
+				severity?: "critical" | "major" | "minor";
+			};
+			return {
+				file: comment.file,
+				comment: `[${type}] ${comment.comment}`,
+				severity: comment.severity ?? "minor",
+			};
+		});
+
+	const labeledComments = [
+		...buildLabeledComments(sec.comments, "security"),
+		...buildLabeledComments(style.comments, "style"),
+		...buildLabeledComments(perf.comments, "performance"),
+	];
+
+	// Only approve if ALL specialists approve
+	let finalVerdict: ReviewVerdict["verdict"] = "approved";
+	if (
+		sec.verdict === "blocked" ||
+		style.verdict === "blocked" ||
+		perf.verdict === "blocked"
+	) {
+		finalVerdict = "blocked";
+	} else if (
+		sec.verdict === "changes_requested" ||
+		style.verdict === "changes_requested" ||
+		perf.verdict === "changes_requested"
+	) {
+		finalVerdict = "changes_requested";
+	}
+
+	return {
+		verdict: finalVerdict,
+		summary: `[security] ${sec.summary} | [style] ${style.summary} | [perf] ${perf.summary}`,
+		comments: labeledComments,
+	};
+}
+
 // ─── Agents ─────────────────────────────────────────────────────────────────
 
 export function createPlannerAgent(opts: ModelOptions = {}) {

package/harness/langchain/checkpointer.d.ts

@@ -0,0 +1,48 @@
+/**
+ * File-based checkpointer — persists LangGraph StateGraph checkpoints to disk.
+ *
+ * Enables crash-safe loop resume: if the daemon dies mid-task, a new instance
+ * resumes from the last checkpoint instead of restarting from scratch.
+ *
+ * Storage layout:
+ *   <root>/
+ *   ├── <threadId>/
+ *   │   ├── index.jsonl      # one line per checkpoint (id, ts, parentId, step)
+ *   │   └── <checkpointId>.json  # full checkpoint + metadata + parentConfig
+ *
+ * Wiki: wiki/auto-trigger-multi-agent.md §M5
+ */
+import { BaseCheckpointSaver, Checkpoint, CheckpointListOptions, CheckpointMetadata, CheckpointTuple } from "@langchain/langgraph-checkpoint";
+import type { ChannelVersions } from "@langchain/langgraph-checkpoint";
+import type { RunnableConfig } from "@langchain/core/runnables";
+/**
+ * File-based LangGraph checkpointer. Implements BaseCheckpointSaver so it can be
+ * passed directly to `buildWriteReviewLoop()` as the `checkpointer` option.
+ *
+ * Usage:
+ *   const saver = new FileCheckpointSaver({ root: "/tmp/checkpoints" });
+ *   const loop = buildWriteReviewLoop(deps, { checkpointer: saver });
+ *
+ * On daemon restart, pass the same root — checkpoints persist across restarts.
+ */
+export declare class FileCheckpointSaver extends BaseCheckpointSaver {
+    private readonly root;
+    constructor(opts: {
+        root: string;
+    });
+    get(config: RunnableConfig): Promise<Checkpoint | undefined>;
+    getTuple(config: RunnableConfig): Promise<CheckpointTuple | undefined>;
+    private _loadCheckpoint;
+    list(config: RunnableConfig, options?: CheckpointListOptions): AsyncGenerator<CheckpointTuple>;
+    put(config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata, _newVersions: ChannelVersions): Promise<RunnableConfig>;
+    putWrites(_config: RunnableConfig, _writes: [], _taskId: string): Promise<void>;
+    deleteThread(threadId: string): Promise<void>;
+    toJSON(): string;
+    /** List all known thread IDs with saved checkpoints. */
+    listThreads(): string[];
+    /** Delete all checkpoints for all threads (cleanup). */
+    clearAll(): void;
+}
+/** Build a FileCheckpointSaver wired to the daemon's workspace. */
+export declare function createLoopCheckpointer(workspace: string): FileCheckpointSaver;
+//# sourceMappingURL=checkpointer.d.ts.map

package/harness/langchain/checkpointer.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * FileCheckpointSaver tests — T9–T11 (wiki/auto-trigger-multi-agent.md §M5)
+ *
+ * Run:
+ *   bun test harness/langchain/checkpointer.test.ts
+ */
+export {};
+//# sourceMappingURL=checkpointer.test.d.ts.map

package/harness/langchain/cron-cli.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Cron task management CLI.
+ *
+ * Usage:
+ *   bun harness/langchain/run.ts cron add <schedule> <request>
+ *   bun harness/langchain/run.ts cron list
+ *   bun harness/langchain/run.ts cron rm <task-id>
+ *
+ * Schedules: every-5m, every-10m, every-30m, hourly, daily, weekly
+ */
+export declare function runCron(argv: string[]): Promise<void>;
+//# sourceMappingURL=cron-cli.d.ts.map