pi-harness-runtime 1.1.398 → 1.1.402

package/harness/langchain/model-router.d.ts

@@ -1,63 +0,0 @@
-/**
- * Smart model router — reads the request prompt and decides which model to use
- * for each agent role at runtime. No hardcoded model IDs; all choices are driven
- * by env vars + optional per-request directives in the prompt.
- *
- * Per-request directives (optional — fallback to env defaults if absent):
- *
- *   Planner directive:
- *     [planner: gpt-5.6]   or  [planner: GLM-5.2]   or  [planner: MiniMax-M2]
- *
- *   Reviewer directive (master reviewer — GLM is the design default):
- *     [reviewer: GLM-5.2]  or  [reviewer: GPT-5.6]
- *
- *   Coder directive:
- *     [coder: MiniMax-M2]   or  [coder: gpt-5.6]
- *
- *   Examples in a prompt:
- *     "Implement X   [reviewer: GPT-5.6]  [planner: GLM-5.2]"
- *     "Use GLM as master reviewer for this task"
- *     "GPT as reviewer: please review this code"
- *
- *   The parser is forgiving — these all work:
- *     [reviewer: GLM]        → uses GLM_MODEL from env
- *     [reviewer: gpt]         → uses PLANNER_MODEL from env (same family)
- *     [reviewer: MiniMax]     → uses MINIMAX_MODEL from env
- *
- * Wiki: wiki/multi-agent-langchain.md
- */
-/** Model options derived from a resolved env prefix. */
-export interface ResolvedModel {
-    model: string;
-    baseURL: string;
-    apiKey: string;
-}
-/** Result of routing a request to models. */
-export interface RouteResult {
-    planner: ResolvedModel;
-    reviewer: ResolvedModel;
-    coder: ResolvedModel;
-    /** Text of the request with directive comments stripped (safe for agent prompts). */
-    cleanRequest: string;
-}
-/**
- * Resolve a model family to actual env-backed model options.
- * family: "GLM" | "PLANNER" | "MINIMAX" (case-insensitive input)
- */
-export declare function resolveModel(family: string): ResolvedModel;
-/**
- * Route a request prompt to the correct model configuration.
- *
- * Algorithm:
- * 1. Extract [role: family] directives from the prompt
- * 2. Resolve each family to actual env-backed model options
- * 3. Apply defaults (planner→PLANNER, reviewer→GLM, coder→MINIMAX)
- * 4. Strip directive comments from the request before passing to agents
- */
-export declare function routeRequest(request: string): RouteResult;
-/**
- * Route a request, also scanning natural-language hints.
- * Directives ([role: family]) take precedence over natural hints.
- */
-export declare function routeRequestSmart(request: string): RouteResult;
-//# sourceMappingURL=model-router.d.ts.map

package/harness/langchain/model-router.test.d.ts

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

package/harness/langchain/models.d.ts

