infinity-harness 2.0.0

package/src/modelRouter.ts

@@ -0,0 +1,184 @@
+/**
+ * modelRouter — difficulty tiers + MASTER ladder, fresh-read each call, optional via harness/model-router.json v1
+ * Priority: task.modelHint > byDifficulty[difficulty] > byFeature > bySprint > byPhase > byRole > default
+ * Ladder: easy -> moderate -> difficult -> MASTER (MASTER never directly assigned)
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { writeJsonAtomic, stripBom } from "./core/fsx.ts";
+
+export const ROUTER_FILE = "harness/model-router.json";
+export const ROUTER_VERSION = 1;
+
+export interface RouterConfig {
+  version: number;
+  enabled: boolean;
+  default: string;
+  byDifficulty?: Record<string, string>;
+  master?: string;
+  byPhase?: Record<string, string>;
+  byRole?: Record<string, string>;
+  byFeature?: Record<string, string>;
+  bySprint?: Record<string, string>;
+  byTask?: Record<string, string>;
+  consultation?: { enabled: boolean; maxPerTask: number; oneStepOnly: boolean; requireExhaustion: boolean };
+  budgets?: { maxReworksPerRun: number; maxReplansPerRun: number; maxReviewBounces: number };
+}
+
+/**
+ * Router defaults.
+ *
+ * Every model slot is empty on purpose. An empty string means "whatever model
+ * pi is already configured with", so installing the harness never silently
+ * redirects work to some vendor's model that the user did not choose. Routing
+ * only takes effect once someone fills in harness/model-router.json and sets
+ * `enabled: true`.
+ */
+export const DEFAULT_ROUTER: RouterConfig = {
+  version: 1,
+  enabled: false,
+  default: "",
+  byDifficulty: {
+    easy: "",
+    moderate: "",
+    difficult: "",
+  },
+  master: "",
+  byPhase: {},
+  byRole: {},
+  byFeature: {},
+  bySprint: {},
+  byTask: {},
+  consultation: { enabled: true, maxPerTask: 1, oneStepOnly: true, requireExhaustion: true },
+  budgets: { maxReworksPerRun: 3, maxReplansPerRun: 2, maxReviewBounces: 2 },
+};
+
+export const DIFFICULTY_LADDER: Array<"easy" | "moderate" | "difficult"> = ["easy", "moderate", "difficult"];
+
+function routerPath(projectDir = process.cwd()): string { return resolve(projectDir, ROUTER_FILE); }
+
+/**
+ * Persist the router config.
+ *
+ * Written atomically and read fresh on every resolution, so an edit made from
+ * the config TUI takes effect on the next task without restarting the session.
+ */
+export function saveRouterConfig(projectDir: string, cfg: RouterConfig): void {
+  writeJsonAtomic(routerPath(projectDir), cfg);
+}
+
+export function loadRouterConfig(projectDir?: string): RouterConfig {
+  const p = routerPath(projectDir);
+  if (!existsSync(p)) return { ...DEFAULT_ROUTER, byDifficulty: { ...DEFAULT_ROUTER.byDifficulty! }, byPhase: {}, byRole: {}, byFeature: {}, bySprint: {}, byTask: {}, consultation: { ...DEFAULT_ROUTER.consultation! }, budgets: { ...DEFAULT_ROUTER.budgets! } };
+  try {
+    const raw = JSON.parse(stripBom(readFileSync(p, "utf-8")));
+    // merge with defaults to ensure fields
+    const cfg: RouterConfig = {
+      version: typeof raw.version === "number" ? raw.version : 1,
+      enabled: typeof raw.enabled === "boolean" ? raw.enabled : false,
+      default: typeof raw.default === "string" && raw.default ? raw.default : DEFAULT_ROUTER.default,
+      byDifficulty: raw.byDifficulty ?? { ...DEFAULT_ROUTER.byDifficulty! },
+      master: typeof raw.master === "string" ? raw.master : DEFAULT_ROUTER.master,
+      byPhase: raw.byPhase ?? {},
+      byRole: raw.byRole ?? {},
+      byFeature: raw.byFeature ?? {},
+      bySprint: raw.bySprint ?? {},
+      byTask: raw.byTask ?? {},
+      consultation: raw.consultation ?? { ...DEFAULT_ROUTER.consultation! },
+      budgets: raw.budgets ?? { ...DEFAULT_ROUTER.budgets! },
+    };
+    if (!cfg.byDifficulty) cfg.byDifficulty = { ...DEFAULT_ROUTER.byDifficulty! };
+    return cfg;
+  } catch {
+    return { ...DEFAULT_ROUTER };
+  }
+}
+
+export interface ResolveOpts {
+  projectDir?: string;
+  task?: { difficulty?: string; modelHint?: string; id?: string; key?: string };
+  feature?: { id?: string; difficulty?: string };
+  sprint?: { id?: string; difficulty?: string };
+  phase?: string;
+  role?: string;
+  // direct overrides for testing
+  difficulty?: string;
+  modelHint?: string;
+}
+
+export function resolveModel(opts: ResolveOpts = {}): string {
+  const cfg = loadRouterConfig(opts.projectDir);
+  if (!cfg.enabled) return cfg.default;
+  // 1. task.modelHint (explicit override)
+  const hint = opts.modelHint ?? opts.task?.modelHint;
+  if (hint && hint.trim()) return hint.trim();
+  // 2. byTask exact key
+  const taskKey = opts.task?.key ?? opts.task?.id;
+  if (taskKey && cfg.byTask && cfg.byTask[taskKey]) return cfg.byTask[taskKey];
+  // 3. byDifficulty[difficulty]
+  const difficulty = opts.difficulty ?? opts.task?.difficulty ?? opts.feature?.difficulty ?? opts.sprint?.difficulty;
+  if (difficulty && cfg.byDifficulty && (cfg.byDifficulty as Record<string, string>)[difficulty]) {
+    return (cfg.byDifficulty as Record<string, string>)[difficulty];
+  }
+  // 4. byFeature
+  const featureId = opts.feature?.id;
+  if (featureId && cfg.byFeature && cfg.byFeature[featureId]) return cfg.byFeature[featureId];
+  // 5. bySprint
+  const sprintId = opts.sprint?.id;
+  if (sprintId && cfg.bySprint && cfg.bySprint[sprintId]) return cfg.bySprint[sprintId];
+  // 6. byPhase
+  if (opts.phase && cfg.byPhase && cfg.byPhase[opts.phase]) return cfg.byPhase[opts.phase];
+  // 7. byRole
+  if (opts.role && cfg.byRole && cfg.byRole[opts.role]) return cfg.byRole[opts.role];
+  return cfg.default;
+}
+
+/**
+ * One-step ladder: easy -> moderate -> difficult -> MASTER
+ * MASTER never assigned, only via consultNext after exhaustion.
+ * Returns next model or null if at top/budget exhausted.
+ */
+export function consultNext(
+  currentDifficulty: string | null | undefined,
+  opts: { projectDir?: string; consultedCount?: number } = {},
+): string | null {
+  const cfg = loadRouterConfig(opts.projectDir);
+  if (!cfg.consultation?.enabled) return null;
+  const maxPerTask = cfg.consultation.maxPerTask ?? 1;
+  if ((opts.consultedCount ?? 0) >= maxPerTask) return null;
+  // oneStepOnly: only one step per call
+  if (!currentDifficulty) {
+    // from no difficulty -> easy? Actually consult is after exhaustion of current ladder rung
+    // If no difficulty, next is byDifficulty easy, else if easy -> moderate etc.
+    return null;
+  }
+  const idx = DIFFICULTY_LADDER.indexOf(currentDifficulty as any);
+  if (idx === -1) {
+    // unknown difficulty: check if current is byDifficulty value? Try to infer
+    return null;
+  }
+  if (idx < DIFFICULTY_LADDER.length - 1) {
+    const nextDiff = DIFFICULTY_LADDER[idx + 1];
+    const nextModel = cfg.byDifficulty?.[nextDiff] ?? DEFAULT_ROUTER.byDifficulty![nextDiff];
+    return nextModel ?? null;
+  }
+  // at difficult -> MASTER
+  if (idx === DIFFICULTY_LADDER.length - 1) {
+    return cfg.master ?? DEFAULT_ROUTER.master ?? null;
+  }
+  return null;
+}
+
+/** For widget/remote read-only exposure */
+export function routerSummary(projectDir?: string): { enabled: boolean; default: string; byDifficulty: Record<string, string>; master: string; budgets: RouterConfig["budgets"]; consultation: RouterConfig["consultation"] } {
+  const cfg = loadRouterConfig(projectDir);
+  return {
+    enabled: cfg.enabled,
+    default: cfg.default,
+    byDifficulty: { ...(cfg.byDifficulty ?? {}) } as Record<string, string>,
+    master: cfg.master ?? DEFAULT_ROUTER.master!,
+    budgets: cfg.budgets,
+    consultation: cfg.consultation,
+  };
+}

