infinity-harness 2.6.6 → 2.8.0

package/src/daemon/isolation.ts

@@ -0,0 +1,95 @@
+/**
+ * infinity-harness — daemon/isolation.ts
+ *
+ * Worker isolation: a worker session must not load the harness extension into
+ * the Daemon's process, and must receive the harness tools as customTools.
+ *
+ * The SDK loads discovered extensions by default (DefaultResourceLoader with
+ * reload()). infinity-harness IS an installed pi extension, so a default
+ * loader would load it inside the Daemon and each worker would register
+ * session_start, commands and widgets — sharing module state and driving runs.
+ *
+ * This module produces:
+ *  - a harness-free ResourceLoader (noExtensions, noSkills where appropriate)
+ *  - the harness ToolDefinitions to hand to workers as customTools
+ *  - a helper to assert isolation in tests
+ */
+
+import type { ResourceLoader, ToolDefinition } from "@earendil-works/pi-coding-agent";
+
+export type IsolationOpts = {
+  cwd: string;
+  agentDir?: string;
+};
+
+export type HarnessedLoader = ResourceLoader;
+
+/**
+ * Build a ResourceLoader that WILL NOT discover the harness extension.
+ * Workers receive this as `resourceLoader`.
+ */
+export async function createIsolatedLoader(opts: IsolationOpts): Promise<HarnessedLoader> {
+  const { DefaultResourceLoader, SettingsManager } = await import("@earendil-works/pi-coding-agent");
+  const settingsManager = SettingsManager.create(opts.cwd, opts.agentDir);
+  const loader = new DefaultResourceLoader({
+    cwd: opts.cwd,
+    agentDir: opts.agentDir ?? "",
+    settingsManager,
+    noExtensions: true,
+    noSkills: true,
+    noContextFiles: true,
+  } as unknown as ConstructorParameters<typeof DefaultResourceLoader>[0]);
+  await loader.reload();
+  return loader as HarnessedLoader;
+}
+
+/**
+ * Minimal harness tools that a worker needs to function.
+ * Daemon hands these as `customTools` so the worker's ability to record work
+ * is declared, not discovered. A worker that cannot record is a worker whose
+ * unit loops forever.
+ */
+export function harnessToolsForWorker(): ToolDefinition[] {
+  return [
+    {
+      name: "infinity_plan",
+      description: "Atomic plan editor: submit the full task list. Omission=deletion, baseRevision guard, cycle/missingDep checks.",
+      parameters: {
+        type: "object",
+        properties: {
+          baseRevision: { type: "number" },
+          tasks: { type: "array", items: { type: "object" } },
+          features: { type: "array", items: { type: "object" } },
+          goal: { type: "string" },
+        },
+      },
+      handler: async () => ({ content: [{ type: "text", text: "infinity_plan stub — Daemon replaces this handler" }] }),
+    } as unknown as ToolDefinition,
+    {
+      name: "infinity_validate",
+      description: "Run the deterministic gate; model never decides PASS/FAIL.",
+      parameters: { type: "object", properties: {} },
+      handler: async () => ({ content: [{ type: "text", text: "infinity_validate stub" }] }),
+    } as unknown as ToolDefinition,
+    {
+      name: "infinity_brief",
+      description: "Return the rendered brief for the next unit.",
+      parameters: { type: "object", properties: {} },
+      handler: async () => ({ content: [{ type: "text", text: "infinity_brief stub" }] }),
+    } as unknown as ToolDefinition,
+  ];
+}
+
+/**
+ * Test assertion: a worker session's loader has zero harness extension instances.
+ * The session's extensionsResult captures what was loaded; we count any factory
+ * whose id contains "infinity-harness".
+ */
+export function assertZeroHarnessExtensions(extensionsResult: unknown): void {
+  const result = extensionsResult as { extensions?: Array<{ id?: string; name?: string }> } | null | undefined;
+  const list = result?.extensions ?? [];
+  const found = list.filter((e) => String(e?.id ?? e?.name ?? "").includes("infinity-harness"));
+  if (found.length !== 0) {
+    throw new Error(`isolation violated: worker loaded ${found.length} harness extension(s): ${found.map(f => f.id ?? f.name).join(", ")}`);
+  }
+}

package/src/daemon/preflight.ts