@@ -1,72 +0,0 @@
-/**
- * Model factories — all models fully env-driven, no hardcoded defaults.
- *
- * Agent roles (configurable via env):
- *   planner  → GPT  (PLANNER_API_KEY, PLANNER_MODEL, PLANNER_BASE_URL)
- *   reviewer → GLM  (GLM_API_KEY,     GLM_MODEL,     GLM_BASE_URL)
- *   coder    → MiniMax (MINIMAX_API_KEY, MINIMAX_MODEL, MINIMAX_BASE_URL)
- *
- * Wiki: wiki/multi-agent-langchain.md
- */
-import { ChatOpenAI } from "@langchain/openai";
-export interface ModelOptions {
-    /** Override model id (e.g. "gpt-5.6", "GLM-5.2", "MiniMax-M2") */
-    model?: string;
-    /** Override API base URL */
-    baseURL?: string;
-    /** Override API key */
-    apiKey?: string;
-    /** Sampling temperature */
-    temperature?: number;
-}
-/**
- * Pre-resolved model config from model-router.ts.
- * Pass this to skip env-lookup and use the routed model directly.
- */
-export interface ResolvedModelOptions {
-    model: string;
-    baseURL: string;
-    apiKey: string;
-    /** Sampling temperature */
-    temperature?: number;
-}
-/**
- * Planner model — GPT family.
- *
- * Can be called with:
- *   - ModelOptions (override fields, rest from env)
- *   - ResolvedModelOptions (fully resolved from model-router, no env lookup)
- *
- * Env vars (when using ModelOptions):
- *   PLANNER_API_KEY   (required)
- *   PLANNER_MODEL     (required)
- *   PLANNER_BASE_URL  (required)
- */
-export declare function createPlannerModel(opts?: ModelOptions | ResolvedModelOptions): ChatOpenAI;
-/**
- * Reviewer model — GLM family (master reviewer per design).
- *
- * Can be called with:
- *   - ModelOptions (override fields, rest from env)
- *   - ResolvedModelOptions (fully resolved from model-router, no env lookup)
- *
- * Env vars (when using ModelOptions):
- *   GLM_API_KEY   (required)
- *   GLM_MODEL     (required)
- *   GLM_BASE_URL  (required)
- */
-export declare function createReviewerModel(opts?: ModelOptions | ResolvedModelOptions): ChatOpenAI;
-/**
- * Coder model — MiniMax family.
- *
- * Can be called with:
- *   - ModelOptions (override fields, rest from env)
- *   - ResolvedModelOptions (fully resolved from model-router, no env lookup)
- *
- * Env vars (when using ModelOptions):
- *   MINIMAX_API_KEY   (required)
- *   MINIMAX_MODEL     (required)
- *   MINIMAX_BASE_URL  (required)
- */
-export declare function createCoderModel(opts?: ModelOptions | ResolvedModelOptions): ChatOpenAI;
-//# sourceMappingURL=models.d.ts.map

package/harness/langchain/ping-pong-middleware.d.ts

@@ -1,28 +0,0 @@
-import { PingPongDecisionEngine, type PingPongDecisionOptions, type PingPongDecisionResult } from "../../packages/intent-analyzer/src/index.js";
-export interface PingPongMiddlewareOptions extends PingPongDecisionOptions {
-    /** Shared directory watched by LoopDaemon. Defaults to /tmp/herdr-workspace. */
-    workspace?: string;
-    /** Repository root and blackboard owner. Defaults to process.cwd(). */
-    projectRoot?: string;
-    /** Agent or terminal identifier for audit records. */
-    actorId?: string;
-    /** Also enqueue suggest_ping_pong decisions. Default: false. */
-    enqueueSuggestions?: boolean;
-    /** Test hook for stable timestamps. */
-    now?: () => Date;
-}
-export interface PingPongMiddlewareResult {
-    decision: PingPongDecisionResult;
-    enqueued: boolean;
-    taskId?: string;
-    taskFile?: string;
-    auditFile: string;
-    blackboardFile: string;
-}
-export declare class PingPongMiddleware {
-    private readonly engine;
-    constructor(engine?: PingPongDecisionEngine);
-    submit(request: string, options?: PingPongMiddlewareOptions): PingPongMiddlewareResult;
-}
-export declare function submitPingPongIntent(request: string, options?: PingPongMiddlewareOptions): PingPongMiddlewareResult;
-//# sourceMappingURL=ping-pong-middleware.d.ts.map

package/harness/langchain/ping-pong-middleware.test.d.ts

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

package/harness/langchain/run.d.ts

@@ -1,15 +0,0 @@
-/**
- * CLI runner for the LangChain write-review loop.
- *
- * Usage:
- *   bun harness/langchain/run.ts --mode graph --request "implement X" [--max-iterations 3]
- *   bun harness/langchain/run.ts --mode graph --request "implement X" --dry-run
- *   bun harness/langchain/run.ts --mode supervisor --request "implement X"
- *
- * --dry-run uses deterministic stubs — no API keys needed. Use it to verify
- * the whole loop machinery (plan → write → review → fix → approve).
- *
- * Wiki: wiki/multi-agent-langchain.md
- */
-export {};
-//# sourceMappingURL=run.d.ts.map

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

@@ -1,13 +0,0 @@
-/**
- * Scoreboard integration tests — T15
- *
- * Tests that the WriteReviewBlackboard is correctly wired into the LangGraph loop:
- * 1. `buildRealLoopDeps` creates and updates the blackboard at each step
- * 2. Agent prompts receive the scoreboard markdown
- * 3. `status.json` reflects the current phase/verdict/files
- *
- * Run:
- *   bun test harness/langchain/scoreboard.test.ts
- */
-export {};
-//# sourceMappingURL=scoreboard.test.d.ts.map