package/src/remote.ts

@@ -0,0 +1,244 @@
+/**
+ * infinity-harness — the read-only dashboard server.
+ *
+ * A developer running the harness unattended wants to glance at progress
+ * without attaching to the terminal session. This serves that view over plain
+ * HTTP on loopback.
+ *
+ * Two properties are non-negotiable:
+ *
+ *   - **Read-only.** Nothing here writes, and nothing bumps `baseRevision`.
+ *     Opening the dashboard must never perturb the run it is observing.
+ *   - **Loopback by default.** The page exposes source paths, task text and
+ *     gate output. Binding it to a public interface would leak the project.
+ *     A non-loopback host has to be asked for explicitly.
+ */
+
+import { createServer, type Server } from "node:http";
+import type { AddressInfo } from "node:net";
+import { resolve } from "node:path";
+
+import type { FeatureList, Feature, Goal, GateResult, Phase } from "./core/types.ts";
+import { loadFeatureList, computeProgress } from "./core/featureList.ts";
+import { loadConfig } from "./core/config.ts";
+import { modelRouterPath, reworkPath } from "./core/paths.ts";
+import { readJsonSafe } from "./core/fsx.ts";
+import { renderDashboard, escapeHtml, type DashboardState } from "./ui/dashboard.ts";
+
+export { escapeHtml };
+
+export interface RemoteOptions {
+  projectDir?: string;
+  host?: string;
+  port?: number;
+}
+
+export interface RemoteState {
+  baseRevision: number;
+  phase: Phase | null;
+  enabledPhases: readonly string[] | null;
+  paused: boolean;
+  features: Feature[];
+  goals: Goal[];
+  list: FeatureList;
+  progress: ReturnType<typeof computeProgress>;
+  gate: GateResult | null;
+  retries: { task: number; max: number };
+  timestamp: string;
+  router: unknown;
+  rework: unknown;
+}
+
+export interface RemoteServer {
+  url: string;
+  host: string;
+  port: number;
+  close(): Promise<void>;
+}
+
+/**
+ * Snapshot everything the dashboard needs, from disk, without mutating a thing.
+ *
+ * The gate is *not* run here — running lint and tests because someone opened a
+ * web page would be a surprising and expensive side effect. The last recorded
+ * verdict from `gateHistory` is reported instead, which is what the human
+ * actually wants: what the harness last decided.
+ */
+export function buildRemoteState(projectDir?: string): RemoteState {
+  const dir = projectDir ? resolve(projectDir) : process.cwd();
+  const { list } = loadFeatureList(dir);
+  const { config } = loadConfig(dir);
+
+  const lastGate = [...(config.gateHistory ?? [])].reverse()[0] ?? null;
+  const gate: GateResult | null = lastGate
+    ? {
+        phase: lastGate.phase,
+        overall: lastGate.result === "pass",
+        failures: lastGate.result === "pass" ? [] : ["see terminal for detail"],
+        checks: [
+          {
+            name: `last recorded gate (${lastGate.timestamp})`,
+            pass: lastGate.result === "pass",
+            detail:
+              lastGate.result === "pass"
+                ? `passed on ${lastGate.phase}`
+                : `failed on ${lastGate.phase} — run validate for the per-check breakdown`,
+          },
+        ],
+        ...(lastGate.feature ? { feature: lastGate.feature } : {}),
+        ...(lastGate.task ? { task: lastGate.task } : {}),
+      }
+    : null;
+
+  return {
+    baseRevision: list.baseRevision,
+    phase: config.currentPhase,
+    enabledPhases: config.phases?.enabled ?? null,
+    paused: Boolean(config.paused),
+    features: list.features ?? [],
+    goals: list.goals ?? [],
+    list,
+    progress: computeProgress(list),
+    gate,
+    retries: { task: config.taskRetryCount ?? 0, max: config.maxRetries ?? 10 },
+    timestamp: new Date().toISOString(),
+    router: readJsonSafe<unknown>(modelRouterPath(dir), null),
+    rework: readJsonSafe<unknown>(reworkPath(dir), null),
+  };
+}
+
+function toDashboardState(s: RemoteState): DashboardState {
+  return {
+    list: s.list,
+    phase: s.phase,
+    enabledPhases: s.enabledPhases,
+    paused: s.paused,
+    gate: s.gate,
+    baseRevision: s.baseRevision,
+    timestamp: s.timestamp,
+    retries: s.retries,
+    router: s.router,
+    rework: s.rework,
+  };
+}
+
+export function buildHtml(state: RemoteState): string {
+  return renderDashboard(toDashboardState(state));
+}
+
+/** JSON payload for `/api/harness`. Excludes the full list to stay compact. */
+export function buildApiPayload(state: RemoteState): Record<string, unknown> {
+  return {
+    baseRevision: state.baseRevision,
+    phase: state.phase,
+    paused: state.paused,
+    progress: state.progress,
+    retries: state.retries,
+    timestamp: state.timestamp,
+    gate: state.gate,
+    router: state.router,
+    rework: state.rework,
+    features: state.features.map((f) => ({
+      id: f.id,
+      name: f.name,
+      passes: f.passes ?? false,
+      tasks: (f.tasks ?? []).map((t) => ({
+        id: t.id,
+        key: t.key ?? t.id,
+        description: t.description,
+        status: t.status,
+        dependsOn: t.dependsOn ?? [],
+        subtasks: t.subtasks ?? [],
+      })),
+    })),
+    goals: state.goals,
+  };
+}
+
+const LOOPBACK = new Set(["127.0.0.1", "::1", "localhost"]);
+
+export async function createRemoteServer(opts?: RemoteOptions): Promise<RemoteServer> {
+  const projectDir = opts?.projectDir ? resolve(opts.projectDir) : process.cwd();
+  const host = opts?.host ?? "127.0.0.1";
+  const port = opts?.port ?? 0;
+
+  if (!LOOPBACK.has(host) && process.env.INFINITY_HARNESS_ALLOW_REMOTE !== "1") {
+    throw new Error(
+      `refusing to bind the dashboard to ${host}: it exposes project source and task text. ` +
+        `Set INFINITY_HARNESS_ALLOW_REMOTE=1 if you really mean to.`,
+    );
+  }
+
+  const server: Server = createServer((req, res) => {
+    // Read-only surface: anything that is not a GET is refused outright.
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      res.writeHead(405, { "content-type": "text/plain; charset=utf-8", allow: "GET, HEAD" });
+      res.end("method not allowed");
+      return;
+    }
+
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    const noStore = { "cache-control": "no-store" };
+
+    try {
+      if (url.pathname === "/api/health") {
+        res.writeHead(200, { "content-type": "application/json; charset=utf-8", ...noStore });
+        res.end(JSON.stringify({ ok: true, timestamp: new Date().toISOString() }));
+        return;
+      }
+      if (url.pathname === "/api/harness") {
+        const payload = buildApiPayload(buildRemoteState(projectDir));
+        res.writeHead(200, { "content-type": "application/json; charset=utf-8", ...noStore });
+        res.end(JSON.stringify(payload, null, 2));
+        return;
+      }
+      if (url.pathname === "/") {
+        const html = buildHtml(buildRemoteState(projectDir));
+        res.writeHead(200, {
+          "content-type": "text/html; charset=utf-8",
+          // The page renders untrusted model output; a tight CSP means an
+          // escaping slip cannot become script execution.
+          "content-security-policy":
+            "default-src 'none'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; connect-src 'self'; img-src data:",
+          "x-content-type-options": "nosniff",
+          ...noStore,
+        });
+        res.end(html);
+        return;
+      }
+      res.writeHead(404, { "content-type": "text/plain; charset=utf-8", ...noStore });
+      res.end("not found");
+    } catch (e) {
+      res.writeHead(500, { "content-type": "text/plain; charset=utf-8", ...noStore });
+      res.end(`dashboard error: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  });
+
+  await new Promise<void>((res, rej) => {
+    server.once("error", rej);
+    server.listen(port, host, () => {
+      server.removeListener("error", rej);
+      res();
+    });
+  });
+
+  const addr = server.address() as AddressInfo;
+  const shownHost = addr.address === "::1" ? "[::1]" : addr.address;
+
+  let closed = false;
+  return {
+    url: `http://${shownHost}:${addr.port}`,
+    host: addr.address,
+    port: addr.port,
+    close: async () => {
+      if (closed) return;
+      closed = true;
+      await new Promise<void>((res) => {
+        server.close(() => res());
+        // Idle keep-alive sockets would otherwise hold the server open past
+        // session shutdown, leaking a port for the life of the process.
+        server.closeAllConnections?.();
+      });
+    },
+  };
+}