ennodia 0.2.0 → 0.3.0

package/src/diagnosis.ts

@@ -42,23 +42,29 @@ export function diagnoseTasks(tasks: TaskView[]): TaskDiagnosis | undefined {
 }
 
 function likelyCause(tasks: TaskView[]): string {
+  if (tasks.every(hasQuotaError)) {
+    return "Provider usage capacity was exhausted. This attempt does not establish solution quality or a cost saving.";
+  }
+  if (tasks.every(hasAuthenticationError)) {
+    return "Agent authentication failed. This attempt did not establish how the selected model would handle the task.";
+  }
   if (tasks.every((task) => task.timedOut)) {
     if (tasks.some(outputChars) && tasks.some(hasRecentOutput)) {
-      return "Task needed more time; at least one provider was still producing output before the deadline.";
+      return "The task produced output near its deadline but did not return a completed result.";
     }
 
     if (tasks.some(outputChars)) {
-      return "Provider timeout after partial progress.";
+      return "Ennodia stopped the task at its execution deadline after capturing output; the value of that output is not yet assessed.";
     }
 
-    return "Provider timeout before useful output; this may be slow startup, a model hang, or provider configuration.";
+    return "Ennodia stopped the task at its execution deadline without captured output. This does not establish whether the model was investigating, blocked, or unable to solve the task.";
   }
 
   if (tasks.some((task) => task.drainTimedOut)) {
     return "Output drain timed out; captured output may be incomplete.";
   }
 
-  if (tasks.some((task) => task.exitCode !== undefined && task.exitCode !== 0)) {
+  if (tasks.some((task) => !task.timedOut && !task.cancelRequested && task.exitCode !== undefined && task.exitCode !== null && task.exitCode !== 0)) {
     return "Provider command error or bad configuration.";
   }
 
@@ -75,17 +81,27 @@ function suggestions(
 ): string[] {
   const result = new Set<string>();
 
+  if (tasks.some(hasQuotaError)) {
+    result.add("Preserve partial findings. Check capacity through the provider's supported interface before retrying; do not repeat calls against the exhausted account.");
+  }
+
+  if (tasks.some(hasAuthenticationError)) {
+    result.add("Sign in through the affected agent's supported CLI, then retry the same task.");
+  }
+
   if (tasks.some((task) => task.timedOut)) {
-    result.add("Retry the timed-out provider with a longer timeoutMs.");
+    result.add("Review captured findings and partial changes before retrying. Check the assigned scope, deadline, tool access, and permissions; continue useful work with an adequate budget instead of repeating the investigation.");
   }
 
   if (hasPartialOutput) {
     result.add("Inspect partial output and events with ennodia_get_task.");
   }
 
-  if (tasks.some((task) => task.exitCode !== undefined && task.exitCode !== 0)) {
+  if (tasks.some((task) => !task.timedOut && !task.cancelRequested && task.exitCode !== undefined && task.exitCode !== null && task.exitCode !== 0)) {
     result.add("Inspect stderr and task events with ennodia_get_task.");
-    result.add("Retry with a different harness if the provider command looks broken.");
+    if (!tasks.every(task => hasAuthenticationError(task) || hasQuotaError(task))) {
+      result.add("Check the requested model and command configuration before retrying.");
+    }
   }
 
   if (tasks.some((task) => task.drainTimedOut)) {
@@ -99,6 +115,27 @@ function suggestions(
   return [...result];
 }
 
+/** Only native error envelopes count; quoted tool output is not a quota signal. */
+export function hasCodexQuotaError(stdout: string): boolean {
+  for (const line of stdout.split("\n")) {
+    let event;
+    try { event = JSON.parse(line); } catch { continue; }
+    const message = event?.type === "error" ? event.message
+      : event?.type === "turn.failed" ? event.error?.message : undefined;
+    if (typeof message === "string" && /^You've hit your usage limit\b/i.test(message)) return true;
+  }
+  return false;
+}
+
+function hasQuotaError(task: TaskView): boolean {
+  return task.harnessId === "codex" && (hasCodexQuotaError(task.stdout) || hasCodexQuotaError(task.stderr));
+}
+
+function hasAuthenticationError(task: TaskView): boolean {
+  return !task.timedOut && /^(?:Error: )?(?:Failed to authenticate:|OAuth session expired|Authentication failed:|Not logged in\b)/im
+    .test(`${task.stdout}\n${task.stderr}`);
+}
+
 function summaryLine(task: TaskView): string {
   const status = task.timedOut ? "timed out" : task.status;
   const facts = [

package/src/harnesses.ts

@@ -1,12 +1,35 @@
 import { existsSync } from "node:fs";
+import { signalOwnedProcess } from "./process";
 import { type Skill } from "./skills";
 
 export type HarnessKind = "cli" | "app";
 
+export const DEFAULT_TASK_TIMEOUT_MS = 5 * 60 * 1000;
+
+export const REASONING_EFFORTS = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "ultra",
+] as const;
+
+export type ReasoningEffort = (typeof REASONING_EFFORTS)[number];
+
 export type HarnessRunInput = {
   prompt: string;
   cwd?: string;
   model?: string;
+  reasoningEffort?: ReasoningEffort;
+  nativeSubagents?: "disabled";
+  nativeSandbox?: "read-only" | "workspace-write";
+  /** Request native session persistence when the selected adapter supports it. */
+  persistSession?: boolean;
+  /** Manager-resolved native session ID to resume for a continuation. */
+  nativeSessionId?: string;
+  /** TaskManager-owned task ID for continuation; adapters do not consume it. */
+  continueTaskId?: string;
   timeoutMs?: number;
   skills?: Skill[];
   /** Run the task against an ephemeral isolated copy of cwd instead of cwd
@@ -24,6 +47,12 @@ export type HarnessUsage = {
   /** Best-effort, adapter-reported token count. Not guaranteed available or
    * billing-accurate; parsed from each CLI's own text output where possible. */
   tokensUsed?: number;
+  /** Native input-token count when the adapter reports a structured breakdown. */
+  inputTokens?: number;
+  /** Native cached-input count; this is a subset of inputTokens. */
+  cachedInputTokens?: number;
+  /** Native output-token count when the adapter reports a structured breakdown. */
+  outputTokens?: number;
 };
 
 export type CommandSpec = {
@@ -43,11 +72,46 @@ export type HarnessAdapter = {
   versionArgs?: string[];
   capabilities: string[];
   notes?: string[];
+  /** Input preparation guidance, not a guarantee of model or tool access. */
+  inputGuidance?: string[];
+  /** Whether the adapter can receive an explicit reasoning effort setting. */
+  supportsReasoningEffort?: boolean;
+  supportsNativeSubagentControl?: boolean;
+  supportsNativeSandbox?: boolean;
+  /** Whether the adapter supports manager-owned native session continuation. */
+  supportsSessionContinuation?: boolean;
   buildCommand?: (commandPath: string, input: HarnessRunInput) => CommandSpec;
   /** Best-effort usage extraction from a finished task's captured output. */
   extractUsage?: (stdout: string, stderr: string) => HarnessUsage | undefined;
+  /** Extract a native session ID from captured stdout as it arrives. */
+  extractSessionId?: (stdout: string) => string | undefined;
+  /** Some public CLIs report a semantic failure with exit code zero. */
+  failureReason?: (stdout: string, stderr: string) => string | undefined;
 };
 
+export function assertNativeSandboxSupported(adapter: HarnessAdapter, setting?: "read-only" | "workspace-write"): void {
+  if (setting === undefined) return;
+  if (setting !== "read-only" && setting !== "workspace-write") throw new Error("Unsupported nativeSandbox setting.");
+  if (!adapter.supportsNativeSandbox) throw new Error(`${adapter.name} (${adapter.id}) does not support nativeSandbox control.`);
+}
+
+export function assertNativeSubagentsSupported(adapter: HarnessAdapter, setting?: "disabled"): void {
+  if (setting !== undefined && !adapter.supportsNativeSubagentControl) {
+    throw new Error(`${adapter.name} (${adapter.id}) does not support nativeSubagents control.`);
+  }
+}
+
+export function assertReasoningEffortSupported(
+  adapter: Pick<HarnessAdapter, "id" | "name" | "supportsReasoningEffort">,
+  reasoningEffort?: ReasoningEffort,
+): void {
+  if (reasoningEffort !== undefined && !adapter.supportsReasoningEffort) {
+    throw new Error(
+      `${adapter.name} (${adapter.id}) does not support explicit reasoningEffort.`,
+    );
+  }
+}
+
 export type HarnessDiscovery = {
   id: string;
   name: string;
@@ -59,6 +123,7 @@ export type HarnessDiscovery = {
   version?: string;
   capabilities: string[];
   notes: string[];
+  inputGuidance?: string[];
 };
 
 export type DiscoverHarnessesOptions = {
@@ -75,12 +140,36 @@ type CaptureResult = {
 
 const DEFAULT_VERSION_TIMEOUT_MS = 2_500;
 const DEFAULT_DISCOVERY_CACHE_MS = 30_000;
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
 let cachedDiscovery:
   | { createdAtMs: number; harnesses: HarnessDiscovery[] }
   | undefined;
 let inFlightDiscovery: Promise<HarnessDiscovery[]> | undefined;
 
+export const MULTIMODAL_INPUT_GUIDANCE = [
+  "Ennodia passes text prompts and local file paths, not media attachments. Native input depends on the selected harness, model, file tools, permissions, and format. Missing guidance means unverified access.",
+  "When native listening or viewing is required, first load one small sample with native file tools. Report the file, inspected range, tool, and content-specific evidence, or the exact blocking error. A transcript, DSP score, or extracted frame is not equivalent evidence.",
+  "For media comparisons, use matching excerpts and an original reference. Separate cleanup quality from voice or image fidelity. Report conversions and limitations; a successful process exit does not establish successful media inspection.",
+];
+
+export function hasMultimodalInput(prompt: string): boolean {
+  return /\b(audio|video|image|multimodal|listen|listening|sound|speech|voice|recordings?|footage)\b|\.(mp3|wav|flac|m4a|aac|opus|ogg|ogv|mp4|mov|webm|png|jpe?g|webp)\b/i.test(prompt);
+}
+
+/** Keep preparation instructions out of unrelated work and internal text judges. */
+export function withInputGuidance(
+  prompt: string,
+  adapter?: Pick<HarnessAdapter, "inputGuidance">,
+): string {
+  if (!hasMultimodalInput(prompt) || /^ENNODIA_(?:COMPARE|PLAN_ADVISOR)/.test(prompt)) {
+    return prompt;
+  }
+  return `${prompt}\n\nEnnodia media input guidance (applies when native media inspection is required):\n${
+    (adapter?.inputGuidance ?? MULTIMODAL_INPUT_GUIDANCE).map((note) => `- ${note}`).join("\n")
+  }`;
+}
+
 export const harnessAdapters: HarnessAdapter[] = [
   {
     id: "claude-code",
@@ -102,7 +191,7 @@ export const harnessAdapters: HarnessAdapter[] = [
         args.push("--model", input.model);
       }
 
-      args.push(input.prompt);
+      args.push("--", input.prompt);
       return { command: commandPath, args, cwd: input.cwd };
     },
   },
@@ -114,17 +203,26 @@ export const harnessAdapters: HarnessAdapter[] = [
     versionArgs: ["--version"],
     capabilities: ["reasoning", "code", "agents", "mcp", "non-interactive-cli"],
     notes: ["Defaults to read-only sandboxing for Ennodia-launched tasks."],
+    supportsReasoningEffort: true,
+    supportsSessionContinuation: true,
+    supportsNativeSubagentControl: true,
+    supportsNativeSandbox: true,
     buildCommand: (commandPath, input) => {
+      const resuming = Boolean(input.nativeSessionId);
+      const persistent = Boolean(input.persistSession || resuming);
       const args = [
         "exec",
         "--color",
         "never",
         "--sandbox",
-        "read-only",
+        input.nativeSandbox ?? "read-only",
         "--skip-git-repo-check",
-        "--ephemeral",
       ];
 
+      if (!persistent) {
+        args.push("--ephemeral");
+      }
+
       if (input.cwd) {
         args.push("-C", input.cwd);
       }
@@ -133,15 +231,36 @@ export const harnessAdapters: HarnessAdapter[] = [
         args.push("--model", input.model);
       }
 
+      if (input.reasoningEffort) {
+        args.push("-c", `model_reasoning_effort="${input.reasoningEffort}"`);
+      }
+
+      if (input.nativeSubagents === "disabled") args.push("--disable", "multi_agent", "--disable", "multi_agent_v2");
+
+      if (resuming) {
+        args.push("resume", input.nativeSessionId!, "--json");
+      } else if (persistent) {
+        args.push("--json");
+      }
+
       if (input.finalMessagePath) {
         args.push("-o", input.finalMessagePath);
       }
 
-      args.push(input.prompt);
+      args.push("--", input.prompt);
       return { command: commandPath, args, cwd: input.cwd };
     },
-    extractUsage: (stdout) => {
-      const match = /tokens used\s*\n\s*([\d,]+)/i.exec(stdout);
+    extractSessionId: extractCodexSessionId,
+    extractUsage: (stdout, stderr) => {
+      const jsonUsage = extractCodexJsonUsage(stdout);
+      if (jsonUsage) {
+        return jsonUsage;
+      }
+
+      if (/"type"\s*:\s*"turn\.(?:started|completed|failed)"/.test(stdout)) return undefined;
+
+      const summary = /(?:^|\n)tokens used[ \t]*\r?\n[ \t]*([\d,]+)\s*$/i;
+      const match = summary.exec(stderr) ?? summary.exec(stdout);
       if (!match) {
         return undefined;
       }
@@ -169,7 +288,7 @@ export const harnessAdapters: HarnessAdapter[] = [
         args.push("--model", input.model);
       }
 
-      args.push(input.prompt);
+      args.push("--", input.prompt);
       return { command: commandPath, args, cwd: input.cwd };
     },
   },
@@ -201,7 +320,7 @@ export const harnessAdapters: HarnessAdapter[] = [
         args.push("--model", input.model);
       }
 
-      args.push(input.prompt);
+      args.push("--", input.prompt);
       return { command: commandPath, args, cwd: input.cwd };
     },
   },
@@ -256,7 +375,7 @@ export const harnessAdapters: HarnessAdapter[] = [
         args.push("--model", input.model);
       }
 
-      args.push(input.prompt);
+      args.push("--", input.prompt);
       return { command: commandPath, args, cwd: input.cwd };
     },
   },
@@ -281,7 +400,7 @@ export const harnessAdapters: HarnessAdapter[] = [
         args.push("--model", input.model);
       }
 
-      args.push(input.prompt);
+      args.push("--", input.prompt);
       return { command: commandPath, args, cwd: input.cwd };
     },
   },
@@ -296,11 +415,22 @@ export const harnessAdapters: HarnessAdapter[] = [
       "/Applications/Antigravity IDE.app",
     ],
     capabilities: ["ide", "browser-automation", "agents", "non-interactive-cli"],
+    inputGuidance: [
+      ...MULTIMODAL_INPUT_GUIDANCE,
+      "Antigravity headless input is text-only, including stream-json content blocks. Put local paths in the prompt and use the worker's native view_file tool when available; do not send Gemini API attachment blocks to agy. https://antigravity.google/docs/cli/headless/",
+      "Observed 2026-09-10 with agy 1.2.0 and gemini-3.8-flash-medium: an eight-second MP3 loaded through view_file and returned spoken words absent from the prompt. Start with a short MP3 probe for this route, then compare matched samples after confirming native access.",
+      "In that same case, FLAC was rejected as unsupported MIME audio/x-flac; four WAV samples timed out without output. These are scoped observations, not a universal FLAC/WAV support rule. CLI release notes list broader audio support: https://antigravity.google/changelog",
+      "Use native file tools first. Headless command permission denials cannot be approved interactively; report the blocked operation and keep normal permission settings. Do not keep guessing formats or repeat an unchanged failed request.",
+    ],
     notes: [
       "Runs through the supported `agy` CLI surface.",
       "Defaults to Antigravity sandbox mode for Ennodia-launched tasks.",
       "Passes the prompt as the value of Antigravity's non-interactive `--print` option.",
     ],
+    failureReason: (stdout, stderr) => !stdout.trim() &&
+      /^jetski: no output produced\b/m.test(stderr)
+      ? "Antigravity returned no answer. Check the required tool access in its normal permission settings."
+      : undefined,
     buildCommand: (commandPath, input) => {
       const args = [
         "--sandbox",
@@ -323,6 +453,110 @@ export const harnessAdapters: HarnessAdapter[] = [
   },
 ];
 
+function extractCodexSessionId(stdout: string): string | undefined {
+  for (const line of stdout.split(/\r?\n/)) {
+    const event = parseJsonObject(line);
+    if (event?.type !== "thread.started") {
+      continue;
+    }
+
+    const threadId = event.thread_id;
+    if (typeof threadId === "string" && UUID_PATTERN.test(threadId)) {
+      return threadId;
+    }
+  }
+
+  return undefined;
+}
+
+function extractCodexJsonUsage(stdout: string): HarnessUsage | undefined {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cachedInputTokens = 0;
+  let cachedInputKnown = true;
+  let found = false;
+  let malformed = false;
+  let pendingTurn = false;
+
+  for (const line of stdout.split(/\r?\n/)) {
+    const event = parseJsonObject(line);
+    if (event?.type === "turn.started" || event?.type === "turn.failed") pendingTurn = true;
+    if (event?.type !== "turn.completed") {
+      if (
+        !event &&
+        /^\s*\{/.test(line) &&
+        /"type"\s*:\s*"turn\.completed"/.test(line)
+      ) {
+        malformed = true;
+        break;
+      }
+      continue;
+    }
+
+    if (!isRecord(event.usage)) {
+      malformed = true;
+      break;
+    }
+
+    const input = event.usage.input_tokens;
+    const output = event.usage.output_tokens;
+    if (!isTokenCount(input) || !isTokenCount(output)) {
+      malformed = true;
+      break;
+    }
+
+    found = true;
+    pendingTurn = false;
+    inputTokens += input;
+    outputTokens += output;
+    const cached = event.usage.cached_input_tokens;
+    if (cached === undefined) {
+      cachedInputKnown = false;
+    } else if (!isTokenCount(cached) || cached > input) {
+      malformed = true;
+      break;
+    } else {
+      cachedInputTokens += cached;
+    }
+  }
+
+  if (
+    malformed ||
+    pendingTurn ||
+    !found ||
+    !isTokenCount(inputTokens) ||
+    !isTokenCount(outputTokens) ||
+    !isTokenCount(inputTokens + outputTokens) ||
+    (cachedInputKnown && !isTokenCount(cachedInputTokens))
+  ) {
+    return undefined;
+  }
+
+  return {
+    tokensUsed: inputTokens + outputTokens,
+    inputTokens,
+    ...(cachedInputKnown ? { cachedInputTokens } : {}),
+    outputTokens,
+  };
+}
+
+function parseJsonObject(line: string): Record<string, unknown> | undefined {
+  try {
+    const value: unknown = JSON.parse(line);
+    return isRecord(value) ? value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isTokenCount(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+
 export async function discoverHarnesses(
   options: DiscoverHarnessesOptions = {},
 ): Promise<HarnessDiscovery[]> {
@@ -367,7 +601,15 @@ async function discoverHarness(
     .find((match): match is string => Boolean(match));
 
   const appPath = adapter.appPaths?.find((path) => existsSync(path));
-  const version = commandPath ? await readVersion(commandPath, adapter) : undefined;
+  let version: string | undefined;
+  const notes = [...(adapter.notes ?? [])];
+  if (commandPath) {
+    try {
+      version = await readVersion(commandPath, adapter);
+    } catch (error) {
+      notes.push(`Version check failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
   const available = Boolean(commandPath || appPath);
   const runnable = Boolean(commandPath && adapter.buildCommand);
 
@@ -381,7 +623,8 @@ async function discoverHarness(
     appPath,
     version,
     capabilities: adapter.capabilities,
-    notes: adapter.notes ?? [],
+    notes,
+    ...(adapter.inputGuidance ? { inputGuidance: [...adapter.inputGuidance] } : {}),
   };
 }
 
@@ -396,6 +639,8 @@ async function readVersion(
   const result = await capture(commandPath, adapter.versionArgs, {
     timeoutMs: DEFAULT_VERSION_TIMEOUT_MS,
   });
+  if (result.timedOut) throw new Error("Version probe timed out.");
+  if (result.exitCode !== 0) throw new Error(`Version probe exited with code ${result.exitCode}.`);
 
   const text = `${result.stdout}\n${result.stderr}`.trim();
   return text.split(/\r?\n/).find((line) => line.trim())?.trim();
@@ -406,41 +651,49 @@ async function capture(
   args: string[],
   options: { timeoutMs: number },
 ): Promise<CaptureResult> {
-  const process = Bun.spawn({
+  const child = Bun.spawn({
     cmd: [command, ...args],
     stdout: "pipe",
     stderr: "pipe",
+    detached: process.platform !== "win32",
   });
 
   let timedOut = false;
-  const timeout = setTimeout(() => {
-    timedOut = true;
-    process.kill();
-  }, options.timeoutMs);
+  let timeout: Timer | undefined;
+  const readers = [child.stdout.getReader(), child.stderr.getReader()];
+  const output = ["", ""];
+  const drained = Promise.all(readers.map(async (reader, index) => {
+    const decoder = new TextDecoder();
+    try {
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        output[index] = (output[index] + decoder.decode(value, { stream: true })).slice(0, 8_000);
+      }
+      output[index] += decoder.decode();
+    } catch { /* cancellation closes a stalled pipe */ }
+    finally { reader.releaseLock(); }
+  }));
 
   try {
-    const [stdout, stderr, exitCode] = await Promise.all([
-      streamToText(process.stdout),
-      streamToText(process.stderr),
-      process.exited,
+    const exitCode = await Promise.race([
+      Promise.all([drained, child.exited]).then(([, code]) => code),
+      new Promise<null>((resolve) => {
+        timeout = setTimeout(() => {
+          timedOut = true;
+          signalOwnedProcess(child, "SIGKILL");
+          for (const reader of readers) void reader.cancel().catch(() => undefined);
+          resolve(null);
+        }, options.timeoutMs);
+      }),
     ]);
-
-    return { stdout, stderr, exitCode, timedOut };
+    return { stdout: output[0], stderr: output[1], exitCode, timedOut };
   } finally {
     clearTimeout(timeout);
+    if (!timedOut) signalOwnedProcess(child, "SIGKILL");
   }
 }
 
-async function streamToText(
-  stream: ReadableStream<Uint8Array> | null,
-): Promise<string> {
-  if (!stream) {
-    return "";
-  }
-
-  return await new Response(stream).text();
-}
-
 function toGoDuration(timeoutMs = 5 * 60 * 1000): string {
   const seconds = Math.max(1, Math.ceil(timeoutMs / 1000));
   return `${seconds}s`;

package/src/history.ts

@@ -60,10 +60,13 @@ export class FileHistorySink implements HistorySink {
 
   async recordRun(snapshot: RunHistorySnapshot): Promise<void> {
     await mkdir(this.dir, { recursive: true, mode: 0o700 });
+    // Frame each append with a leading newline so a previous truncated record
+    // cannot swallow the next receipt. Keep the delimiter and record in one
+    // append; never read/truncate the shared file to repair it.
     // Append-only hot path: an interrupted write can lose at most this
     // snapshot, and concurrent writers (MCP and IO processes share the
     // default directory) cannot clobber each other's lines.
-    await appendFile(this.path, `${serialize(snapshot)}\n`, { mode: 0o600 });
+    await appendFile(this.path, `\n${serialize(snapshot)}\n`, { mode: 0o600 });
     await this.compactIfNeeded();
   }
 

package/src/index.ts

@@ -1,3 +1,4 @@
+export { pragmaticSchema, type PragmaticOptions } from "./pragmatic";
 export {
   createEnnodiaServer,
   shutdownEnnodia,
@@ -99,12 +100,14 @@ export {
   discoverHarnesses,
   findHarnessAdapter,
   harnessAdapters,
+  REASONING_EFFORTS,
   type CommandSpec,
   type DiscoverHarnessesOptions,
   type HarnessAdapter,
   type HarnessDiscovery,
   type HarnessKind,
   type HarnessRunInput,
+  type ReasoningEffort,
 } from "./harnesses";
 export { planRoute, renderPlanMermaid, type RoutePlan } from "./planner";
 export {

package/src/plan-advice.ts

@@ -97,6 +97,7 @@ export type PlanAdviceManagerStartInput = {
   advisorModel?: string;
   timeoutMs?: number;
   budget?: BudgetLimits;
+  findHarnessAdapter?: (id: string) => HarnessAdapter | undefined;
 };
 
 export type PlanAdviceRevalidationContext = {
@@ -117,6 +118,7 @@ type InternalPlanAdvice = {
   advisorModel?: string;
   advisorTimeoutMs: number;
   budgetLimits?: BudgetLimits;
+  findHarnessAdapter?: PlanAdviceManagerStartInput["findHarnessAdapter"];
   advisorBudget: BudgetCheck;
   executionBudget?: BudgetCheck;
   proposal?: AdvisorPlanProposal;
@@ -167,7 +169,7 @@ export class PlanAdviceManager {
           harnessId: input.advisor.adapter.id,
         }],
         comparePlanned: false,
-      }),
+      }, () => input.advisor.adapter),
       input.budget,
     );
     assertBudgetWithinLimits(advisorBudget);
@@ -208,6 +210,7 @@ export class PlanAdviceManager {
       advisorTimeoutMs: advisorTask.timeoutMs ??
         input.timeoutMs ?? DEFAULT_ADVISOR_TIMEOUT_MS,
       budgetLimits: input.budget ? { ...input.budget } : undefined,
+      findHarnessAdapter: input.findHarnessAdapter,
       advisorBudget,
       issues: [],
       createdAtMs: now,
@@ -386,7 +389,7 @@ export class PlanAdviceManager {
             harnessId: slice.harnessId,
           })),
           comparePlanned: false,
-        }),
+        }, record.findHarnessAdapter),
         record.budgetLimits,
       );
       record.executionBudget = executionBudget;