package/harness/langchain/status-line.d.ts

@@ -1,91 +0,0 @@
-/**
- * Status line manager — drives the harness loop status in the pi host.
- *
- * Architecture:
- *
- *   Pi-lens installed?
- *   ├─ YES → LoopWidget.makeRenderer() → pi host's ui.setWidget("harness-loop", ...)
- *   └─ NO  → write to .harness-status → pi host reads and displays
- *
- * The status line shows two tiers of information:
- *   [loop status]  [API quota]
- *   [P] planning  |  MiniMax: 5h: 89% left · week: 90% left
- *
- * API quota is read from ~/.pi-harness/quota.json (written by the pi host
- * process that has access to the TUI quota signals).  The daemon polls this
- * file every 60s so the status line stays fresh even when no task is running.
- *
- * Wiki: wiki/pi-lens-status-line.md
- */
-export interface QuotaData {
-    /** MiniMax 5-hour window usage percentage (0–100). Undefined = unknown. */
-    fiveHourPercent?: number;
-    /** MiniMax weekly window usage percentage (0–100). Undefined = unknown. */
-    weeklyPercent?: number;
-    /** ISO timestamp of when the 5-hour quota resets. */
-    fiveHourResetAt?: string;
-    /** ISO timestamp of when the weekly quota resets. */
-    weeklyResetAt?: string;
-    /** Raw message from GLM quota signal (for display) */
-    rawMessage?: string;
-}
-/** True when the daemon is running inside a pi-lens-equipped pi host. */
-export declare function isPiLensAvailable(): boolean;
-/**
- * Build a one-line status string.
- * Format: "MiniMax: 5h: 89% left (resets in 2h) · week: 90% left"
- */
-export declare function formatQuotaLine(q: QuotaData): string;
-/**
- * Drives the harness status line in the pi host.
- *
- * - When pi-lens is available: provides the LoopWidget renderer factory
- *   for the pi host to integrate via `ui.setWidget("harness-loop", factory)`.
- * - When pi-lens is not available: writes a plain-text status to
- *   `<workspace>/.harness-status` every time update() is called.
- *
- * The pi host can read `.harness-status` and display it in its own UI.
- */
-export declare class StatusLineManager {
-    private readonly workspace;
-    private readonly quotaFile;
-    private lastQuota;
-    private timer?;
-    private loopStatus;
-    constructor(workspace: string);
-    /**
-     * Start polling the quota file.
-     * Call once after construction.
-     */
-    start(): void;
-    /** Stop polling. */
-    stop(): void;
-    /**
-     * Update the loop status (planning/writing/reviewing/finished).
-     * Call this from the daemon's onStep handler.
-     */
-    updateLoopStatus(status: string): void;
-    /**
-     * Update the full status — call after each loop transition.
-     * Writes the status file (when no pi-lens) and logs to console.
-     */
-    update(data: {
-        loopStatus?: string;
-        quota?: QuotaData;
-    }): void;
-    /**
-     * Returns a rendered one-line status string for the pi host to display.
-     * Combines loop status + quota into a single readable line.
-     */
-    getLine(): string;
-    private _pollQuota;
-    private _writeStatusFile;
-}
-/**
- * Write quota data to the shared quota file.
- * Call this from the pi host process that receives GLM TUI signals.
- *
- * The daemon reads this file to keep its status line fresh.
- */
-export declare function writeQuotaFile(data: QuotaData): void;
-//# sourceMappingURL=status-line.d.ts.map

package/harness/langchain/status-line.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * StatusLineManager tests — T16
- *
- * Tests the pi-lens detection, quota formatting, and status file writing
- * when pi-lens is not available.
- */
-export {};
-//# sourceMappingURL=status-line.test.d.ts.map

package/harness/langchain/surge.d.ts

