@a-t-h-i/bot-lobby 0.6.55 → 0.6.57

package/src/harness/process.ts

@@ -0,0 +1,175 @@
+/**
+ * Runs one third-party harness process: spawns it in its own process group,
+ * feeds its stdout to the protocol driver line by line, and watches it the
+ * way `spawnPiProcess` watches pi (a stall kills it, a cancel aborts it, and
+ * the run ends when the process exits). There is no time limit.
+ */
+import { spawn } from "node:child_process";
+import { POSIX, signalGroup, terminate, watchInterval, type PiStreamEvent, type RunHandle } from "../execution/pi-runner.ts";
+
+/** What a driver can do with its process. */
+export interface HarnessIO {
+  /** Write one line to the process's stdin. */
+  write(line: string): void;
+  closeInput(): void;
+  /** Forward an agent event to the caller (and to the stall watchdog). */
+  emit(event: PiStreamEvent): void;
+  /** The turn is over: close stdin and let the process go (killing it after a short grace). */
+  done(): void;
+}
+
+/** One protocol: what it sends first, how it reads each stdout line, and how it is cancelled or steered. */
+export interface HarnessDriver {
+  start(): void;
+  line(text: string): void;
+  /** Called on cancel before the process is killed (ACP's `session/cancel`). */
+  abort?(): void;
+  /** A steering message for the running agent; absent when the protocol cannot take one mid-run. */
+  steer?(text: string): void;
+}
+
+export interface HarnessSpawn {
+  command: string;
+  args: string[];
+  cwd: string;
+  env: Record<string, string | undefined>;
+}
+
+export interface HarnessProcessOptions {
+  signal?: AbortSignal;
+  stallTimeoutMs?: number;
+  toolStallTimeoutMs?: number;
+  onEvent?: (event: PiStreamEvent) => void;
+  onStart?: (handle: RunHandle) => void;
+}
+
+export interface HarnessOutcome {
+  exitCode: number;
+  stderr: string;
+  killed: boolean;
+  stalled: boolean;
+  /** The command could not be started at all (not installed, not executable). */
+  spawnError?: string;
+}
+
+const MAX_STDERR = 64_000;
+const EXIT_DRAIN_MS = 1500;
+const DONE_GRACE_MS = 2000;
+
+export function runHarnessProcess(spec: HarnessSpawn, options: HarnessProcessOptions, makeDriver: (io: HarnessIO) => HarnessDriver): Promise<HarnessOutcome> {
+  return new Promise((resolve) => {
+    const proc = spawn(spec.command, spec.args, {
+      cwd: spec.cwd,
+      env: spec.env as NodeJS.ProcessEnv,
+      shell: false,
+      detached: POSIX,
+      windowsHide: true,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    let stdinOpen = true;
+    let stderr = "";
+    let partial = "";
+    let lastOutput = Date.now();
+    let toolsInFlight = 0;
+    let killed = false;
+    let stalled = false;
+    let finished = false;
+    let exitCode: number | undefined;
+    let spawnError: string | undefined;
+    let doneTimer: ReturnType<typeof setTimeout> | undefined;
+    proc.stdin?.on("error", () => {
+      stdinOpen = false;
+    });
+
+    const io: HarnessIO = {
+      write(line) {
+        if (!stdinOpen || !proc.stdin?.writable) return;
+        try {
+          proc.stdin.write(`${line}\n`);
+        } catch {
+          stdinOpen = false;
+        }
+      },
+      closeInput() {
+        if (!stdinOpen) return;
+        stdinOpen = false;
+        try {
+          proc.stdin?.end();
+        } catch {
+          // Already closed.
+        }
+      },
+      emit(event) {
+        if (event.type === "tool_execution_start") toolsInFlight += 1;
+        if (event.type === "tool_execution_end") toolsInFlight = Math.max(0, toolsInFlight - 1);
+        options.onEvent?.(event);
+      },
+      done() {
+        io.closeInput();
+        // An ACP agent is a server and stays up after its turn: give it a moment, then end it.
+        doneTimer ??= setTimeout(() => terminate(proc, 2000), DONE_GRACE_MS);
+        doneTimer.unref();
+      },
+    };
+    const driver = makeDriver(io);
+
+    const finish = (code: number) => {
+      if (finished) return;
+      finished = true;
+      clearInterval(watch);
+      clearTimeout(doneTimer);
+      options.signal?.removeEventListener("abort", onAbort);
+      if (partial) {
+        const rest = partial;
+        partial = "";
+        driver.line(rest);
+      }
+      io.closeInput();
+      if (POSIX) signalGroup(proc, "SIGTERM");
+      resolve({ exitCode: code, stderr, killed, stalled, ...(spawnError ? { spawnError } : {}) });
+    };
+    const onAbort = () => {
+      killed = true;
+      driver.abort?.();
+      io.closeInput();
+      terminate(proc, 3000);
+    };
+    const watch = setInterval(() => {
+      if (killed || finished) return;
+      const limit = toolsInFlight > 0 ? options.toolStallTimeoutMs : options.stallTimeoutMs;
+      if (limit && limit > 0 && Date.now() - lastOutput >= limit) {
+        killed = true;
+        stalled = true;
+        io.closeInput();
+        terminate(proc, 3000);
+      }
+    }, watchInterval(options.stallTimeoutMs, options.toolStallTimeoutMs));
+    watch.unref();
+
+    proc.stdout?.setEncoding("utf8");
+    proc.stderr?.setEncoding("utf8");
+    proc.stdout?.on("data", (chunk: string) => {
+      lastOutput = Date.now();
+      const lines = (partial + chunk).split("\n");
+      partial = lines.pop() ?? "";
+      for (const line of lines) if (line.trim()) driver.line(line);
+    });
+    proc.stderr?.on("data", (chunk: string) => {
+      lastOutput = Date.now();
+      if (stderr.length < MAX_STDERR) stderr += chunk;
+    });
+    proc.on("exit", (code, signal) => {
+      exitCode = code ?? (signal ? 1 : 0);
+      setTimeout(() => finish(exitCode ?? 0), EXIT_DRAIN_MS);
+    });
+    proc.on("close", (code) => finish(exitCode ?? code ?? 0));
+    proc.on("error", (error: NodeJS.ErrnoException) => {
+      spawnError = error.code === "ENOENT" ? `${spec.command} was not found; install it or set its path in Settings > Harnesses` : error.message;
+      finish(1);
+    });
+    driver.start();
+    options.onStart?.({ steer: (text) => driver.steer?.(text) });
+    if (options.signal?.aborted) onAbort();
+    else options.signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}

package/src/harness/runner.ts

@@ -0,0 +1,188 @@
+/**
+ * Runs one subagent step on a third-party harness instead of pi. The caller
+ * sees the same `PiRunResult` and stream events either way, so the workflow,
+ * the lobby feed and the edit log do not care which harness did the work.
+ */
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { activityWord } from "../pi/activity.ts";
+import { roleSpec } from "../roles/registry.ts";
+import type { HarnessRun } from "../schemas/harness.ts";
+import { shortDuration } from "../text.ts";
+import type { PiRunOptions, PiRunResult } from "../execution/pi-runner.ts";
+import { acpDriver } from "./acp.ts";
+import { HARNESSES, harnessCommand, harnessEffort, harnessModelId } from "./catalog.ts";
+import { claudeArgs, claudeDriver } from "./claude.ts";
+import { codexArgs, codexDriver } from "./codex.ts";
+import { acpPromptWithInstructions, harnessInstructions } from "./instructions.ts";
+import { runHarnessProcess, type HarnessDriver, type HarnessIO, type HarnessOutcome, type HarnessProcessOptions, type HarnessSpawn } from "./process.ts";
+import { loadClaudeSdk, runClaudeSdk } from "./claude-sdk.ts";
+
+/** What one run is allowed to do, from its role's pi tool allowlist (absent: everything). */
+export interface HarnessAccess {
+  writes: boolean;
+  shell: boolean;
+  web: boolean;
+  tools?: readonly string[];
+}
+
+export function accessOf(tools: readonly string[] | undefined): HarnessAccess {
+  if (!tools) return { writes: true, shell: true, web: true };
+  return {
+    writes: tools.includes("edit") || tools.includes("write"),
+    shell: tools.includes("bash"),
+    web: tools.some((tool) => tool === "web_search" || tool === "fetch_content" || tool === "web_fetch"),
+    tools,
+  };
+}
+
+/** One run's harness, model, effort and instructions, resolved from the settings. */
+export interface HarnessPlan {
+  harness: HarnessRun;
+  /** The id the harness is given; empty leaves its default. */
+  model: string;
+  /** The harness's own effort value, when it takes one on the command line. */
+  effort?: string;
+  /** The agent's effort level in pi's names (ACP agents match it against their options). */
+  level: string;
+  instructions: string;
+  autoCompact?: boolean;
+}
+
+/** What the stream told us, filled in by the driver. */
+export interface HarnessCollector {
+  text: string;
+  usage: { input: number; output: number; cost: number; turns: number };
+  model?: string;
+  session?: string;
+  error?: string;
+  warning?: string;
+  stopReason?: string;
+  addUsage(input: number, output: number, cost: number, model?: string): void;
+}
+
+function collector(): HarnessCollector {
+  const out: HarnessCollector = {
+    text: "",
+    usage: { input: 0, output: 0, cost: 0, turns: 0 },
+    addUsage(input, output, cost, model) {
+      out.usage.input += input;
+      out.usage.output += output;
+      out.usage.cost += cost;
+      out.usage.turns += 1;
+      if (model) out.model = model;
+    },
+  };
+  return out;
+}
+
+export function planHarnessRun(options: Pick<PiRunOptions, "systemPrompt" | "thinking" | "autoCompact" | "agent"> & { harness: HarnessRun }): HarnessPlan {
+  const { harness } = options;
+  const level = options.thinking ?? "medium";
+  const effort = harnessEffort(harness.id, harness.settings, harness.model, level);
+  const model = harnessModelId(harness.id, harness.settings, harness.model, level);
+  const contract = options.agent ? roleSpec(options.agent.role).contract : undefined;
+  return {
+    harness,
+    model,
+    ...(effort && HARNESSES[harness.id].effort === "flag" ? { effort } : {}),
+    level,
+    instructions: harnessInstructions({ harness, ...(options.systemPrompt ? { systemPrompt: options.systemPrompt } : {}), ...(contract ? { contract } : {}), ...(effort ? { effort } : {}) }),
+    ...(options.autoCompact === false ? { autoCompact: false } : {}),
+  };
+}
+
+/** Starts one run and resolves when it ends: a harness process, or Claude Code through the Agent SDK. */
+export type HarnessStart = (collected: HarnessCollector, options: HarnessProcessOptions) => Promise<HarnessOutcome>;
+
+/** How one run starts; Claude Code goes through the Agent SDK when it is installed, else its CLI. */
+export function harnessLaunch(plan: HarnessPlan, options: Pick<PiRunOptions, "cwd" | "env"> & { prompt: string; access: HarnessAccess }, promptFile: () => string): HarnessStart {
+  const launched = processLaunch(plan, options, promptFile);
+  const fromProcess: HarnessStart = (collected, watch) => runHarnessProcess(launched.spawn, watch, (io) => launched.driver(io, collected));
+  if (HARNESSES[plan.harness.id].protocol !== "claude-stream") return fromProcess;
+  return async (collected, watch) => {
+    const query = await loadClaudeSdk();
+    if (!query) return fromProcess(collected, watch);
+    return runClaudeSdk(query, plan, options.access, { cwd: options.cwd, env: launched.spawn.env, launchArgs: launched.launchArgs, prompt: options.prompt }, collected, watch);
+  };
+}
+
+/** The process to start and the driver that speaks to it. */
+function processLaunch(plan: HarnessPlan, options: Pick<PiRunOptions, "cwd" | "env"> & { prompt: string; access: HarnessAccess }, promptFile: () => string): { spawn: HarnessSpawn; launchArgs: string[]; driver: (io: HarnessIO, collected: HarnessCollector) => HarnessDriver } {
+  const { id, settings } = plan.harness;
+  const info = HARNESSES[id];
+  const { command, args: launchArgs } = harnessCommand(id, settings);
+  if (!command) throw new Error(`${info.label} has no command yet: set it in Settings > Harnesses`);
+  const { access } = options;
+  const env: Record<string, string | undefined> = { ...process.env, ...options.env };
+  if (info.homeEnv && settings.homePath) env[info.homeEnv] = settings.homePath;
+  if (id === "antigravity" && settings.harnessPath) env.ANTIGRAVITY_HARNESS_PATH = settings.harnessPath;
+  const task = options.prompt;
+  if (info.protocol === "codex-exec") {
+    const built = codexArgs(plan, access, launchArgs);
+    const prompt = built.promptPrefix ? acpPromptWithInstructions(task, built.promptPrefix) : task;
+    return { spawn: { command, args: built.args, cwd: options.cwd, env }, launchArgs, driver: (io, collected) => codexDriver(io, plan, prompt, collected) };
+  }
+  if (info.protocol === "claude-stream") {
+    const built = claudeArgs(plan, access, launchArgs, plan.instructions ? promptFile() : undefined);
+    return { spawn: { command, args: built.args, cwd: options.cwd, env: { ...env, ...built.env } }, launchArgs, driver: (io, collected) => claudeDriver(io, task, collected) };
+  }
+  const prompt = acpPromptWithInstructions(task, plan.instructions);
+  return { spawn: { command, args: launchArgs, cwd: options.cwd, env }, launchArgs, driver: (io, collected) => acpDriver(io, plan, prompt, collected, access, options.cwd) };
+}
+
+function toResult(collected: HarnessCollector, outcome: HarnessOutcome, aborted: boolean, options: PiRunOptions, label: string): PiRunResult {
+  const base = { output: collected.text, usage: collected.usage, ...(collected.model ? { model: collected.model } : {}) };
+  if (outcome.stalled) return { ...base, status: "timeout", stalled: true, error: `stalled: no output for ${shortDuration(options.stallTimeoutMs ?? 0)}` };
+  if (outcome.killed || aborted || collected.stopReason === "aborted") return { ...base, status: "cancelled", error: "agent was cancelled" };
+  if (outcome.spawnError) return { ...base, status: "failed", error: `${label}: ${outcome.spawnError}` };
+  if (collected.error) return { ...base, status: "failed", error: `${label}: ${collected.error}` };
+  if (outcome.exitCode !== 0 && !collected.text.trim()) {
+    const detail = collected.warning ?? lastLines(outcome.stderr);
+    return { ...base, status: "failed", error: `${label}: ${detail || `exited with code ${outcome.exitCode}`}` };
+  }
+  if (!collected.text.trim()) return { ...base, status: "failed", error: `${label}: the agent produced no usable output${collected.warning ? ` (${collected.warning})` : ""}` };
+  return { ...base, status: "success" };
+}
+
+function lastLines(text: string): string {
+  return text.trim().split("\n").slice(-3).join(" ").slice(0, 400);
+}
+
+/** Run one subagent step on its harness and normalise the outcome like a pi run. */
+export async function runHarnessAgent(options: PiRunOptions & { harness: HarnessRun }): Promise<PiRunResult> {
+  const empty = { status: "cancelled" as const, output: "", usage: { input: 0, output: 0, cost: 0, turns: 0 } };
+  if (options.signal?.aborted) return empty;
+  const plan = planHarnessRun(options);
+  const label = HARNESSES[plan.harness.id].label;
+  let dir: string | undefined;
+  const promptFile = () => {
+    dir ??= mkdtempSync(join(tmpdir(), "bot-lobby-harness-"));
+    const file = join(dir, "instructions.md");
+    writeFileSync(file, plan.instructions, { encoding: "utf8", mode: 0o600 });
+    return file;
+  };
+  try {
+    let start: HarnessStart;
+    try {
+      start = harnessLaunch(plan, { cwd: options.cwd, ...(options.env ? { env: options.env } : {}), prompt: `Task: ${options.task}`, access: accessOf(options.tools) }, promptFile);
+    } catch (error) {
+      return { ...empty, status: "failed", error: (error as Error).message };
+    }
+    const collected = collector();
+    const outcome = await start(collected, {
+      ...(options.signal ? { signal: options.signal } : {}),
+      ...(options.stallTimeoutMs !== undefined ? { stallTimeoutMs: options.stallTimeoutMs } : {}),
+      ...(options.toolStallTimeoutMs !== undefined ? { toolStallTimeoutMs: options.toolStallTimeoutMs } : {}),
+      ...(options.onStart ? { onStart: options.onStart } : {}),
+      onEvent: (event) => {
+        if (event.type === "tool_execution_start") options.onActivity?.(activityWord(event.toolName));
+        options.onEvent?.(event);
+      },
+    });
+    return toResult(collected, outcome, options.signal?.aborted === true, options, label);
+  } finally {
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  }
+}

package/src/harness/status.ts

@@ -0,0 +1,115 @@
+/**
+ * Whether each harness is installed, and its version, for the settings page.
+ * The command is looked up on PATH without running it; only the CLIs with a
+ * cheap `--version` are asked for one (Antigravity's ACP server is a large
+ * bundle, so it is never started just to probe it, as T3 Code's
+ * `AntigravityDriver.ts` also avoids).
+ */
+import { spawn } from "node:child_process";
+import { accessSync, constants, statSync } from "node:fs";
+import { delimiter, isAbsolute, join } from "node:path";
+import { HARNESS_IDS, type HarnessId, type HarnessesConfig } from "../schemas/harness.ts";
+import { HARNESSES, harnessCommand, harnessModels, type HarnessModel } from "./catalog.ts";
+
+export interface HarnessStatus {
+  id: HarnessId;
+  label: string;
+  blurb: string;
+  protocol: string;
+  /** The command a run starts, as the settings leave it. */
+  command: string;
+  /** Where it was found; absent when it was not. */
+  path?: string;
+  version?: string;
+  providers: ReadonlyArray<{ value: string; label: string }>;
+  effort: "flag" | "variant" | "session";
+  models: HarnessModel[];
+}
+
+const VERSION_TIMEOUT_MS = 4000;
+const CACHE_MS = 60_000;
+const VERSIONED: ReadonlySet<HarnessId> = new Set(["codex", "claude", "gemini", "opencode"]);
+
+function executable(path: string): boolean {
+  try {
+    if (!statSync(path).isFile()) return false;
+    accessSync(path, process.platform === "win32" ? constants.F_OK : constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** The file a command runs, from PATH (with Windows' extensions) unless it is a path already. */
+export function findCommand(command: string, env: NodeJS.ProcessEnv = process.env): string | undefined {
+  if (!command) return undefined;
+  if (isAbsolute(command) || command.includes("/")) return executable(command) ? command : undefined;
+  const extensions = process.platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
+  for (const dir of (env.PATH ?? "").split(delimiter)) {
+    if (!dir) continue;
+    for (const extension of extensions) {
+      const candidate = join(dir, command + extension);
+      if (executable(candidate)) return candidate;
+    }
+  }
+  return undefined;
+}
+
+const versions = new Map<string, { at: number; version?: string }>();
+
+function readVersion(path: string): Promise<string | undefined> {
+  const cached = versions.get(path);
+  if (cached && Date.now() - cached.at < CACHE_MS) return Promise.resolve(cached.version);
+  return new Promise((resolve) => {
+    let out = "";
+    let settled = false;
+    const done = (version?: string) => {
+      if (settled) return;
+      settled = true;
+      versions.set(path, { at: Date.now(), ...(version ? { version } : {}) });
+      resolve(version);
+    };
+    try {
+      const proc = spawn(path, ["--version"], { shell: false, windowsHide: true, stdio: ["ignore", "pipe", "ignore"], env: { ...process.env, NO_COLOR: "1" } });
+      const timer = setTimeout(() => {
+        proc.kill("SIGKILL");
+        done();
+      }, VERSION_TIMEOUT_MS);
+      timer.unref();
+      proc.stdout?.setEncoding("utf8");
+      proc.stdout?.on("data", (chunk: string) => {
+        if (out.length < 2000) out += chunk;
+      });
+      proc.on("error", () => done());
+      proc.on("close", () => {
+        clearTimeout(timer);
+        done(/\d+\.\d+(?:\.\d+)?(?:[-+][\w.]+)?/.exec(out)?.[0]);
+      });
+    } catch {
+      done();
+    }
+  });
+}
+
+/** Every harness with what the settings page shows about it. */
+export async function harnessStatuses(harnesses: HarnessesConfig): Promise<HarnessStatus[]> {
+  return Promise.all(HARNESS_IDS.map(async (id) => {
+    const info = HARNESSES[id];
+    const settings = harnesses[id];
+    const { command } = harnessCommand(id, settings);
+    const path = findCommand(command);
+    const version = path && VERSIONED.has(id) ? await readVersion(path) : undefined;
+    return {
+      id,
+      label: info.label,
+      blurb: info.blurb,
+      protocol: info.protocol,
+      command,
+      ...(path ? { path } : {}),
+      ...(version ? { version } : {}),
+      providers: info.providers,
+      effort: info.effort,
+      models: harnessModels(id, settings),
+    };
+  }));
+}

package/src/lobby/host.ts

@@ -150,6 +150,8 @@ export interface LobbyService {
   models?(): ModelChoice[];
   /** The MCP tools and skills pi offers to grant agents, for the settings page. */
   grants?(): { mcpTools: Array<{ name: string; server: string; description: string; readOnly: boolean }>; skills: Array<{ name: string; description: string; path: string }> };
+  /** Each harness's status and models; absent probes the machine (the dev server answers with a fixture). */
+  harnesses?(): import("../harness/status.ts").HarnessStatus[];
   /** The classifier models pi can call with its logins, for the classifier's picker. */
   classifierModels?(): Array<{ id: string; label: string }>;
   /** The model this window's session runs on (`provider/id`), when it has one. */

package/src/lobby/planner.ts

@@ -1008,8 +1008,9 @@ export class PlanningSession {
           model,
           thinking,
           mcpTools: profile.mcpTools,
-        ...(profile.autoCompact === false ? { autoCompact: false } : {}),
-          ...(profile.autoCompact === false ? { autoCompact: false } : {}),
+          ...(profile.autoCompact === false ? { autoCompact: false } : {}), ...(profile.compactAt ? { compactAt: profile.compactAt } : {}),
+          // Seats may run on a harness; the planner itself stays on pi (its settings cannot name one).
+          ...(profile.harness ? { harness: profile.harness } : {}),
           onChildRun: (child) => {
             this.deps.feed?.step(label, `child ${child.runId.slice(0, 8)}: ${child.step ?? child.status}`, child.runId);
             if (child.status !== "running") this.deps.feed?.end(child.runId, child.status !== "success");

package/src/lobby/pr-review.ts

@@ -279,7 +279,8 @@ export class PullReviews {
         model,
         thinking,
         mcpTools: profile.mcpTools,
-        ...(profile.autoCompact === false ? { autoCompact: false } : {}),
+        ...(profile.autoCompact === false ? { autoCompact: false } : {}), ...(profile.compactAt ? { compactAt: profile.compactAt } : {}),
+        ...(profile.harness ? { harness: profile.harness } : {}),
         onChildRun: (child) => {
           this.deps.feed?.step(REVIEW_SOURCE, `child ${child.runId.slice(0, 8)}: ${child.step ?? child.status}`, child.runId);
           if (child.status !== "running") this.deps.feed?.end(child.runId, child.status !== "success");

package/src/lobby/quickfix.ts

@@ -25,6 +25,7 @@ import type { LintExec } from "../execution/lint.ts";
 import { scriptsFor, type ScriptPicker } from "../scripts/pick.ts";
 import { dataRoot } from "../state/project.ts";
 import { lintFeed, runLintGate } from "../workflow/lint.ts";
+import type { HarnessRun } from "../schemas/harness.ts";
 
 /** A quick fix edits code, so it gets the full coding tool set. */
 export const QUICK_FIX_TOOLS: readonly string[] = ["read", "bash", "edit", "write", "grep", "find", "ls"];
@@ -95,6 +96,9 @@ export interface QuickFixProfile {
   skills?: string[];
   /** False when its settings turn the agent's auto-compaction off. */
   autoCompact?: boolean;
+  /** The third-party harness it runs on; absent runs it on pi. */
+  harness?: HarnessRun;
+  compactAt?: number;
   /** Where the job goes when its model runs out of usage or is unavailable. */
 }
 
@@ -343,8 +347,8 @@ export class QuickFixQueue {
           model,
           thinking,
           mcpTools: profile.mcpTools,
-        ...(profile.autoCompact === false ? { autoCompact: false } : {}),
-          ...(profile.autoCompact === false ? { autoCompact: false } : {}),
+          ...(profile.autoCompact === false ? { autoCompact: false } : {}), ...(profile.compactAt ? { compactAt: profile.compactAt } : {}),
+          ...(profile.harness ? { harness: profile.harness } : {}),
           delegationQuota: quota,
           agent: { runId: job.id, taskId: job.id, domain: "backend", role: "worker" },
           onChildRun: (child) => {

package/src/master/goal-check.ts

@@ -101,6 +101,7 @@ export async function runGoalCheck(request: GoalCheckRequest, run: ProcessRunner
     instruction: goalCheckInstruction(request),
     context: { task: request.request },
     systemPrompt: goalCheckPrompt(profile.instructions),
+    mcpTools: profile.mcpTools,
     ...(profile.model ? { model: profile.model } : {}),
     thinking: profile.thinking,
     cwd: request.cwd,

package/src/master/master.ts

@@ -59,7 +59,7 @@ export interface ScoutRequest {
 /** Model, thinking and grants for one run, from settings. */
 function profileFields(config: BotLobbyConfig, resolver: ProfileResolver | undefined, domain: Domain, role: AgentRequest["role"]) {
   const profile = profileFor(config, resolver, domain, role);
-  return { model: profile.model, mcpTools: profile.mcpTools, ...(profile.skills ? { skills: profile.skills } : {}), ...(profile.autoCompact === false ? { autoCompact: false } : {}), thinking: profile.thinking };
+  return { model: profile.model, mcpTools: profile.mcpTools, ...(profile.skills ? { skills: profile.skills } : {}), ...(profile.autoCompact === false ? { autoCompact: false } : {}), ...(profile.compactAt ? { compactAt: profile.compactAt } : {}), ...(profile.harness ? { harness: profile.harness } : {}), thinking: profile.thinking };
 }
 
 function scoutInstruction(request: ScoutRequest, domain: Domain): string {
@@ -198,8 +198,8 @@ async function scoutDomains(request: ScoutRequest, run: ProcessRunner): Promise<
     onUpdate: request.onUpdate,
     ...watchdogOptions(request.config.workflow),
   }));
-  // Scouts think at a fixed level; a trivial one may move to the cheaper model.
-  const routes = await Promise.all(requests.map((entry) => routeFor(request.effort, entry.instruction, { ...(entry.model ? { model: entry.model } : {}), thinking: entry.thinking ?? "low" }, { thinkingFixed: true, context: request.taskText, ...(request.signal ? { signal: request.signal } : {}) })));
+  // Scouts think at a fixed level; a trivial one may move to the cheaper model (a pi model, so not on another harness).
+  const routes = await Promise.all(requests.map((entry) => entry.harness ? undefined : routeFor(request.effort, entry.instruction, { ...(entry.model ? { model: entry.model } : {}), thinking: entry.thinking ?? "low" }, { thinkingFixed: true, context: request.taskText, ...(request.signal ? { signal: request.signal } : {}) })));
   const first = requests.map((entry, index) => (routes[index] ? { ...entry, ...routedFields(routes[index]!) } : entry));
   const runs = await runParallel(first, request.config.workflow.maxParallelScouts, run);
   let outcomes = runs.map((agentRun) => toOutcome(agentRun, agentRun.domain));

package/src/master/research.ts

@@ -70,7 +70,8 @@ export async function runResearch(request: ResearchRequest, run: ProcessRunner =
       model: profile.model,
       mcpTools: profile.mcpTools,
       ...(profile.skills ? { skills: profile.skills } : {}),
-      ...(profile.autoCompact === false ? { autoCompact: false } : {}),
+      ...(profile.autoCompact === false ? { autoCompact: false } : {}), ...(profile.compactAt ? { compactAt: profile.compactAt } : {}),
+      ...(profile.harness ? { harness: profile.harness } : {}),
       thinking: profile.thinking,
       cwd: request.cwd,
       signal: request.signal,

package/src/pi/auto-compaction.ts

@@ -1,7 +1,8 @@
 import { compact, CONFIG_DIR_NAME, DEFAULT_COMPACTION_SETTINGS, estimateTokens, findCutPoint, type ExtensionAPI, type ExtensionContext, type TurnEndEvent } from "@earendil-works/pi-coding-agent";
 import { contextMarks, freshContextOn, staleCompaction } from "./fresh-context.ts";
-import { AUTO_COMPACT_ENV, isSubagentProcess } from "./quiet.ts";
+import { AUTO_COMPACT_ENV, COMPACT_AT_ENV, isSubagentProcess } from "./quiet.ts";
 import { dataRoot, detectProjectRoot, loadConfig } from "../state/project.ts";
+import { normalizeCompactAt } from "../schemas/configuration.ts";
 import { describeShared, DIGEST_INSTRUCTION, parseDigest, shareDigest, type DigestItem } from "../knowledge/oracle-digest.ts";
 
 const CHECKPOINT = "Write a concise checkpoint with: Requirements and constraints; Decisions; Files changed; Verification and evidence; Failed approaches (do not repeat); Unfinished work and next action; Outstanding children and their assignments. Preserve concrete file references and distinguish verified facts from guesses. The parent remains responsible for integration and verification.";
@@ -9,6 +10,8 @@ const CHECKPOINT = "Write a concise checkpoint with: Requirements and constraint
 export interface AutoCompactionOptions {
   /** Whether this agent compacts on its own: a subagent by its environment, the oracle by its settings. */
   enabled?: () => boolean;
+  /** The token count set in this agent's settings to compact at; by default its environment, or the oracle's settings. */
+  target?: () => number | undefined;
   /** Where the oracle's shared knowledge goes; by default the project's knowledge files. */
   share?: (items: DigestItem[], ctx: ExtensionContext) => string;
 }
@@ -22,6 +25,15 @@ function enabledBySettings(): boolean {
   }
 }
 
+function targetBySettings(): number | undefined {
+  if (isSubagentProcess()) return normalizeCompactAt(Number(process.env[COMPACT_AT_ENV]));
+  try {
+    return loadConfig().master.compactAt;
+  } catch {
+    return undefined;
+  }
+}
+
 function shareWithAgents(items: DigestItem[], ctx: ExtensionContext): string {
   const root = detectProjectRoot(ctx.cwd, CONFIG_DIR_NAME);
   return describeShared(shareDigest(dataRoot(root, CONFIG_DIR_NAME), items));
@@ -29,18 +41,24 @@ function shareWithAgents(items: DigestItem[], ctx: ExtensionContext): string {
 
 export const CONTEXT_TARGET = 64_000;
 
-export function compactionThreshold(window: number, reserve = DEFAULT_COMPACTION_SETTINGS.reserveTokens): number {
-  return Math.max(1, Math.min(CONTEXT_TARGET, Math.floor(window * 0.6), window - Math.min(reserve, Math.floor(window / 2))));
+/**
+ * When to compact: a threshold set in Settings, else 64K or 60% of the window, whichever is smaller. Either way it
+ * stays below the window less pi's reserve, so the checkpoint still has room to be written.
+ */
+export function compactionThreshold(window: number, reserve = DEFAULT_COMPACTION_SETTINGS.reserveTokens, target?: number): number {
+  const room = window - Math.min(reserve, Math.floor(window / 2));
+  return Math.max(1, Math.min(target ?? Math.min(CONTEXT_TARGET, Math.floor(window * 0.6)), room));
 }
 
 /**
  * Compact at a settled tool boundary, below pi's own threshold (pi 1.3 still sets that only per model in settings, and
- * ctx.compact() would abort the turn we need to continue). Each agent's settings can turn it off. Compactions pi
+ * ctx.compact() would abort the turn we need to continue). Each agent's settings can turn it off or set the token count it starts at. Compactions pi
  * starts itself get the same checkpoint through `session_before_compact`. The oracle's checkpoint also lists what it learned that is worth keeping, tagged by agent, and
  * that goes into the knowledge base: its own, and the designer's, backend's and QA's where it concerns them.
  */
 export function registerAutoCompaction(pi: ExtensionAPI, summarize: typeof compact = compact, options: AutoCompactionOptions = {}): void {
   const enabled = options.enabled ?? enabledBySettings;
+  const target = options.target ?? targetBySettings;
   const share = options.share ?? shareWithAgents;
   const oracle = !isSubagentProcess();
   let busy = false;
@@ -53,7 +71,7 @@ export function registerAutoCompaction(pi: ExtensionAPI, summarize: typeof compa
     const configured = pi.getSettings().compaction;
     const override = configured?.modelOverrides?.[`${ctx.model.provider}/${ctx.model.id}`];
     const reserve = Math.min(override?.reserveTokens ?? configured?.reserveTokens ?? DEFAULT_COMPACTION_SETTINGS.reserveTokens, Math.floor(ctx.model.contextWindow / 2));
-    const threshold = compactionThreshold(ctx.model.contextWindow, reserve);
+    const threshold = compactionThreshold(ctx.model.contextWindow, reserve, target());
     const estimate = event.context.contextMessages.reduce((total, message) => total + estimateTokens(message), 0) + Math.ceil(ctx.getSystemPrompt().length / 4);
     const usage = ctx.getContextUsage();
     if (Math.max(estimate, usage?.tokens ?? 0) < threshold) return;