@@ -0,0 +1,132 @@
+/**
+ * infinity-harness — daemon/preflight.ts
+ *
+ * Tier preflight: at arm time, prove each configured tier A/B/C/D/X can serve.
+ * getModel() and getAvailable() are registry checks, not auth checks. Only a
+ * real call proves a tier serves. A tier that fails preflight blocks arming
+ * (naming the tier and reason) — not a warning buried in a log.
+ *
+ * Distinct tiers are probed once. Probe uses SessionManager.inMemory() + a
+ * one-token prompt on a throwaway session with noTools.
+ */
+
+import type { TierId, TierSpec, HarnessConfig } from "../core/types.ts";
+import type { TierResults, TierPreflight } from "../core/runState.ts";
+import { loadConfig } from "../core/config.ts";
+
+export type PreflightResult = { tier: TierId; ok: boolean; servedModel?: string; reason?: string };
+
+export type PreflightOpts = {
+  targetDir: string;
+  tiers?: Partial<Record<TierId, TierSpec>>;
+  /** For tests: inject a probe fn instead of doing the real SDK call. */
+  probe?: (spec: TierSpec) => Promise<{ served: string }>;
+};
+
+function tiersFromConfig(config: HarnessConfig): Partial<Record<TierId, TierSpec>> {
+  const t = (config as unknown as { tiers?: Partial<Record<TierId, TierSpec>> }).tiers;
+  return t && typeof t === "object" && !Array.isArray(t) ? t : {};
+}
+
+function dedupeSpecs(tiers: Partial<Record<TierId, TierSpec>>): Map<string, { tiers: TierId[]; spec: TierSpec }> {
+  const byKey = new Map<string, { tiers: TierId[]; spec: TierSpec }>();
+  for (const [tier, spec] of Object.entries(tiers) as Array<[TierId, TierSpec]>) {
+    if (!spec?.provider || !spec?.id) continue;
+    const key = `${spec.provider}/${spec.id}`;
+    const entry = byKey.get(key);
+    if (entry) entry.tiers.push(tier);
+    else byKey.set(key, { tiers: [tier], spec });
+  }
+  return byKey;
+}
+
+export async function runPreflight(opts: PreflightOpts): Promise<{ results: PreflightResult[]; tierResults: TierResults; blocked: PreflightResult | null }> {
+  const configTiers = opts.tiers ?? tiersFromConfig(loadConfig(opts.targetDir).config);
+  const unique = dedupeSpecs(configTiers);
+  const results: PreflightResult[] = [];
+  const tierResults: TierResults = {};
+
+  if (unique.size === 0) {
+    return { results: [], tierResults: {}, blocked: null };
+  }
+
+  for (const [key, entry] of unique) {
+    let ok = false;
+    let servedModel: string | undefined;
+    let reason: string | undefined;
+    try {
+      if (opts.probe) {
+        const r = await opts.probe(entry.spec);
+        servedModel = r.served || key;
+        ok = true;
+      } else {
+        // Real probe (SDK).
+        const { ModelRuntime, SessionManager, createAgentSession, DefaultResourceLoader, SettingsManager } = await import("@earendil-works/pi-coding-agent");
+        const runtime = await ModelRuntime.create();
+        // getModel is a registry lookup; hasConfiguredAuth guards the credential existence.
+        const model = runtime.getModel(entry.spec.provider, entry.spec.id);
+        if (!model) throw new Error(`unknown model ${key}`);
+        const hasAuth = typeof runtime.hasConfiguredAuth === "function" ? runtime.hasConfiguredAuth(entry.spec.provider) : true;
+        if (!hasAuth) {
+          let check: unknown = undefined;
+          try { check = typeof runtime.checkAuth === "function" ? await runtime.checkAuth(entry.spec.provider) : hasAuth; } catch { check = undefined; }
+          if (!check) throw new Error(`no credential for provider ${entry.spec.provider}`);
+        }
+        // Minimal prompt on an in-memory session.
+        const { resolve } = await import("node:path");
+        const cwd = opts.targetDir;
+        const agentDir = "";
+        const settingsManager = SettingsManager.create(cwd, agentDir);
+        const loader = new DefaultResourceLoader({
+          cwd,
+          agentDir,
+          settingsManager,
+          noExtensions: true,
+          noSkills: true,
+          noContextFiles: true,
+        } as unknown as ConstructorParameters<typeof DefaultResourceLoader>[0]);
+        await loader.reload();
+        const { session } = await createAgentSession({
+          model,
+          modelRuntime: runtime,
+          cwd,
+          resourceLoader: loader,
+          sessionManager: SessionManager.inMemory(cwd),
+          noTools: "all" as unknown as string,
+          thinkingLevel: "minimal" as unknown as string,
+        } as unknown as Parameters<typeof createAgentSession>[0]);
+        try {
+          // One-token probe — the only thing that proves the tier serves.
+          await session.prompt("Reply with the single word: ok");
+          servedModel = `${(session as { model?: { provider?: string; id?: string } }).model?.provider ?? entry.spec.provider}/${(session as { model?: { id?: string } }).model?.id ?? entry.spec.id}`;
+          ok = true;
+        } finally {
+          try { (session as { dispose?: () => void }).dispose?.(); } catch {}
+        }
+      }
+    } catch (e) {
+      ok = false;
+      reason = e instanceof Error ? e.message : String(e);
+      servedModel = undefined;
+    }
+    for (const tier of entry.tiers) {
+      const res: PreflightResult = { tier, ok, ...(servedModel ? { servedModel } : {}), ...(reason ? { reason } : {}) };
+      results.push(res);
+      tierResults[tier] = {
+        provider: entry.spec.provider,
+        id: entry.spec.id,
+        preflight: ok ? "ok" : "fail",
+        ...(servedModel ? { servedModel } : {}),
+        ...(reason ? { reason } : {}),
+      } as TierPreflight;
+    }
+  }
+
+  const blocked = results.find(r => !r.ok) ?? null;
+  return { results, tierResults, blocked };
+}
+
+export function formatPreflightResults(results: PreflightResult[]): string {
+  if (!results.length) return "no tiers configured";
+  return results.map(r => `${r.tier}:${r.ok ? "ok" : `fail(${r.reason ?? "unknown"})`}${r.servedModel ? `:${r.servedModel}` : ""}`).join(" | ");
+}