@@ -1,111 +0,0 @@
-/**
- * Surge auto-resume — 529 / overloaded_error (MiniMax) + 1308 (GLM quota) detection,
- * escalation backoff, and retry wrappers for the daemon's graph invocations.
- *
- * Two wrappers:
- *   invokeWithSurgeRetry     — MiniMax 529/overload; exponential backoff
- *   invokeWithGLMRetry       — GLM 1308 quota; waits until reset time
- *
- * Wiki: wiki/peak-hour-surge-auto-resume.md
- */
-export interface SurgeSignal {
-    /** Parsed recovery delay in ms (midpoint of the stated range, or fallback) */
-    retryAfterMs: number;
-    /** True when the delay came from an explicit provider statement */
-    explicit: boolean;
-    /** Raw error text for logs */
-    sourceText: string;
-}
-/**
- * Classify an unknown error as a transient provider surge (MiniMax).
- * Returns null for anything that is not a 529/overload-class failure.
- */
-export declare function classifySurge(err: unknown): SurgeSignal | null;
-/**
- * Classify a GLM 1308 quota exhaustion error.
- * Returns the reset-at ISO timestamp, or null if not a GLM quota error.
- */
-export declare function classifyGLMQuota(err: unknown): GLMQuotaSignal | null;
-export interface GLMQuotaSignal {
-    /** ISO timestamp when the quota resets */
-    resetAt: string;
-    /** Epoch ms when the quota resets */
-    resetAtEpoch: number;
-    /** Raw error text for logs */
-    sourceText: string;
-}
-export interface SurgePolicy {
-    /** Override the signal's parsed delay (ms). Default: use the signal. */
-    baseDelayMs?: number;
-    /** Delay multiplier per attempt. Default: 2 (3 → 6 → 12 min) */
-    multiplier: number;
-    /** Floor for any wait. Default: 30_000 (never hammer a surging provider) */
-    minDelayMs: number;
-    /** Ceiling for any wait. Default: 15 min */
-    maxDelayMs: number;
-    /** ± ratio applied as jitter. Default: 0.2 */
-    jitterRatio: number;
-    /** Max surge pauses before giving up. Default: 5 */
-    maxAttempts: number;
-}
-/**
- * Deterministic delay computation (unit-testable, no timers).
- * `rand` in [0,1] controls jitter; omit it for zero jitter.
- */
-export declare function computeSurgeDelayMs(signal: SurgeSignal, attempt: number, policy?: Partial<SurgePolicy>, rand?: number): number;
-/** Attempt counter with escalation; persists across a task's lifetime. */
-export declare class SurgeScheduler {
-    private attempt;
-    private readonly policy;
-    constructor(policy?: Partial<SurgePolicy>);
-    /** Next attempt number, or null when maxAttempts is exhausted. */
-    nextAttempt(): number | null;
-    get attempts(): number;
-    delayFor(signal: SurgeSignal, rand?: number): number;
-}
-export interface SurgeRetryOptions {
-    policy?: Partial<SurgePolicy>;
-    /**
-     * Pre-existing scheduler to use. When provided, the attempt counter persists
-     * across calls — enabling true exponential escalation across multiple surges
-     * within the same task (e.g. surge on 2nd loop.invoke, surge on 3rd loop.invoke).
-     * If omitted, a fresh scheduler is created (attempt counter resets per call).
-     */
-    scheduler?: SurgeScheduler;
-    /** Called before each surge pause (logging / notifications) */
-    onSurge?: (info: {
-        attempt: number;
-        delayMs: number;
-        signal: SurgeSignal;
-    }) => void;
-    /** Called once when attempts are exhausted (no more retries in this scheduler).
-     * Can be async to allow sleeping. Return true to retry, false/undefined to throw.
-     */
-    onExhausted?: (signal: SurgeSignal) => boolean | void | Promise<boolean | void>;
-    /** Injectable sleep for tests. Default: real setTimeout */
-    sleep?: (ms: number) => Promise<void>;
-}
-/**
- * Run `fn`, retrying only on surge-classified failures (MiniMax 529/overload)
- * with exponential backoff. Non-surge errors rethrow immediately.
- */
-export declare function invokeWithSurgeRetry<T>(fn: () => Promise<T>, opts?: SurgeRetryOptions): Promise<T>;
-export interface GLMRetryOptions {
-    /** Called when GLM quota exhaustion is detected (for status-line countdown) */
-    onGLMQuota?: (signal: GLMQuotaSignal) => void;
-    /** Called after the countdown expires and the loop retries */
-    onGLMRetry?: (signal: GLMQuotaSignal) => void;
-    /** Called when the GLM quota error is non-retryable (e.g., no reset time) */
-    onGLMExhausted?: (signal: GLMQuotaSignal) => void;
-    /** Injectable sleep for tests. Default: real setTimeout */
-    sleep?: (ms: number) => Promise<void>;
-    /** How often to tick the countdown callback (default: 30s) */
-    tickMs?: number;
-}
-/**
- * Run `fn`, retrying on GLM 1308 quota errors.
- * After the first 1308, waits until the reset time before retrying.
- * Subsequent 1308s within the same wait window are silently ignored.
- * Non-GLM-quota errors rethrow immediately.
- */
-export declare function invokeWithGLMRetry<T>(fn: () => Promise<T>, opts?: GLMRetryOptions): Promise<T>;

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

