pi-harness-runtime 1.1.50 → 1.1.77

package/harness/langchain/cron-cli.ts

@@ -0,0 +1,169 @@
+/**
+ * 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
+ */
+
+import { readdirSync, readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+
+const SCHEDULES = ["every-5m", "every-10m", "every-30m", "hourly", "daily", "weekly"] as const;
+type Schedule = typeof SCHEDULES[number];
+
+function getCronDir(workspace: string): string {
+	return join(workspace, ".cron-tasks");
+}
+
+function taskIdFromPath(schedule: string, filename: string): string {
+	return `${schedule}:${filename.replace(/\.json$/, "")}`;
+}
+
+function parseTaskId(id: string): { schedule: string; name: string } | null {
+	const colon = id.indexOf(":");
+	if (colon === -1) return null;
+	return { schedule: id.slice(0, colon), name: id.slice(colon + 1) };
+}
+
+function loadWorkspace(): string {
+	// Dynamically import to avoid a hard dep on herdr-bus when not needed
+	try {
+		const { getHerdrWorkspace } = require("../../packages/event-bus/src/herdr-bus.js");
+		return getHerdrWorkspace();
+	} catch {
+		const home = process.env.HOME ?? "/tmp";
+		return join(home, ".pi-harness");
+	}
+}
+
+export async function runCron(argv: string[]): Promise<void> {
+	const [subcommand, ...rest] = argv;
+
+	if (!subcommand) {
+		printCronHelp();
+		process.exit(0);
+	}
+
+	const workspace = loadWorkspace();
+	const cronDir = getCronDir(workspace);
+
+	switch (subcommand) {
+		case "add": {
+			const [schedule, ...requestParts] = rest;
+			if (!schedule || requestParts.length === 0) {
+				console.error("Usage: bd cron add <schedule> <request>");
+				console.error(`Schedules: ${SCHEDULES.join(", ")}`);
+				process.exit(1);
+			}
+			if (!SCHEDULES.includes(schedule as Schedule)) {
+				console.error(`Unknown schedule: ${schedule}`);
+				console.error(`Valid: ${SCHEDULES.join(", ")}`);
+				process.exit(1);
+			}
+			const request = requestParts.join(" ");
+			const taskId = `task-${Date.now()}`;
+			const taskPath = join(cronDir, schedule, `${taskId}.json`);
+
+			if (!existsSync(cronDir)) mkdirSync(cronDir, { recursive: true });
+			if (!existsSync(join(cronDir, schedule))) mkdirSync(join(cronDir, schedule), { recursive: true });
+
+			writeFileSync(taskPath, JSON.stringify({ request, enabled: true }, null, 2));
+			console.log(`[cron] Added task ${schedule}:${taskId}`);
+			console.log(`       Request: ${request.slice(0, 80)}${request.length > 80 ? "…" : ""}`);
+			break;
+		}
+
+		case "list": {
+			if (!existsSync(cronDir)) {
+				console.log("No cron tasks configured.");
+				return;
+			}
+			let found = false;
+			for (const schedule of SCHEDULES) {
+				const schedDir = join(cronDir, schedule);
+				if (!existsSync(schedDir)) continue;
+				const files = readdirSync(schedDir).filter((f) => f.endsWith(".json"));
+				for (const file of files) {
+					found = true;
+					let data: { request?: string; enabled?: boolean };
+					try {
+						data = JSON.parse(readFileSync(join(schedDir, file), "utf8"));
+					} catch {
+						continue;
+					}
+					const id = taskIdFromPath(schedule, file);
+					const status = data.enabled === false ? " [PAUSED]" : "";
+					const req = (data.request ?? "").slice(0, 70);
+					console.log(`  ${id}${status}`);
+					console.log(`    → ${req}${data.request && data.request.length > 70 ? "…" : ""}`);
+				}
+			}
+			if (!found) console.log("No cron tasks configured.");
+			break;
+		}
+
+		case "rm": {
+			const [taskId] = rest;
+			if (!taskId) {
+				console.error("Usage: bd cron rm <task-id>");
+				console.error("Run 'bd cron list' to see task IDs.");
+				process.exit(1);
+			}
+			const parsed = parseTaskId(taskId);
+			if (!parsed) {
+				console.error(`Invalid task ID format: ${taskId}`);
+				console.error("Expected: <schedule>:<task-name>  (e.g. hourly:task-1234)");
+				process.exit(1);
+			}
+			const taskPath = join(cronDir, parsed.schedule, `${parsed.name}.json`);
+			if (!existsSync(taskPath)) {
+				console.error(`Task not found: ${taskId}`);
+				process.exit(1);
+			}
+			unlinkSync(taskPath);
+			console.log(`[cron] Removed ${taskId}`);
+			break;
+		}
+
+		case "help": {
+			printCronHelp();
+			break;
+		}
+
+		default: {
+			console.error(`Unknown subcommand: ${subcommand}`);
+			printCronHelp();
+			process.exit(1);
+		}
+	}
+}
+
+function printCronHelp(): void {
+	console.log(`\
+Cron task management.
+
+Usage: bd cron <subcommand> [args]
+
+Subcommands:
+  add <schedule> <request>
+    Schedule a task. Example:
+      bd cron add hourly "Check for outdated dependencies"
+
+    Valid schedules: ${SCHEDULES.join(", ")}
+
+  list
+    Show all scheduled tasks.
+
+  rm <task-id>
+    Remove a task. Use 'bd cron list' to find the task ID.
+
+Examples:
+  bd cron add daily "Sync docs to wiki"
+  bd cron list
+  bd cron rm every-5m:task-1234567890
+`);
+}

package/harness/langchain/daemon.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Loop Daemon — Auto-triggered write-review loop.
+ *
+ * Design philosophy: Human *on* the loop, not *in* the loop.
+ * The daemon starts itself, routes itself, and only notifies the human at gates
+ * (approval, escalation, blocked). No human ever acts as the message bus between
+ * GPT and MiniMax.
+ *
+ * Architecture:
+ *
+ *   TRIGGERS
+ *   bd task created  ─┐
+ *   inbox file       ─┤
+ *   bus event        ─┼──► watcher (poll) ─► LeaseManager.claim ─► LangGraph.run
+ *   cron (stub)     ─┘                     │
+ *                                           │ publish (loop-events.ts) ─► HerdrEventBus
+ *                                           │ gates ─► NotificationCenter
+ *
+ * Milestones:
+ *   M1 — Daemon skeleton + inbox/bus watchers
+ *   M2 — Runner integration: LeaseManager → buildWriteReviewLoop → publish
+ *   M3 — Gates & notifications
+ *   M4 — Robustness: surge/529 auto-resume + retry backoff, stale-lease, bd-tasks
+ *          watcher (worker heartbeats: still TODO)
+ *
+ * Wiki: wiki/auto-trigger-multi-agent.md
+ */
+import type { ApprovalClass } from "../../packages/autonomous-runtime/src/types.js";
+import { type SurgePolicy } from "./surge.js";
+import type { LoopWidget } from "./widget.js";
+import { type LoopDeps } from "./graph.js";
+export type TriggerSource = "bd-tasks" | "inbox" | "bus" | "cron";
+export type ApprovalPolicy = "never" | "on_blocked" | "on_class" | "always";
+export interface DaemonConfig {
+    /** Agent/worker identity. Default: "loop-daemon" */
+    agentId?: string;
+    /** Trigger poll interval in ms. Default: 2000 */
+    pollMs?: number;
+    /** Max write-review rounds per task. Default: 3 */
+    maxIterations?: number;
+    /** Human gate policy. Default: "never" */
+    approvalPolicy?: ApprovalPolicy;
+    /** Use deterministic stubs (no API keys). Default: false */
+    dryRun?: boolean;
+    /** Abort loop if cumulative cost exceeds this. Default: no cap */
+    costCapUsd?: number;
+    /** Surge (529/overloaded) retry policy. Default: 3→6→12 min, max 5 pauses */
+    surgePolicy?: Partial<SurgePolicy>;
+    /** Kill a task if it runs longer than this (ms). Prevents permanent freezes. Default: no timeout */
+    taskTimeoutMs?: number;
+    /** Use persistent file-based checkpointer for crash-resume. Default: false (MemorySaver). */
+    checkpointer?: boolean | string;
+    /** @internal Test injection — overrides dryRun/real deps entirely */
+    deps?: LoopDeps;
+    /** Which watchers to enable. Default: ["inbox", "bus"] */
+    sources?: TriggerSource[];
+    /** Herdr workspace override. Default: from herdr-bus */
+    workspace?: string;
+    /** NotificationCenter config */
+    notificationConfig?: {
+        telegramBotToken?: string;
+        telegramChatId?: string;
+        ntfyTopic?: string;
+        webhookUrl?: string;
+    };
+    /**
+     * Path to a tunnel-start script (e.g. tailscale-tunnel.sh).
+     * If set, the daemon health-checks the tunnel before each task and
+     * auto-restarts it if the target port is unreachable.
+     *
+     * Set to "auto" to search for scripts/tailscale-tunnel.sh in the
+     * project root, or give an absolute path.
+     * Default: none (no tunnel management)
+     */
+    tunnelCommand?: string;
+    /**
+     * Optional widget for TUI / status-line display.
+     * When set, the daemon updates the widget at each loop transition
+     * (mirrors pi-lens footer style: !NW ●ME).
+     */
+    widget?: LoopWidget;
+}
+export interface TriggeredTask {
+    /** Stable id — derived from the trigger source */
+    taskId: string;
+    /** Human-readable task description */
+    request: string;
+    /** How the task arrived */
+    source: TriggerSource;
+    /** Optional approval class from task metadata */
+    approvalClass?: ApprovalClass;
+    /** ISO timestamp of when the trigger was observed */
+    triggeredAt: string;
+}
+export interface TaskProposedPayload {
+    taskId: string;
+    request: string;
+    approvalClass?: ApprovalClass;
+}
+/** Write an ack file (used by tests / manual approval). */
+export declare function writeAck(inboxDir: string, taskId: string, decision: "approved" | "denied"): void;
+/**
+ * The main daemon class. Coordinates watchers, leasing, loop execution, and
+ * notifications.
+ *
+ * Usage:
+ *   const daemon = new LoopDaemon({ dryRun: true, sources: ["inbox", "bus"] });
+ *   daemon.start();
+ *   // ... daemon runs in the background ...
+ *   daemon.stop();
+ */
+export declare class LoopDaemon {
+    private readonly config;
+    private readonly agentId;
+    private readonly leaseManager;
+    private readonly bus;
+    private readonly notificationCenter;
+    private readonly inboxDir;
+    private readonly inboxWatcher;
+    private readonly busWatcher;
+    private readonly bdWatcher;
+    private readonly cronWatcher;
+    private readonly tunnelMonitor;
+    private readonly statusLine;
+    private readonly widget;
+    /** Currently running tasks (taskId → RunningTask) */
+    private readonly running;
+    private stopped;
+    constructor(config?: DaemonConfig);
+    /** Start the daemon — begins watching all configured sources. */
+    start(): void;
+    /** Stop all watchers and release all held leases. */
+    stop(): void;
+    /** Returns true if stop() has been called. */
+    get isStopped(): boolean;
+    private _onTriggered;
+    private _runTask;
+    private _publishTransition;
+    /**
+     * Drive the TUI widget through loop transitions.
+     * Called from onStep within _runTask.
+     */
+    private _updateWidget;
+    private _reviewReportPath;
+    private _releaseLease;
+    private _notifyHumanReviewNeeded;
+    private _closeBdIssue;
+    private _notifyReadyForClient;
+    /**
+     * 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;
+    private _buildChannels;
+}
+export { LoopDaemon as default };
+//# sourceMappingURL=daemon.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * Daemon Acceptance Tests (T1–T7)
+ *
+ * All tests run with dryRun=true — no API keys needed.
+ * Tests write inbox files to /tmp/herdr-workspace (the real workspace the daemon watches).
+ *
+ * Run:
+ *   bun test harness/langchain/daemon.test.ts
+ */
+export {};
+//# sourceMappingURL=daemon.test.d.ts.map

package/harness/langchain/daemon.test.ts

@@ -316,7 +316,9 @@ describe("T6 — maxIterations cap", () => {
 			review: async () => ({
 				verdict: "changes_requested" as const,
 				summary: "need changes",
-				comments: [{ file: `file${counter.n}.ts`, comment: "fix this", severity: "major" }],
+				comments: [
+					{ file: `file${counter.n}.ts`, comment: "fix this", severity: "major" },
+				],
 			}),
 		};
 		const daemon = new LoopDaemon(