package/src/daemon/server.ts

@@ -0,0 +1,153 @@
+/**
+ * infinity-harness — daemon/server.ts
+ *
+ * Tiny localhost HTTP for Interfaces -> Daemon control. Daemon binds port 0,
+ * OS picks free, daemon.json records the port+token.
+ *
+ * GET /status  (open)  → state
+ * POST /run | /halt | /pause | /resume | /approve | /replan | /rework   (token-checked)
+ * GET /dashboard → dashboard.ts HTML
+ */
+
+import { createServer, type Server } from "node:http";
+import { daemonPath, runStatePath, supervisorPath, activityPath } from "../core/paths.ts";
+import { readJsonSafe } from "../core/fsx.ts";
+import { isDaemonAlive, loadDaemon } from "./guard.ts";
+
+export type ServerOpts = {
+  targetDir: string;
+  port?: number;
+  token?: string;
+  onRun?: (req: unknown) => Promise<unknown>;
+  onHalt?: (req: unknown) => Promise<unknown>;
+  onPause?: (req: unknown) => Promise<unknown>;
+  onResume?: (req: unknown) => Promise<unknown>;
+  onApprove?: (req: unknown) => Promise<unknown>;
+  onReplan?: (req: unknown) => Promise<unknown>;
+  onRework?: (req: unknown) => Promise<unknown>;
+  onPilot?: (req: unknown) => Promise<unknown>;
+};
+
+export function startServer(opts: ServerOpts): Promise<{ server: Server; port: number; token: string }> {
+  const targetDir = opts.targetDir;
+  // token comes from daemon.json if running, or fresh for a new Daemon — caller should supply.
+  const expectedToken = opts.token ?? loadDaemon(targetDir)?.token ?? null;
+
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "127.0.0.1"}`);
+    const path = url.pathname;
+
+    const writeJson = (code: number, body: unknown): void => {
+      res.writeHead(code, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(body));
+    };
+
+    const requireToken = (): boolean => {
+      if (!expectedToken) return true;
+      const auth = req.headers.authorization ?? "";
+      const queryToken = url.searchParams.get("token") ?? "";
+      const headerToken = auth.startsWith("Bearer ") ? auth.slice(7) : "";
+      const bodyToken = "";
+      // Token is in daemon.json; client reads it and sends via header or query.
+      if (headerToken === expectedToken || queryToken === expectedToken) return true;
+      return false;
+    };
+
+    if (req.method === "GET" && (path === "/status" || path === "/api/status")) {
+      const daemon = loadDaemon(targetDir);
+      const alive = isDaemonAlive(daemon);
+      const run = readJsonSafe<unknown>(runStatePath(targetDir), null);
+      const supervisor = readJsonSafe<unknown>(supervisorPath(targetDir), null);
+      const activity = readJsonSafe<unknown>(activityPath(targetDir), null);
+      writeJson(200, { ok: true, alive, daemon, run, supervisor, activity: Array.isArray(activity) ? (activity as unknown[]).slice(-20) : [] });
+      return;
+    }
+
+    if (req.method === "GET" && (path === "/dashboard" || path === "/" || path === "/api/harness")) {
+      // /api/harness is the JSON shape; dashboard / path serves the dashboard HTML.
+      if (path === "/api/harness") {
+        const { loadFeatureList } = await import("../core/featureList.ts");
+        const { list } = loadFeatureList(targetDir);
+        writeJson(200, { baseRevision: list.baseRevision, features: list.features, goals: list.goals, sprints: list.sprints });
+        return;
+      }
+      try {
+        const { loadFeatureList } = await import("../core/featureList.ts");
+        const { loadConfig } = await import("../core/config.ts");
+        const { renderDashboard } = await import("../ui/dashboard.ts");
+        const { normalizeDisplay } = await import("../ui/display.ts");
+        const { readJsonSafe: rjs } = await import("../core/fsx.ts");
+        const { list } = loadFeatureList(targetDir);
+        const cfg = loadConfig(targetDir).config;
+        const daemon = loadDaemon(targetDir);
+        // dashboard derives viewState same way widget does, but via server data
+        const run = rjs<Record<string,unknown>|null>(runStatePath(targetDir), null);
+        const sup = rjs<Record<string,unknown>|null>(supervisorPath(targetDir), null);
+        const act = rjs<unknown[]>(activityPath(targetDir), []);
+        const html = renderDashboard({
+          list,
+          phase: (cfg.currentPhase as unknown as import("../core/types.ts").Phase) ?? null,
+          enabledPhases: (cfg.phases as { enabled?: readonly string[] })?.enabled ?? null,
+          paused: Boolean((cfg as { paused?: boolean }).paused),
+          gate: null,
+          baseRevision: list.baseRevision,
+          timestamp: new Date().toISOString(),
+          dashboardUrl: daemon ? `http://127.0.0.1:${(daemon as { port?: number }).port ?? 0}/dashboard` : null,
+          handoffModelNote: null,
+          awaitingApproval: (cfg as unknown as { awaitingApproval?: string | null }).awaitingApproval ?? null,
+          display: normalizeDisplay((cfg as unknown as { display?: unknown }).display as unknown as import("../core/types.ts").DisplayPolicy | undefined),
+          engine: "background",
+          workers: sup && typeof (sup as Record<string,unknown>).name === "string" ? [sup as unknown as import("../ui/dashboard.ts").DashWorker] : [],
+          activity: Array.isArray(act) ? (act as unknown as import("../ui/dashboard.ts").DashActivity[]).slice(-40) : [],
+        });
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(html);
+        return;
+      } catch (e) {
+        // If dashboard render throws, fall back to minimal page — never 500 the only way to see the run.
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(`<!doctype html><title>infinity-harness</title>< meta name="viewport" content="width=device-width"><h1>infinity-harness</h1><p>Daemon at ${targetDir}</p><p><a href="/status">/status</a> <a href="/api/harness">/api/harness</a></p><p style="color:#c33">dashboard render error: ${String((e as Error).message ?? e).replace(/[&<>"']/g,c=>({"&":"&amp;","<":"&lt;",">":"&gt;","\"":"&quot;","'":"&#39;"}[c]??c))}</p>`);
+        return;
+      }
+    }
+
+    if (req.method === "POST") {
+      if (!requireToken()) { writeJson(401, { ok: false, error: "invalid token" }); return; }
+      let body = "";
+      req.on("data", chunk => { body += String(chunk); if (body.length > 1_000_000) req.destroy(); });
+      req.on("end", async () => {
+        let parsed: unknown = null;
+        try { parsed = body ? JSON.parse(body) : {}; } catch { parsed = {}; }
+        try {
+          if (path === "/run" && opts.onRun) { const r = await opts.onRun(parsed); writeJson(200, r ?? { ok: true }); return; }
+          if (path === "/halt" && opts.onHalt) { const r = await opts.onHalt(parsed); writeJson(200, r ?? { ok: true }); return; }
+          if (path === "/pause" && opts.onPause) { const r = await opts.onPause(parsed); writeJson(200, r ?? { ok: true }); return; }
+          if (path === "/resume" && opts.onResume) { const r = await opts.onResume(parsed); writeJson(200, r ?? { ok: true }); return; }
+          if (path === "/approve" && opts.onApprove) { const r = await opts.onApprove(parsed); writeJson(200, r ?? { ok: true }); return; }
+          if (path === "/replan" && opts.onReplan) { const r = await opts.onReplan(parsed); writeJson(200, r ?? { ok: true }); return; }
+          if (path === "/rework" && opts.onRework) { const r = await opts.onRework(parsed); writeJson(200, r ?? { ok: true }); return; }
+          if (path === "/pilot" && opts.onPilot) { const r = await opts.onPilot(parsed); writeJson(200, r ?? { ok: true }); return; }
+          writeJson(404, { ok: false, error: `unknown POST ${path}` });
+        } catch (e) {
+          writeJson(500, { ok: false, error: e instanceof Error ? e.message : String(e) });
+        }
+      });
+      return;
+    }
+
+    writeJson(404, { ok: false, error: `unknown ${req.method} ${path}` });
+  });
+
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(opts.port ?? 0, "127.0.0.1", () => {
+      const addr = server.address() as { port: number } | null;
+      const port = addr?.port ?? (opts.port ?? 0);
+      resolve({ server, port, token: expectedToken ?? "" });
+    });
+  });
+}
+
+export function stopServer(server: Server): Promise<void> {
+  return new Promise((resolve) => server.close(() => resolve()));
+}