@@ -1,10 +0,0 @@
-/**
- * Surge auto-resume tests — S2/S4 acceptance (wiki/peak-hour-surge-auto-resume.md)
- *
- * All deterministic via injected sleep/rand — no real timers, no API keys.
- *
- * Run:
- *   bun test harness/langchain/surge.test.ts
- */
-export {};
-//# sourceMappingURL=surge.test.d.ts.map

package/harness/langchain/widget.d.ts

@@ -1,105 +0,0 @@
-/**
- * LoopWidget — harness progress display for the pi host status line.
- *
- * Architecture mirrors pi-lens's `clients/widget-state.ts` + `renderWidget()`:
- * - State store: per-file step counts, iteration, phase
- * - Render function: builds the `!NW ●ME` style summary line
- * - Pi host integration: wired via ExtensionUIContext.setWidget() when available
- *
- * The widget is designed as a dependency injected into LoopDaemon/LoopRuntime,
- * so it works in two modes:
- * 1. Standalone (console): logs human-readable progress to stderr
- * 2. Pi host: calls ui.setWidget("harness-loop", renderFn) for TUI display
- *
- * Wiki: wiki/multi-agent-langchain.md
- */
-import type { TUI } from "@earendil-works/pi-tui";
-import type { Theme } from "@earendil-works/pi-coding-agent";
-/** Valid theme color keys passed to `theme.fg()`.*/
-type ColorKey = "dim" | "error" | "warning" | "success" | "accent";
-export type LoopPhase = "idle" | "planning" | "writing" | "reviewing" | "fixing" | "approving" | "blocked" | "surge-pause" | "complete" | "error";
-export interface LoopWidgetOptions {
-    /** Called with the rendered lines each time the widget updates. */
-    onRender?: (lines: string[]) => void;
-}
-export declare class LoopWidget {
-    private files;
-    private phase;
-    private iteration;
-    private maxIterations;
-    private stepLabel;
-    private errors;
-    private warnings;
-    private readonly onRender?;
-    constructor(options?: LoopWidgetOptions);
-    /** Called when the loop starts a new iteration. */
-    startIteration(iter: number, max: number): void;
-    /** Called when the loop transitions to a new phase. */
-    setPhase(phase: LoopPhase, label?: string): void;
-    /** Called when the coder writes to a file. */
-    recordWrite(filePath: string): void;
-    /** Called when the reviewer reports blockers for a file. */
-    recordBlockers(filePath: string, count: number): void;
-    /** Called when the reviewer passes a file (no blockers). */
-    recordReviewPass(filePath: string): void;
-    /** Called on surge-pause / quota-wait events. */
-    setSurgePause(resetAt?: Date): void;
-    /** Called on unrecoverable error. */
-    setError(message: string): void;
-    /** Called when the loop completes with a verdict. */
-    setComplete(verdict: "approved" | "rejected" | "max_iterations"): void;
-    /** Reset to idle state. */
-    reset(): void;
-    /**
-     * Build widget lines for the pi host's `setWidget()` renderer.
-     *
-     * Returns 0-3 lines:
-     * Line 1: `harness  [iter 2/5]  ✍ coder  !2W`   — header + summary
-     * Line 2: `  surge pause — resets 19:17`           — surge detail (when applicable)
-     * Line 3: `  ●surge.ts  ✍2  🔍3  !1`             — file rows (up to 5)
-     */
-    renderWidget(width: number, theme: {
-        fg: (color: ColorKey, s: string) => string;
-    }): string[];
-    /** Console fallback (standalone mode). */
-    toConsoleString(): string;
-    /**
-     * Returns a pi-tui Component factory for use with `ui.setWidget("harness-loop", factory)`.
-     * The caller (pi host integration) owns the `setWidget` call — this factory is just
-     * the render function.
-     *
-     * Usage in pi host:
-     * ```
-     * setWidget("harness-loop", makeWidgetRenderer(widget, theme), { placement: "belowEditor" });
-     * ```
-     */
-    /**
-     * Returns a factory suitable for `ui.setWidget("harness-loop", factory)` in the
-     * pi host. The factory's `render(width)` is called by the pi-tui render loop
-     * on every frame; `invalidate` is called by the harness to trigger a re-render.
-     */
-    makeRenderer(): {
-        factory: (tui: TUI, theme: Theme) => {
-            render: (width: number) => string[];
-            invalidate: () => void;
-            dispose: () => void;
-        };
-        invalidate: () => void;
-    };
-    private getOrCreate;
-    private fileRecords;
-    private fileBasename;
-    private classifyFileTier;
-    private phaseLabel;
-    private phaseIcon;
-    private formatResetTime;
-    /**
-     * Truncate `line` to `width` visible columns.
-     * Uses `visibleWidth` (not raw char count) so ANSI codes don't cause
-     * false wrapping — matching how the terminal measures columns.
-     */
-    private fitLine;
-    private render;
-}
-export declare function getLoopWidget(): LoopWidget;
-//# sourceMappingURL=widget.d.ts.map

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

