infinity-harness 2.7.0 → 2.8.0

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 {}
+}

package/src/daemon/worker.ts

@@ -0,0 +1,239 @@
+/**
+ * infinity-harness — daemon/worker.ts
+ *
+ * One AgentSession: create → prompt → settle → dispose, plus the
+ * events->TurnResult adapter. prompt() returns void in the SDK, so every
+ * turn field (servedModel, usage, tools, summary, contextRatio, compacted)
+ * comes via subscribe().
+ *
+ * v2.7's WorkerSession.prompt returned TurnResult; the SDK's prompt returns void.
+ * This file rebuilds the same shape by accumulating events.
+ */
+
+// Usage type is from pi session — use a loose shape to avoid hard dep on pi-ai path
+type Usage = { input?: number; output?: number; inputTokens?: number; outputTokens?: number; cacheRead?: number; cacheWrite?: number; cost?: number };
+
+export type TurnResult = {
+  summary: string;
+  tools: Array<{ name: string; ok: boolean }>;
+  usage: { input: number; output: number; cacheRead?: number; cacheWrite?: number; cost?: number };
+  contextRatio: number | null;
+  servedModel: string | null;
+  askedModel: string;
+  compacted: boolean;
+  aborted: boolean;
+  error: string | null;
+  modelFallbackMessage?: string | null;
+};
+
+export type WorkerEvents = {
+  onMessageStart?: (ev: unknown) => void;
+  onMessageUpdate?: (ev: unknown) => void;
+  onMessageEnd?: (ev: unknown) => void;
+  onToolStart?: (ev: unknown) => void;
+  onToolEnd?: (ev: unknown) => void;
+  onCompactionStart?: (ev: unknown) => void;
+};
+
+export type CreateWorkerOpts = {
+  cwd: string;
+  agentDir?: string;
+  modelSpec: { provider: string; id: string; thinkingLevel?: string };
+  askedModel: string;
+  sessionManagerDir?: string;
+  customTools?: unknown[];
+  thinkingLevel?: string;
+  resourceLoader?: unknown;
+  runId?: string;
+  unitKey?: string;
+  isolationBypassForTest?: boolean;
+};
+
+export type PromptOpts = {
+  text: string;
+  timeoutMs?: number;
+};
+
+/**
+ * Create one SDK AgentSession with harness-free loader + customTools.
+ * Returns session + unsubscribe + dispose handles.
+ */
+export async function createWorker(opts: CreateWorkerOpts): Promise<{
+  session: unknown;
+  unsubscribe: () => void;
+  dispose: () => void;
+  modelFallbackMessage?: string | null;
+  events: { servedModel: string | null; usage: Usage | null; tools: TurnResult["tools"]; summary: string; compacted: boolean };
+}> {
+  const mod = await import("@earendil-works/pi-coding-agent");
+  const { createAgentSession, ModelRuntime, SessionManager, DefaultResourceLoader, SettingsManager } = mod as unknown as {
+    createAgentSession: (opts: unknown) => Promise<{ session: unknown; modelFallbackMessage?: string | null; extensionsResult?: unknown }>;
+    ModelRuntime: { create: () => Promise<{ getModel: (p: string, id: string) => unknown; hasConfiguredAuth: (p: string) => boolean; checkAuth: (p: string) => Promise<unknown> }> };
+    SessionManager: { create: (cwd: string, dir?: string) => unknown; inMemory: (cwd: string) => unknown };
+    DefaultResourceLoader: new (opts: unknown) => { reload: () => Promise<void> };
+    SettingsManager: { create: (cwd: string, agentDir?: string) => unknown };
+  };
+
+  const runtime = await ModelRuntime.create();
+  const model = runtime.getModel(opts.modelSpec.provider, opts.modelSpec.id);
+  if (!model) throw new Error(`unknown model ${opts.modelSpec.provider}/${opts.modelSpec.id}`);
+
+  let loader: unknown = opts.resourceLoader;
+  if (!loader && !opts.isolationBypassForTest) {
+    const sm = SettingsManager.create(opts.cwd, opts.agentDir);
+    const l = new DefaultResourceLoader({
+      cwd: opts.cwd,
+      agentDir: opts.agentDir ?? "",
+      settingsManager: sm,
+      noExtensions: true,
+      noSkills: true,
+      noPromptTemplates: true,
+      noThemes: true,
+      noContextFiles: true,
+    } as unknown as ConstructorParameters<typeof DefaultResourceLoader>[0]);
+    await l.reload();
+    loader = l;
+  }
+
+  // Verify isolation: if loader discovery includes harness, fail fast (unless bypassed for test).
+  if (!opts.isolationBypassForTest && loader && typeof (loader as { getExtensions?: () => unknown }).getExtensions === "function") {
+    try {
+      const ext = (loader as { getExtensions: () => { extensions?: Array<{ id?: string }> } }).getExtensions();
+      const found = (ext?.extensions ?? []).filter(e => String(e?.id ?? "").includes("infinity-harness"));
+      if (found.length) throw new Error(`isolation violated: loader has ${found.length} harness extension(s)`);
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("isolation violated")) throw e;
+    }
+  }
+
+  const sessionManager = opts.sessionManagerDir
+    ? SessionManager.create(opts.cwd, opts.sessionManagerDir)
+    : SessionManager.inMemory(opts.cwd);
+
+  const thinkingLevel = (opts.thinkingLevel ?? opts.modelSpec.thinkingLevel ?? "medium") as unknown as string;
+
+  const agentTools = opts.customTools as unknown as import("@earendil-works/pi-coding-agent").ToolDefinition[] | undefined;
+
+  const created = await createAgentSession({
+    model: model as never,
+    modelRuntime: runtime as never,
+    cwd: opts.cwd,
+    thinkingLevel: thinkingLevel as never,
+    resourceLoader: loader as never,
+    customTools: agentTools as never,
+    sessionManager: sessionManager as never,
+  } as never);
+
+  const session = created.session as {
+    subscribe: (fn: (ev: { type: string; [k: string]: unknown }) => void) => () => void;
+    prompt: (text: string, opts?: unknown) => Promise<void>;
+    steer: (text: string) => Promise<void>;
+    dispose: () => void;
+    abort?: () => void;
+    model?: { provider?: string; id?: string };
+  };
+
+  if (created.modelFallbackMessage) throw new Error(`modelFallbackMessage: ${created.modelFallbackMessage}`);
+
+  const state = { servedModel: null as string | null, usage: null as Usage | null, tools: [] as TurnResult["tools"], summary: "", compacted: false };
+
+  const unsubscribe = session.subscribe((ev: { type: string; [k: string]: unknown }) => {
+    if (ev.type === "message_start") {
+      // message_start carries provider/model in some SDK versions
+      const prov = (ev as { provider?: string }).provider ?? (ev as { model?: { provider?: string } }).model?.provider;
+      const mid = (ev as { modelId?: string }).modelId ?? (ev as { model?: { id?: string } }).model?.id;
+      if (prov || mid) state.servedModel = `${prov ?? "?"}:${mid ?? "?"}`;
+    } else if (ev.type === "message_end") {
+      // usage is cumulative per session
+      const usage = (ev as { usage?: Usage }).usage;
+      if (usage) state.usage = usage as Usage;
+      const text = (ev as { content?: unknown }).content ?? (ev as { text?: string }).text;
+      if (typeof text === "string" && text) state.summary = text;
+      else if (Array.isArray((ev as { content?: unknown }).content)) {
+        const c = (ev as { content?: unknown }).content as Array<{ type?: string; text?: string }>;
+        const t = c.filter(x => x?.type === "text").map(x => x.text ?? "").join("\n");
+        if (t) state.summary = t;
+      }
+    } else if (ev.type === "tool_execution_start" || ev.type === "tool_execution_end") {
+      const name = String((ev as { toolName?: string }).toolName ?? (ev as { name?: string }).name ?? "tool");
+      const ok = ev.type === "tool_execution_end" ? ((ev as { ok?: boolean }).ok ?? true) : true;
+      // dedupe: keep last ok per name per end event
+      if (ev.type === "tool_execution_end") state.tools.push({ name, ok: Boolean(ok) });
+      else if (ev.type === "tool_execution_start") state.tools.push({ name, ok: true });
+    } else if (ev.type === "compaction_start") {
+      state.compacted = true;
+    } else if (ev.type === "entry_appended") {
+      // session entries include model_change and compaction; capture compaction usage
+      const entry = (ev as { entry?: { type?: string; usage?: Usage } }).entry;
+      if (entry?.type === "compaction" && entry.usage) state.compacted = true;
+    }
+  });
+
+  return {
+    session,
+    unsubscribe,
+    dispose: () => { try { unsubscribe(); } catch {} try { session.dispose(); } catch {} },
+    modelFallbackMessage: created.modelFallbackMessage ?? null,
+    events: state,
+  };
+}
+
+export async function promptWorker(
+  worker: { session: { prompt: (t: string, o?: unknown) => Promise<void> }; events: { servedModel: string | null; usage: Usage | null; tools: TurnResult["tools"]; summary: string; compacted: boolean } },
+  opts: PromptOpts,
+): Promise<TurnResult> {
+  // We need the askedModel — fall back to events.servedModel if not known.
+  const askedModel = "asked";
+  const startedUsage = worker.events.usage;
+  try {
+    const timeoutMs = opts.timeoutMs ?? 30 * 60 * 1000;
+    let settled = false;
+    const timer = timeoutMs > 0 ? setTimeout(() => { if (!settled) try { (worker.session as { abort?: () => void }).abort?.(); } catch {} }, timeoutMs) : null;
+    try {
+      await worker.session.prompt(opts.text);
+      settled = true;
+    } finally {
+      if (timer) clearTimeout(timer);
+      settled = true;
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    // CredentialSynchronizationError is handled by caller; bubble it.
+    if (msg.includes("CredentialSynchronizationError") || (e as { name?: string })?.name === "CredentialSynchronizationError") throw e;
+    return {
+      summary: worker.events.summary,
+      tools: worker.events.tools,
+      usage: toUsageTotals(worker.events.usage, startedUsage),
+      contextRatio: null,
+      servedModel: worker.events.servedModel,
+      askedModel,
+      compacted: worker.events.compacted,
+      aborted: msg.toLowerCase().includes("abort"),
+      error: msg,
+    };
+  }
+  return {
+    summary: worker.events.summary,
+    tools: worker.events.tools,
+    usage: toUsageTotals(worker.events.usage, startedUsage),
+    contextRatio: null,
+    servedModel: worker.events.servedModel,
+    askedModel,
+    compacted: worker.events.compacted,
+    aborted: false,
+    error: null,
+  };
+}
+
+function toUsageTotals(cur: Usage | null, _prev: Usage | null): { input: number; output: number; cacheRead?: number; cacheWrite?: number; cost?: number } {
+  if (!cur) return { input: 0, output: 0 };
+  // pi usage is cumulative per session; the last reading IS the total.
+  const input = typeof (cur as { input?: number }).input === "number" ? (cur as { input: number }).input
+    : typeof (cur as { inputTokens?: number }).inputTokens === "number" ? (cur as unknown as { inputTokens: number }).inputTokens : 0;
+  const output = typeof (cur as { output?: number }).output === "number" ? (cur as { output: number }).output
+    : typeof (cur as { outputTokens?: number }).outputTokens === "number" ? (cur as unknown as { outputTokens: number }).outputTokens : 0;
+  const cacheRead = (cur as { cacheRead?: number }).cacheRead ?? 0;
+  const cacheWrite = (cur as { cacheWrite?: number }).cacheWrite ?? 0;
+  const cost = (cur as { cost?: number }).cost ?? 0;
+  return { input, output, cacheRead, cacheWrite, cost };
+}

package/src/daemon/worktree.ts

@@ -0,0 +1,95 @@
+/**
+ * infinity-harness — daemon/worktree.ts
+ *
+ * Git worktree per concurrent worker. Gate in worktree, merge lock, unlock.
+ *
+ * v3.0 is sequential (maxWorkers:1) — this file is the isolation that will be
+ * used when we lift that. Kept isolated in its own module so it cannot leak
+ * into the single-owner path prematurely.
+ */
+
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { worktreePath, worktreesDir } from "../core/paths.ts";
+import { run } from "../core/exec.ts";
+import { ensureDir } from "../core/fsx.ts";
+
+export async function isWorktreeSupported(targetDir: string): Promise<boolean> {
+  const r = await run("git rev-parse --is-inside-work-tree", { cwd: targetDir, timeoutMs: 10_000 });
+  return r.ok && r.stdout.trim() === "true";
+}
+
+export async function createWorktree(targetDir: string, branch: string): Promise<{ path: string; error: string | null }> {
+  if (!await isWorktreeSupported(targetDir)) return { path: "", error: "not a git repo — cannot create worktree" };
+  const worktree = worktreePath(targetDir, branch);
+  if (existsSync(worktree)) return { path: worktree, error: null };
+  try { ensureDir(worktreesDir(targetDir)); } catch {}
+  // Safe to create on current HEAD: `git worktree add <path>` with no branch creates detached worktree
+  const r = await run(`git worktree add --detach "${worktree.replace(/"/g, '\\"')}"`, { cwd: targetDir, timeoutMs: 30_000 });
+  if (!r.ok) return { path: "", error: (r.stderr || r.stdout || r.spawnError || `git worktree add exited ${r.code}`).slice(0, 400) };
+  return { path: worktree, error: null };
+}
+
+export async function removeWorktree(targetDir: string, branch: string): Promise<{ ok: boolean; error: string | null }> {
+  const worktree = worktreePath(targetDir, branch);
+  if (!existsSync(worktree)) return { ok: true, error: null };
+  const r = await run(`git worktree remove --force "${worktree.replace(/"/g, '\\"')}"`, { cwd: targetDir, timeoutMs: 30_000 });
+  if (!r.ok && !r.stderr?.includes("not a valid path")) return { ok: false, error: (r.stderr || r.stdout || r.spawnError || `exit ${r.code}`).slice(0,400) };
+  // Also prune any stale branch/worktree registration
+  await run("git worktree prune", { cwd: targetDir, timeoutMs: 15_000 });
+  return { ok: true, error: null };
+}
+
+export async function removeAllWorktrees(targetDir: string): Promise<void> {
+  await run("git worktree prune", { cwd: targetDir, timeoutMs: 15_000 });
+  // Best-effort remove each directory under harness/worktrees
+  const root = worktreesDir(targetDir);
+  if (!existsSync(root)) return;
+  let entries: string[] = [];
+  try { const { readdirSync } = await import("node:fs"); entries = readdirSync(root); } catch {}
+  for (const e of entries) {
+    await removeWorktree(targetDir, e);
+  }
+}
+
+export async function gateInWorktree(targetDir: string, worktree: string, phase: string): Promise<{ pass: boolean; reason?: string }> {
+  const { runChecks } = await import("../core/gates.ts");
+  const g = await runChecks(worktree, phase as never, { record: false });
+  if (g.overall) return { pass: true };
+  return { pass: false, reason: g.failures.join(", ") };
+}
+
+export async function mergeWorktreeBranch(targetDir: string, branch: string, worktree: string, gatePhase?: string): Promise<{ ok: boolean; conflict?: boolean; reason?: string }> {
+  // We use a harness/<unit> branch name when creating the worktree. Merge with `git merge`.
+  const branchName = `harness/${branch}`;
+  // Ensure branch exists (worktree add --detach doesn't create one). Create branch from worktree HEAD.
+  const currentHead = (await run(`git -C "${worktree.replace(/"/g,'\\"')}" rev-parse HEAD`, { cwd: targetDir, timeoutMs: 10_000 })).stdout?.trim() ?? null;
+  if (currentHead) {
+    const create = await run(`git branch "${branchName}" "${currentHead}"`, { cwd: targetDir, timeoutMs: 15_000 });
+    // exists is ok — we will merge the branch if already there.
+    if (!create.ok && !(create.stderr||"").includes("already exists")) {
+      // best-effort: continue to merge attempt
+    }
+  }
+  const merge = await run(`git merge --no-ff --no-edit "${branchName}"`, { cwd: targetDir, timeoutMs: 30_000 });
+  if (merge.ok) {
+    await run(`git branch -D "${branchName}"`, { cwd: targetDir, timeoutMs: 10_000 });
+    const { runChecks: _runChecks } = await import("../core/gates.ts");
+    const { loadConfig } = await import("../core/config.ts");
+    const phase = gatePhase ?? ((loadConfig(targetDir).config?.currentPhase as unknown as string) ?? "build");
+    const post = await _runChecks(targetDir, phase as never, { record: false });
+    if (!post.overall) {
+      await run("git reset --hard HEAD~1", { cwd: targetDir, timeoutMs: 15_000 }).catch(()=>null as never);
+      return { ok: false, conflict: false, reason: `post-merge gate FAIL: ${post.failures.join(", ")}` };
+    }
+    return { ok: true };
+  }
+  const out = (merge.stdout ?? "") + "\n" + (merge.stderr ?? "");
+  const conflict = /conflict/i.test(out);
+  if (conflict) {
+    await run("git merge --abort", { cwd: targetDir, timeoutMs: 10_000 }).catch(()=>null as never);
+    return { ok: false, conflict: true, reason: out.slice(0,500) };
+  }
+  await run("git merge --abort", { cwd: targetDir, timeoutMs: 10_000 }).catch(()=>null as never);
+  return { ok: false, conflict: false, reason: out.slice(0,500) };
+}

package/src/exec/piWorker.ts

@@ -26,7 +26,7 @@
  * pi and a stream of events. It has no idea what a phase is.
  */
 
-import { spawn, type ChildProcess } from "node:child_process";
+import { spawn, execFileSync, type ChildProcess } from "node:child_process";
 import { createRequire } from "node:module";
 import { existsSync, mkdirSync, writeFileSync, appendFileSync } from "node:fs";
 import { join, resolve, dirname } from "node:path";
@@ -137,7 +137,6 @@ export function resolvePiCli(env: NodeJS.ProcessEnv = process.env, argv: string[
 /** Where a command lives, or null. Sync on purpose: it runs once per worker. */
 function whichSync(name: string): string | null {
   try {
-    const { execFileSync } = require("node:child_process") as typeof import("node:child_process");
     const cmd = process.platform === "win32" ? "where" : "which";
     const out = String(execFileSync(cmd, [name], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }));
     const first = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean)[0];

package/src/goalState.ts

@@ -9,9 +9,8 @@ import {
   validateGoalLoopState,
 } from "./goalLoop.ts";
 import { type GoalSpecification, validateGoalSpecification } from "./goalSpec.ts";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-declare const require: any;
 
 export const GOAL_STATE_FILE = "GOAL_STATE.json";
 export const GOAL_TRACE_FILE = "GOAL_TRACE.jsonl";
@@ -25,26 +24,7 @@ export function canonicalGoalSpecPath(projectDir = process.cwd()): string {
   return resolve(projectDir, CANONICAL_GOAL_SPEC_DIR, CANONICAL_GOAL_SPEC_FILE);
 }
 
-function writeCanonicalWithLockSync(projectDir: string, content: string): void {
-  const target = canonicalGoalSpecPath(projectDir);
-  // try proper-lockfile sync-ish via dynamic import fallback to plain write
-  try {
-    mkdirSync(dirname(target), { recursive: true });
-    // use proper-lockfile if available (async variant would need async; use sync file write with lock attempt)
-    // For sync canonical we rely on atomic tmp+rename and ignore lock if unavailable — async wrapper below handles lock
-    const tmp = `${target}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    writeFileSync(tmp, content, "utf8");
-    // rename via node:fs renameSync equivalent (import already has rename async, but we use writeFileSync+rename via fs)
-    const { renameSync } = require("node:fs");
-    renameSync(tmp, target);
-  } catch {
-    // fallback simple write
-    try {
-      mkdirSync(dirname(target), { recursive: true });
-      writeFileSync(target, content, "utf8");
-    } catch {}
-  }
-}
+
 
 
 export interface GoalStateStoreOptions {

package/src/intake.ts

@@ -177,7 +177,7 @@ export function planIntake(answers: IntakeAnswers): IntakePlan {
       plan: phaseModes.plan === "copilot",
     },
     session,
-    execution: { engine, parallelAt, maxWorkers },
+    execution: { engine, parallelAt, maxWorkers, isolation: "worktree" as const },
     display,
     router: answers.router,
     summary: summarize(workflow, phases, phaseModes, session, display, brief, _researchDepth),

package/src/remote.ts

@@ -27,6 +27,7 @@ import { loadRunState } from "./runState.ts";
 import { normalizeDisplay } from "./ui/display.ts";
 import { supervisorStatePath, activityPath } from "./supervisor.ts";
 import { renderDashboard, escapeHtml, type DashboardState } from "./ui/dashboard.ts";
+import { executionPolicyOf } from "./scheduler.ts";
 
 export { escapeHtml };
 
@@ -125,8 +126,8 @@ export function buildRemoteState(projectDir?: string): RemoteState {
     rework: readJsonSafe<unknown>(reworkPath(dir), null),
     awaitingApproval: config.awaitingApproval ?? null,
     sessions: loadRunState(dir)?.sessions ?? null,
-    execution: (() => { try { const { executionPolicyOf } = require("./scheduler.ts"); return executionPolicyOf(config); } catch { return null; } })(),
-    engine: (() => { try { const { executionPolicyOf } = require("./scheduler.ts"); return executionPolicyOf(config).engine as "background" | "main-session"; } catch { return null; } })(),
+    execution: (() => { try { return executionPolicyOf(config); } catch { return null; } })(),
+    engine: (() => { try { return executionPolicyOf(config).engine as "background" | "main-session"; } catch { return null; } })(),
     // The supervisor's own state is the truth about what is running. This used
     // to scan the attempt-directory tree, which reported every attempt ever
     // made as a live worker.