package/src/daemon/supervisorState.ts

@@ -0,0 +1,83 @@
+/**
+ * infinity-harness — daemon/supervisorState.ts
+ *
+ * Daemon-owned files: harness/supervisor.json (live worker) and harness/activity.json
+ * (last ~400 lines). Only the Daemon writes them; Interfaces only read.
+ *
+ * SupervisorView captures askedModel vs servedModel per worker — the proof of
+ * routing that v2.7 lacked.
+ */
+
+import { supervisorPath, activityPath } from "../core/paths.ts";
+import { readJsonSafe, writeJsonAtomic, ensureDir } from "../core/fsx.ts";
+import { existsSync, unlinkSync } from "node:fs";
+import { dirname } from "node:path";
+
+export const ACTIVITY_LIMIT = 400;
+
+export type ActivityLevel = "info" | "work" | "warn" | "error" | "good";
+
+export type ActivityLine = {
+  at: string;
+  level: ActivityLevel;
+  worker: string | null;
+  text: string;
+};
+
+export type SupervisorWorker = {
+  name: string;
+  unitKey: string;
+  unitLabel: string;
+  level: string;
+  difficulty: string | null;
+  model: string;
+  askedModel: string;
+  servedModel: string | null;
+  thinking: string;
+  state: "starting" | "working" | "idle" | "closed" | "failed";
+  doing: string | null;
+  startedAt: string;
+  turns: number;
+  recycles: number;
+  tokens: { input: number; output: number; cacheRead?: number; cacheWrite?: number; cost?: number; calls?: number };
+  contextRatio: number | null;
+  sessionId: string | null;
+  unit?: string;
+};
+
+export type SupervisorState = {
+  runId: string;
+  updatedAt: string;
+  worker: SupervisorWorker | null;
+  workers?: SupervisorWorker[];
+};
+
+export function loadSupervisor(targetDir: string): SupervisorState | null {
+  return readJsonSafe<SupervisorState | null>(supervisorPath(targetDir), null);
+}
+
+export function saveSupervisor(targetDir: string, state: SupervisorState): void {
+  ensureDir(dirname(supervisorPath(targetDir)));
+  writeJsonAtomic(supervisorPath(targetDir), { ...state, updatedAt: new Date().toISOString() });
+}
+
+export function loadActivity(targetDir: string): ActivityLine[] {
+  const raw = readJsonSafe<ActivityLine[] | null>(activityPath(targetDir), null);
+  return Array.isArray(raw) ? raw : [];
+}
+
+export function appendActivity(targetDir: string, line: Omit<ActivityLine, "at"> & { at?: string }): ActivityLine {
+  const entry: ActivityLine = { at: line.at ?? new Date().toISOString(), level: line.level, worker: line.worker ?? null, text: line.text };
+  const cur = loadActivity(targetDir);
+  const next = [...cur, entry].slice(-ACTIVITY_LIMIT);
+  ensureDir(dirname(activityPath(targetDir)));
+  writeJsonAtomic(activityPath(targetDir), next);
+  return entry;
+}
+
+export function clearSupervisor(targetDir: string): void {
+  try {
+    const p = supervisorPath(targetDir);
+    if (existsSync(p)) unlinkSync(p);
+  } catch {}
+}