@@ -1,8 +0,0 @@
-/**
- * LoopWidget tests — T14
- *
- * Run:
- *   bun test harness/langchain/widget.test.ts
- */
-export {};
-//# sourceMappingURL=widget.test.d.ts.map

package/packages/autonomous-runtime/dist/worker.d.ts

@@ -1,63 +0,0 @@
-/**
- * Worker Stub — RFC-0101 §4
- *
- * A worker is a pi session that owns tasks from the inbox.
- * This is the lightweight worker-side of the lease protocol.
- *
- * The worker picks up work via the inbox's `claim()` method
- * and reports results via `complete()`.
- */
-import type { TaskResult, WorkerStatus } from "./types.js";
-import type { TaskInbox } from "./inbox.js";
-import type { TaskLease } from "./lease.js";
-export interface WorkerConfig {
-    inbox: TaskInbox;
-    workerId: string;
-    heartbeatIntervalMs?: number;
-    onError?: (taskId: string, error: unknown) => void;
-}
-export interface WorkerEvents {
-    onLease: (lease: TaskLease) => void;
-    onLeaseExpired: (taskId: string) => void;
-    onComplete: (taskId: string, result: TaskResult) => void;
-    onError: (taskId: string, error: unknown) => void;
-}
-/**
- * Worker — picks up tasks from the inbox and processes them.
- *
- * Lifecycle:
- * 1. Construct with inbox + workerId
- * 2. `start()` — begins polling/claiming tasks
- * 3. `stop()` — stops claiming, expires held leases
- *
- * The worker does NOT run tasks itself — it delegates to the harness
- * loop runtime. It just manages the lease lifecycle.
- */
-export declare class Worker {
-    private readonly config;
-    private readonly events;
-    private running;
-    private heartbeatTimer;
-    constructor(config: WorkerConfig);
-    on<K extends keyof WorkerEvents>(event: K, handler: WorkerEvents[K]): void;
-    /**
-     * Start the worker — begins polling for available tasks.
-     */
-    start(): Promise<void>;
-    /**
-     * Stop the worker — stops polling and expires any held leases.
-     */
-    stop(): Promise<void>;
-    /**
-     * Status of this worker.
-     */
-    status(): WorkerStatus;
-    private _poll;
-    private _processTask;
-    /**
-     * Run a single task. Stub — replaces with actual harness loop integration.
-     */
-    private _runTask;
-    private _heartbeat;
-}
-//# sourceMappingURL=worker.d.ts.map