@agntn/harnesses 0.3.1 → 0.4.1

package/README.md

@@ -34,7 +34,7 @@ The rest of it sits on [harnesses.agntn.dev](https://harnesses.agntn.dev).
 pnpm add @agntn/harnesses
 ```
 
-Node.js 24 or newer.
+Node.js 26 or newer.
 
 ## 🚀 First call
 
@@ -45,22 +45,22 @@ npx @agntn/harnesses detect
 ```
   System Scan
 
-    ● antigravity     Google Antigravity CLI  v1.2.5
-    ● claude          Anthropic Claude Code  v2.1.276
-    ● codex           OpenAI Codex CLI  v0.154.0
+    ● antigravity     Google Antigravity CLI  v1.2.14   agent
+    ● claude          Anthropic Claude Code   v2.1.289  advisor · readOnly · agent
+    ● codex           OpenAI Codex CLI        v0.160.0  readOnly · agent
     ○ cursor          Cursor
-    ● freebuff        Freebuff
+    ● freebuff        Freebuff                v0.0.204  no headless mode
     ○ gemini          Google Gemini CLI
     ○ github-copilot  GitHub Copilot
-    ● grok            xAI Grok CLI  v1.0.34
-    ● mastracode      Mastra Code
-    ● omp             OMP (oh-my-pi)  v18.2.4
-    ● opencode        OpenCode CLI  v2.0.5
-    ● prime-agent     Prime Agent  v0.9.5
-    ● pi              Pi Coding Agent  v0.85.1
+    ● grok            xAI Grok CLI            v1.0.41   readOnly · agent
+    ● mastracode      Mastra Code             v0.10.2   no headless mode
+    ● omp             OMP (oh-my-pi)          v18.6.1   agent
+    ● opencode        OpenCode CLI            v2.0.22   agent
+    ● prime-agent     Prime Agent             v0.9.5    advisor · agent
+    ● pi              Pi Coding Agent         v1.0.2    advisor · readOnly · agent
 ```
 
-No key, no config. No network either. `detect` looks at `PATH`. Filled dot is installed, hollow is not. After `pnpm add`, the same command is `pnpm exec harnesses`, or install it once with `pnpm add -g @agntn/harnesses`.
+No key, no config. No network either. `detect` looks at `PATH`. Filled dot is installed, hollow is not. The tail says how `run` can drive it: `advisor` without tools, `readOnly` behind the harness's own read-only lock, `agent` with everything. Codex has no advisor, and now you learn that here, not from a refused run. After `pnpm add`, the same command is `pnpm exec harnesses`, or install it once with `pnpm add -g @agntn/harnesses`.
 
 Same binary, more commands:
 
@@ -77,14 +77,14 @@ harnesses prompts sync --check
 harnesses skills sync --check
 ```
 
-`run` without `--tools` is the advisor. `--tools` is the full agent. `--read-only` asks the CLI for a sandbox and implies tools, so pairing it with `--no-tools` is an error. Timeouts, `--cwd` and `--model` sit in the [CLI guide](https://harnesses.agntn.dev/guide/cli).
+`run` without `--tools` is the advisor. `--tools` is the full agent. `--read-only` asks the CLI for a sandbox and implies tools, so pairing it with `--no-tools` is an error. Timeouts, `--cwd`, `--model` and `--effort` sit in the [CLI guide](https://harnesses.agntn.dev/guide/cli).
 
 ### Commands
 
 | Command        | What it does                                           | Example                                     |
 | -------------- | ------------------------------------------------------ | ------------------------------------------- |
 | `list`         | Every known harness, id and name                       | `harnesses list`                            |
-| `detect`       | Which ones are installed, with versions                | `harnesses detect`                          |
+| `detect`       | Which ones are installed, and how each one runs        | `harnesses detect`                          |
 | `info`         | Registry entry: modes, capabilities, path templates    | `harnesses info claude`                     |
 | `paths`        | Those templates expanded for this machine              | `harnesses paths pi`                        |
 | `models`       | Models the harness can use, through its native listing | `harnesses models pi`                       |
@@ -110,7 +110,7 @@ console.log(paths.temp, claude.envOverrides);
 const active = detectHarness();
 if (active) console.log(active.id);
 
-await getHarness("codex").invoke("Review this patch", { readOnly: true });
+await getHarness("codex").invoke("Review this patch", { readOnly: true, effort: "low" });
 
 const agy = getHarness("antigravity");
 const [model] = (await agy.listModels({ search: "gemini" })).models;
@@ -119,7 +119,7 @@ if (model) await agy.invoke("Review this patch", { tools: true, model: agy.model
 
 `temp` is where a harness drops its own temp files, and `envOverrides` names the variables that move its directories. `claude.resolve().temp` follows `CLAUDE_CODE_TMPDIR` when it's set, which is handy when `/tmp` is tmpfs and Claude's scratchpads are quietly eating RAM.
 
-That's most of it, really. `getHarness` wants an exact id. `detectHarness` uses env vars first, then a single project marker. `invoke()` talks to the CLI. `listModels()` asks it what it can run, and `modelSelector()` turns one of those into what `model` takes, since Pi wants `provider/id` and Antigravity the bare id. A mode the CLI cannot run comes back as an error, not a quieter one. The rest: [Registry](https://harnesses.agntn.dev/guide/registry), [Invoke](https://harnesses.agntn.dev/guide/invoke), [MCP servers](https://harnesses.agntn.dev/guide/mcp-servers), [Instructions files](https://harnesses.agntn.dev/guide/agents-sync).
+That's most of it, really. `getHarness` wants an exact id. `detectHarness` uses env vars first, then a single project marker. `invoke()` talks to the CLI, and `effort` decides how hard it thinks for that one run. `listModels()` asks it what it can run, and `modelSelector()` turns one of those into what `model` takes, since Pi wants `provider/id` while Antigravity and Codex want the bare id. A mode the CLI cannot run comes back as an error, not a quieter one. The rest: [Registry](https://harnesses.agntn.dev/guide/registry), [Invoke](https://harnesses.agntn.dev/guide/invoke), [MCP servers](https://harnesses.agntn.dev/guide/mcp-servers), [Instructions files](https://harnesses.agntn.dev/guide/agents-sync).
 
 ### Prompt templates
 

package/dist/_chunks/agents.mjs

@@ -1,4 +1,4 @@
-import { v as isHarnessId, y as listHarnesses } from "./skills-sync.mjs";
+import { b as listHarnesses, y as isHarnessId } from "./skills-sync.mjs";
 import { r as agentsSync } from "./tool-operations.mjs";
 import { n as formatArgs, r as report } from "./output.mjs";
 import { defineCommand } from "citty";

package/dist/_chunks/mcp-servers.mjs

@@ -1,4 +1,4 @@
-import { v as isHarnessId, y as listHarnesses } from "./skills-sync.mjs";
+import { b as listHarnesses, y as isHarnessId } from "./skills-sync.mjs";
 import { c as mcpList, l as mcpRemove, s as mcpAdd, u as mcpSync } from "./tool-operations.mjs";
 import { n as formatArgs, r as report } from "./output.mjs";
 import { defineCommand } from "citty";

package/dist/_chunks/output.mjs

@@ -29,6 +29,6 @@ function report(result, args) {
 	if (result.isError) process.exitCode = 1;
 }
 //#endregion
-export { formatArgs as n, report as r, exitOnClosedPipe as t };
+export { sanitize as i, formatArgs as n, report as r, exitOnClosedPipe as t };
 
 //# sourceMappingURL=output.mjs.map

package/dist/_chunks/output.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"output.mjs","names":["toToon"],"sources":["../../src/commands/output.ts"],"sourcesContent":["import { stripVTControlCharacters } from \"node:util\";\nimport { encode as toToon } from \"@toon-format/toon\";\nimport { consola } from \"consola\";\nimport type { ToolResult } from \"../tool-operations.ts\";\n\nexport const formatArgs = {\n  json: { type: \"boolean\" as const, description: \"Output as JSON\" },\n  toon: { type: \"boolean\" as const, description: \"Output as TOON\" },\n};\n\n/**\n * Ends the process once the reader of stdout or stderr is gone, as after\n * `| head -1` or a pager that quits early. Node ignores SIGPIPE, so without a\n * listener the next write throws `EPIPE` with a stack trace. The exit code\n * stays whatever the command set.\n *\n * @param error - The error the stream emitted.\n */\nexport function exitOnClosedPipe(error: Readonly<NodeJS.ErrnoException>): void {\n  if (error.code !== \"EPIPE\") throw error;\n  process.exit();\n}\n\ntype OutputFormat = Readonly<{ json?: boolean; toon?: boolean }>;\n\n/** Control bytes removed from reports because they can echo untrusted configuration values. */\n/* oxlint-disable-next-line no-control-regex */\nconst UNSAFE_TERMINAL_CONTROLS = /[\\u0000-\\u0008\\u000B-\\u001F\\u007F-\\u009F]/g;\nconst UNSAFE_UNICODE_FORMATTING = /[\\p{Cf}\\p{Zl}\\p{Zp}]/gu;\n\nfunction sanitize(text: string | undefined): string {\n  return stripVTControlCharacters(text ?? \"\")\n    .replace(UNSAFE_TERMINAL_CONTROLS, \" \")\n    .replace(UNSAFE_UNICODE_FORMATTING, \" \");\n}\n\n/**\n * Emits one tool result in the selected machine or human format.\n *\n * @param result - Shared executor result to emit.\n * @param args - Selected output format.\n */\nexport function report(result: ToolResult<unknown>, args: OutputFormat): void {\n  if (args.json) console.log(JSON.stringify(result.details, null, 2));\n  else if (args.toon) console.log(toToon(result.details));\n  else if (result.isError) consola.error(sanitize(result.content[0]?.text));\n  else console.log(sanitize(result.content[0]?.text));\n\n  if (result.isError) process.exitCode = 1;\n}\n"],"mappings":";;;;AAKA,MAAa,aAAa;CACxB,MAAM;EAAE,MAAM;EAAoB,aAAa;CAAiB;CAChE,MAAM;EAAE,MAAM;EAAoB,aAAa;CAAiB;AAClE;AAUA,SAAgB,iBAAiB,OAA8C;CAC7E,IAAI,MAAM,SAAS,SAAS,MAAM;CAClC,QAAQ,KAAK;AACf;AAMA,MAAM,2BAA2B;AACjC,MAAM,4BAA4B;AAElC,SAAS,SAAS,MAAkC;CAClD,OAAO,yBAAyB,QAAQ,EAAE,CAAC,CACxC,QAAQ,0BAA0B,GAAG,CAAC,CACtC,QAAQ,2BAA2B,GAAG;AAC3C;AAQA,SAAgB,OAAO,QAA6B,MAA0B;CAC5E,IAAI,KAAK,MAAM,QAAQ,IAAI,KAAK,UAAU,OAAO,SAAS,MAAM,CAAC,CAAC;MAC7D,IAAI,KAAK,MAAM,QAAQ,IAAIA,OAAO,OAAO,OAAO,CAAC;MACjD,IAAI,OAAO,SAAS,QAAQ,MAAM,SAAS,OAAO,QAAQ,EAAE,EAAE,IAAI,CAAC;MACnE,QAAQ,IAAI,SAAS,OAAO,QAAQ,EAAE,EAAE,IAAI,CAAC;CAElD,IAAI,OAAO,SAAS,QAAQ,WAAW;AACzC"}
+{"version":3,"file":"output.mjs","names":["toToon"],"sources":["../../src/commands/output.ts"],"sourcesContent":["import { stripVTControlCharacters } from \"node:util\";\nimport { encode as toToon } from \"@toon-format/toon\";\nimport { consola } from \"consola\";\nimport type { ToolResult } from \"../tool-operations.ts\";\n\nexport const formatArgs = {\n  json: { type: \"boolean\" as const, description: \"Output as JSON\" },\n  toon: { type: \"boolean\" as const, description: \"Output as TOON\" },\n};\n\n/**\n * Ends the process once the reader of stdout or stderr is gone, as after\n * `| head -1` or a pager that quits early. Node ignores SIGPIPE, so without a\n * listener the next write throws `EPIPE` with a stack trace. The exit code\n * stays whatever the command set.\n *\n * @param error - The error the stream emitted.\n */\nexport function exitOnClosedPipe(error: Readonly<NodeJS.ErrnoException>): void {\n  if (error.code !== \"EPIPE\") throw error;\n  process.exit();\n}\n\ntype OutputFormat = Readonly<{ json?: boolean; toon?: boolean }>;\n\n/** Control bytes removed from reports because they can echo untrusted configuration values. */\n/* oxlint-disable-next-line no-control-regex */\nconst UNSAFE_TERMINAL_CONTROLS = /[\\u0000-\\u0008\\u000B-\\u001F\\u007F-\\u009F]/g;\nconst UNSAFE_UNICODE_FORMATTING = /[\\p{Cf}\\p{Zl}\\p{Zp}]/gu;\n\n/**\n * Drops terminal sequences, control bytes and Unicode formatting from text meant for a person.\n *\n * @param text - Text that may echo an outside value.\n * @returns {string} The text, safe to print.\n */\nexport function sanitize(text: string | undefined): string {\n  return stripVTControlCharacters(text ?? \"\")\n    .replace(UNSAFE_TERMINAL_CONTROLS, \" \")\n    .replace(UNSAFE_UNICODE_FORMATTING, \" \");\n}\n\n/**\n * Emits one tool result in the selected machine or human format.\n *\n * @param result - Shared executor result to emit.\n * @param args - Selected output format.\n */\nexport function report(result: ToolResult<unknown>, args: OutputFormat): void {\n  if (args.json) console.log(JSON.stringify(result.details, null, 2));\n  else if (args.toon) console.log(toToon(result.details));\n  else if (result.isError) consola.error(sanitize(result.content[0]?.text));\n  else console.log(sanitize(result.content[0]?.text));\n\n  if (result.isError) process.exitCode = 1;\n}\n"],"mappings":";;;;AAKA,MAAa,aAAa;CACxB,MAAM;EAAE,MAAM;EAAoB,aAAa;CAAiB;CAChE,MAAM;EAAE,MAAM;EAAoB,aAAa;CAAiB;AAClE;AAUA,SAAgB,iBAAiB,OAA8C;CAC7E,IAAI,MAAM,SAAS,SAAS,MAAM;CAClC,QAAQ,KAAK;AACf;AAMA,MAAM,2BAA2B;AACjC,MAAM,4BAA4B;AAQlC,SAAgB,SAAS,MAAkC;CACzD,OAAO,yBAAyB,QAAQ,EAAE,CAAC,CACxC,QAAQ,0BAA0B,GAAG,CAAC,CACtC,QAAQ,2BAA2B,GAAG;AAC3C;AAQA,SAAgB,OAAO,QAA6B,MAA0B;CAC5E,IAAI,KAAK,MAAM,QAAQ,IAAI,KAAK,UAAU,OAAO,SAAS,MAAM,CAAC,CAAC;MAC7D,IAAI,KAAK,MAAM,QAAQ,IAAIA,OAAO,OAAO,OAAO,CAAC;MACjD,IAAI,OAAO,SAAS,QAAQ,MAAM,SAAS,OAAO,QAAQ,EAAE,EAAE,IAAI,CAAC;MACnE,QAAQ,IAAI,SAAS,OAAO,QAAQ,EAAE,EAAE,IAAI,CAAC;CAElD,IAAI,OAAO,SAAS,QAAQ,WAAW;AACzC"}

package/dist/_chunks/skills-sync.d.mts

@@ -65,6 +65,8 @@ interface HarnessInvocation {
   readOnlyMinVersion?: string;
   /** Arguments appended when a model is selected; every "{model}" is replaced. */
   modelArgs?: string[];
+  /** Arguments appended when a reasoning effort is selected; every "{effort}" is replaced. */
+  effortArgs?: string[];
   /**
    * Arguments appended to a plain text run so a CLI that holds its answer until
    * the end reports it as events instead; `invoke` folds them back into that text,
@@ -99,6 +101,8 @@ interface HarnessModelListing {
 interface AvailableModel {
   provider: string;
   id: string;
+  /** Display name, where the adapter reads one from the listing; Codex so far. */
+  name?: string;
   /** Absent when the native listing prints only ids, like Grok's. */
   contextWindow?: number;
   maxOutputTokens?: number;
@@ -122,6 +126,8 @@ interface InvokeOptions {
   env?: Record<string, string>;
   /** Harness-native model id or selector. */
   model?: string;
+  /** Reasoning effort in the harness's own words (`low`, `high`, `max`), passed through as is. */
+  effort?: string;
   /** Enable the spawned harness's tools; defaults to advisor without tools mode. */
   tools?: boolean;
   /** Require native enforcement of read-only tool access. Implies `tools: true` when `tools` is omitted; `tools: false` rejects the run. */
@@ -175,10 +181,11 @@ interface McpConfigFile extends PathCandidate {
   key: string[];
   /**
    * Shape of individual entries; "standard" is the {command, args, env, url}
-   * family, "prime" is that family with env values as {"env": "NAME"} references
-   * and "mastracode" is that family read by its keys alone, type ignored.
+   * family, "prime" is that family with env values as {"env": "NAME"} references,
+   * "mastracode" is that family read by its keys alone, type ignored, and "pi"
+   * is that family without sse that keeps the entry fields it doesn't manage.
    */
-  dialect: "standard" | "antigravity" | "mastracode" | "opencode" | "prime" | "vscode";
+  dialect: "standard" | "antigravity" | "mastracode" | "opencode" | "pi" | "prime" | "vscode";
 }
 interface HarnessDetection {
   /** Environment variables that indicate running inside this agent. */
@@ -210,6 +217,7 @@ interface ResolvedPaths {
 //#region src/harness.d.ts
 type InvocationOptions = Readonly<{
   model?: string;
+  effort?: string;
   structured?: boolean;
   tools?: boolean;
   readOnly?: boolean;
@@ -379,6 +387,10 @@ interface McpConfigListing {
 declare class McpEnvError extends Error {
   readonly name = "McpEnvError";
 }
+/** Thrown when the target dialect cannot carry a server's transport. */
+declare class McpTransportError extends Error {
+  readonly name = "McpTransportError";
+}
 /**
  * Lists the MCP servers a harness has configured, per declared config file.
  * Missing files come back with `exists: false`; unparsable ones carry `error`.
@@ -608,5 +620,5 @@ interface SkillsSyncReport {
  */
 declare function syncSkills(harnesses: readonly Harness[], check?: boolean, options?: ResolveOptions): SkillsSyncReport;
 //#endregion
-export { version as $, AvailableModel as A, InvokeResult as B, masterMcpPath as C, syncMcpServers as D, removeMcpServer as E, HarnessId as F, PathCandidate as G, ListModelsResult as H, HarnessInvocation as I, PromptTemplateSyncTarget as J, PathCategory as K, HarnessInvocationModes as L, EvidenceLevel as M, HarnessCapabilities as N, Harness as O, HarnessDetection as P, StorageDescriptor as Q, HarnessModelListing as R, listMcpServers as S, readMasterMcpServers as T, McpConfigFile as U, ListModelsOptions as V, McpServerConfig as W, ResolvedPaths as X, ResolveOptions as Y, SkillsSyncTarget as Z, McpConfigListing as _, PromptSyncAction as a, SyncTargetResult as b, PromptTemplateTargetResult as c, AgentsConfig as d, AgentsSyncAction as f, syncAgentsFiles as g, readAgentsConfig as h, syncSkills as i, EnvOverride as j, HarnessConstructor as k, syncPromptTemplates as l, AgentsTargetResult as m, SkillsSyncReport as n, PromptSyncReport as o, AgentsSyncReport as p, Platform as q, SkillsSyncTargetResult as r, PromptSyncTargetResult as s, SkillsSyncAction as t, AgentsCompanionTargetResult as u, McpEnvError as v, parseJsonc as w, addMcpServer as x, SyncReport as y, InvokeOptions as z };
+export { StorageDescriptor as $, HarnessConstructor as A, InvokeOptions as B, listMcpServers as C, removeMcpServer as D, readMasterMcpServers as E, HarnessDetection as F, McpServerConfig as G, ListModelsOptions as H, HarnessId as I, Platform as J, PathCandidate as K, HarnessInvocation as L, EnvOverride as M, EvidenceLevel as N, syncMcpServers as O, HarnessCapabilities as P, SkillsSyncTarget as Q, HarnessInvocationModes as R, addMcpServer as S, parseJsonc as T, ListModelsResult as U, InvokeResult as V, McpConfigFile as W, ResolveOptions as X, PromptTemplateSyncTarget as Y, ResolvedPaths as Z, McpConfigListing as _, PromptSyncAction as a, SyncReport as b, PromptTemplateTargetResult as c, AgentsConfig as d, version as et, AgentsSyncAction as f, syncAgentsFiles as g, readAgentsConfig as h, syncSkills as i, AvailableModel as j, Harness as k, syncPromptTemplates as l, AgentsTargetResult as m, SkillsSyncReport as n, PromptSyncReport as o, AgentsSyncReport as p, PathCategory as q, SkillsSyncTargetResult as r, PromptSyncTargetResult as s, SkillsSyncAction as t, AgentsCompanionTargetResult as u, McpEnvError as v, masterMcpPath as w, SyncTargetResult as x, McpTransportError as y, HarnessModelListing as z };
 //# sourceMappingURL=skills-sync.d.mts.map

package/dist/_chunks/skills-sync.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"skills-sync.d.mts","names":[],"sources":["../../src/types.ts","../../src/harness.ts","../../src/mcp-servers.ts","../../src/agents-sync.ts","../../src/prompt-sync.ts","../../src/directory-link.ts","../../src/skills-sync.ts"],"mappings":"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"}
+{"version":3,"file":"skills-sync.d.mts","names":[],"sources":["../../src/types.ts","../../src/harness.ts","../../src/mcp-servers.ts","../../src/agents-sync.ts","../../src/prompt-sync.ts","../../src/directory-link.ts","../../src/skills-sync.ts"],"mappings":"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"}

package/dist/_chunks/skills-sync.mjs

@@ -66,6 +66,13 @@ function requestedInvocationMode(options) {
 	if (options.tools === true) return options.structured === true ? "agentStructured" : "agent";
 	return options.structured === true ? "advisorStructured" : "advisor";
 }
+const EFFORT_PATTERN = /^[a-z]+$/u;
+function selectionError(id, invocation, options) {
+	if (options.model !== void 0 && !invocation.modelArgs) return `Harness ${id} does not support model selection`;
+	if (options.effort === void 0) return null;
+	if (!invocation.effortArgs) return `Harness ${id} does not support reasoning effort`;
+	return EFFORT_PATTERN.test(options.effort) ? null : "Reasoning effort must be one lowercase word, such as low or high";
+}
 function accessConflictError(id, invocation, options) {
 	if (options.readOnly !== true || options.tools !== false) return null;
 	const retries = [];
@@ -111,10 +118,24 @@ function compareVersions(a, b) {
 	}
 	return Number(aPre === void 0) - Number(bPre === void 0);
 }
-function buildInvocationArgs(template, prompt, modelArgs, model) {
-	const args = template.map((arg) => arg.replaceAll("{prompt}", () => prompt));
-	if (model !== void 0 && modelArgs) args.push(...modelArgs.map((arg) => arg.replaceAll("{model}", () => model)));
-	return args;
+function readOnlyVersionError(id, invocation, installed) {
+	const floor = invocation?.readOnlyMinVersion;
+	if (floor === void 0) return null;
+	const error = `Harness ${id} requires version ${floor} or newer for read-only runs`;
+	if (installed === null) return `${error}; installed version unknown`;
+	if (compareVersions(installed, floor) < 0) return `${error}; installed ${installed}`;
+	return null;
+}
+function fillArgs(args, placeholder, value) {
+	if (value === void 0 || !args) return [];
+	return args.map((arg) => arg.replaceAll(placeholder, () => value));
+}
+function buildInvocationArgs(template, prompt, invocation, options) {
+	return [
+		...fillArgs(template, "{prompt}", prompt),
+		...fillArgs(invocation.modelArgs, "{model}", options.model),
+		...fillArgs(invocation.effortArgs, "{effort}", options.effort)
+	];
 }
 function signalProcessGroup(pid, signal) {
 	try {
@@ -310,18 +331,19 @@ var Harness = class {
 		if (!this.invocation) return null;
 		const command = this.invocation.binary ?? this.binaries[0];
 		if (!command) return null;
-		if (options.model !== void 0 && !this.invocation.modelArgs) return null;
+		if (selectionError(this.id, this.invocation, options) !== null) return null;
 		if (accessConflictError(this.id, this.invocation, options) !== null) return null;
 		const template = invocationTemplate(this.invocation, requestedInvocationMode(options));
 		if (!template) return null;
 		return {
 			command,
-			args: buildInvocationArgs(template, prompt, this.invocation.modelArgs, options.model)
+			args: buildInvocationArgs(template, prompt, this.invocation, options)
 		};
 	}
 	invocationError(options = {}) {
 		if (!this.invocation) return `Harness ${this.id} has no non-interactive invocation`;
-		if (options.model !== void 0 && !this.invocation.modelArgs) return `Harness ${this.id} does not support model selection`;
+		const unsupported = selectionError(this.id, this.invocation, options);
+		if (unsupported !== null) return unsupported;
 		const conflict = accessConflictError(this.id, this.invocation, options);
 		if (conflict !== null) return conflict;
 		const mode = requestedInvocationMode(options);
@@ -333,6 +355,7 @@ var Harness = class {
 		if (parent) return Promise.reject(/* @__PURE__ */ new Error(`Nested run refused: this process already runs inside ${parent}, started by harnesses. ${this.id} under it would stack agents, and in a read-only sandbox it gets no network and hangs until the deadline. Answer without it`));
 		const invocationOptions = {
 			model: options.model,
+			effort: options.effort,
 			structured: options.structured,
 			tools: options.tools,
 			readOnly: options.readOnly
@@ -359,13 +382,8 @@ var Harness = class {
 		throw new Error(`Harness ${this.id} does not implement stream output folding`);
 	}
 	readOnlyVersionError(options) {
-		const floor = this.invocation?.readOnlyMinVersion;
-		if (floor === void 0 || options.readOnly !== true) return null;
-		const installed = this.version;
-		const error = `Harness ${this.id} requires version ${floor} or newer for read-only runs`;
-		if (installed === null) return `${error}; installed version unknown`;
-		if (compareVersions(installed, floor) < 0) return `${error}; installed ${installed}`;
-		return null;
+		if (this.invocation?.readOnlyMinVersion === void 0 || options.readOnly !== true) return null;
+		return readOnlyVersionError(this.id, this.invocation, this.version);
 	}
 	buildModelListInvocation(search) {
 		if (!this.modelListing) return null;
@@ -851,6 +869,7 @@ var Claude = class extends Harness {
 		],
 		readOnlyMinVersion: "2.1.175",
 		modelArgs: ["--model", "{model}"],
+		effortArgs: ["--effort", "{effort}"],
 		streamArgs: [
 			"--output-format",
 			"stream-json",
@@ -953,6 +972,32 @@ var Claude = class extends Harness {
 };
 //#endregion
 //#region src/harnesses/codex.ts
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function codexModel(entry) {
+	if (!isRecord$1(entry) || typeof entry["slug"] !== "string") throw new Error(`Unexpected Codex model-list entry: ${JSON.stringify(entry)?.slice(0, 200)}`);
+	if (entry["visibility"] !== "list") return void 0;
+	const { display_name: name, context_window: contextWindow, supported_reasoning_levels: levels, input_modalities: input } = entry;
+	return {
+		provider: "openai",
+		id: entry["slug"],
+		...typeof name === "string" ? { name } : {},
+		...typeof contextWindow === "number" ? { contextWindow } : {},
+		...Array.isArray(levels) ? { thinking: levels.length > 0 } : {},
+		...Array.isArray(input) ? { images: input.includes("image") } : {}
+	};
+}
+function parseCodexModels(stdout) {
+	let parsed;
+	try {
+		parsed = JSON.parse(stdout);
+	} catch {
+		throw new Error(`Unexpected Codex model-list output: ${JSON.stringify(stdout.slice(0, 200))}`);
+	}
+	if (!isRecord$1(parsed) || !Array.isArray(parsed["models"])) throw new Error(`Unexpected Codex model-list output: ${JSON.stringify(stdout.slice(0, 200))}`);
+	return parsed["models"].flatMap((entry) => codexModel(entry) ?? []);
+}
 var Codex = class extends Harness {
 	id = "codex";
 	name = "OpenAI Codex CLI";
@@ -1122,9 +1167,15 @@ var Codex = class extends Harness {
 			"{prompt}"
 		],
 		modelArgs: ["--model", "{model}"],
+		effortArgs: ["-c", "model_reasoning_effort={effort}"],
 		level: "official",
 		note: "Non-interactive exec subcommand; add --json for structured output."
 	};
+	modelListing = {
+		args: ["debug", "models"],
+		level: "official",
+		note: "Prints the model catalog as JSON, refreshed from OpenAI unless --bundled, with no filter of its own; only models Codex shows in its picker are kept. It lives under debug, so the shape can move between releases; verified with 0.160.0."
+	};
 	mcpConfigs = [{
 		path: "~/.codex/config.toml",
 		scope: "user",
@@ -1164,6 +1215,12 @@ var Codex = class extends Harness {
 			".agents/skills"
 		]
 	};
+	modelSelector(model) {
+		return model.id;
+	}
+	parseModelListingOutput(stdout) {
+		return parseCodexModels(stdout);
+	}
 };
 //#endregion
 //#region src/harnesses/cursor.ts
@@ -1746,6 +1803,7 @@ var Grok = class extends Harness {
 		],
 		readOnlyMinVersion: "1.0.13",
 		modelArgs: ["--model", "{model}"],
+		effortArgs: ["--reasoning-effort", "{effort}"],
 		level: "official",
 		note: "-p is short for --single; add --output-format json for structured output. --sandbox read-only is kernel-enforced (Landlock, Seatbelt) regardless of the inherited permission mode and still allows writes to ~/.grok and temp dirs; verified on Linux with 1.0.13 and 1.0.25."
 	};
@@ -2036,6 +2094,30 @@ var MastraCode = class extends Harness {
 };
 //#endregion
 //#region src/harnesses/omp.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseOmpModels(stdout) {
+	let parsed;
+	try {
+		parsed = JSON.parse(stdout);
+	} catch {
+		throw new Error(`Unexpected OMP model-list output: ${JSON.stringify(stdout.slice(0, 200))}`);
+	}
+	if (!isRecord(parsed) || !Array.isArray(parsed["models"])) throw new Error(`Unexpected OMP model-list output: ${JSON.stringify(stdout.slice(0, 200))}`);
+	return parsed["models"].map((entry) => {
+		if (!isRecord(entry) || typeof entry["provider"] !== "string" || typeof entry["id"] !== "string") throw new Error(`Unexpected OMP model-list entry: ${JSON.stringify(entry)}`);
+		const { contextWindow, maxTokens, reasoning, input } = entry;
+		return {
+			provider: entry["provider"],
+			id: entry["id"],
+			...typeof contextWindow === "number" ? { contextWindow } : {},
+			...typeof maxTokens === "number" ? { maxOutputTokens: maxTokens } : {},
+			...typeof reasoning === "boolean" ? { thinking: reasoning } : {},
+			...Array.isArray(input) ? { images: input.includes("image") } : {}
+		};
+	});
+}
 var Omp = class extends Harness {
 	id = "omp";
 	name = "OMP (oh-my-pi)";
@@ -2222,9 +2304,31 @@ var Omp = class extends Harness {
 			"{prompt}"
 		],
 		modelArgs: ["--model={model}"],
+		effortArgs: ["--thinking={effort}"],
 		level: "official",
 		note: "Add --mode json for structured event output. --no-tools disables only OMP's bundled tools, so it cannot provide an advisor mode without tools."
 	};
+	modelListing = {
+		args: [
+			"models",
+			"--json",
+			"--kind",
+			"chat",
+			"--no-extensions"
+		],
+		searchArgs: [
+			"models",
+			"find",
+			"--json",
+			"--kind",
+			"chat",
+			"--no-extensions",
+			"--",
+			"{search}"
+		],
+		level: "official",
+		note: "Lists chat models with configured provider authentication as JSON; find matches a substring of the provider, id or name, ignoring case. --no-extensions keeps extension load errors out of the run; verified with 18.4.10."
+	};
 	mcpConfigs = [{
 		path: "~/.omp/agent/mcp.json",
 		scope: "user",
@@ -2260,6 +2364,9 @@ var Omp = class extends Harness {
 		envVars: ["OMP_PROFILE", "PI_CODING_AGENT_DIR"],
 		projectMarkers: [".omp"]
 	};
+	parseModelListingOutput(stdout) {
+		return parseOmpModels(stdout);
+	}
 };
 //#endregion
 //#region src/harnesses/opencode.ts
@@ -2610,6 +2717,7 @@ var Pi = class extends Harness {
 			"{prompt}"
 		],
 		modelArgs: ["--model", "{model}"],
+		effortArgs: ["--thinking", "{effort}"],
 		level: "official",
 		note: "Add --mode json for structured event output."
 	};
@@ -2619,6 +2727,23 @@ var Pi = class extends Harness {
 		level: "official",
 		note: "Lists models with configured provider authentication; accepts an optional fuzzy search."
 	};
+	mcpConfigs = [{
+		path: "~/.pi/agent/mcp.json",
+		scope: "user",
+		level: "official",
+		format: "json",
+		key: ["mcpServers"],
+		dialect: "pi",
+		note: "Read by the built-in MCP extension, which -builtin:mcp in the extensions setting turns off."
+	}, {
+		path: ".pi/mcp.json",
+		scope: "project",
+		level: "official",
+		format: "json",
+		key: ["mcpServers"],
+		dialect: "pi",
+		note: "Read only after the project is trusted."
+	}];
 	envOverrides = [{
 		variable: "PI_CODING_AGENT_DIR",
 		path: "~/.pi/agent",
@@ -2999,6 +3124,9 @@ const ENV_REFERENCE = /^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/;
 var McpEnvError = class extends Error {
 	name = "McpEnvError";
 };
+var McpTransportError = class extends Error {
+	name = "McpTransportError";
+};
 function envReference(value) {
 	return ENV_REFERENCE.exec(value)?.[1];
 }
@@ -3114,6 +3242,7 @@ function resolveEnvReferences(server, dialect) {
 }
 function shapeForDialect(server, dialect) {
 	const shaped = resolveEnvReferences(server, dialect);
+	if (dialect === "pi" && shaped.transport === "sse") throw new McpTransportError(`${server.name}: Pi takes stdio and streamable HTTP servers, not sse; point url at the server's streamable HTTP endpoint`);
 	if (dialect !== "mastracode") return shaped;
 	return compact({
 		...shaped,
@@ -3128,6 +3257,26 @@ function denormalizeEntry(server, dialect) {
 	if (dialect === "prime") return denormalizePrime(server);
 	return denormalizeStandard(server);
 }
+const STANDARD_FIELDS = /* @__PURE__ */ new Set([
+	"type",
+	"command",
+	"args",
+	"env",
+	"url",
+	"httpUrl",
+	"headers",
+	"enabled"
+]);
+function replacementEntry(previous, server, dialect) {
+	const entry = denormalizeEntry(server, dialect);
+	if (dialect !== "pi" || !isObjectRecord(previous)) return entry;
+	if (normalizeStandard(server.name, previous).transport !== server.transport) return entry;
+	const kept = Object.entries(previous).filter(([key]) => !STANDARD_FIELDS.has(key));
+	return {
+		...entry,
+		...Object.fromEntries(kept)
+	};
+}
 function listingBase(entry, path) {
 	return compact({
 		path,
@@ -3268,7 +3417,7 @@ function addMcpServer(harness, server, scope = "user", options = {}) {
 	const map = drill(root, entry.key, "create");
 	if (!map) throw new Error(`Config at ${path} has a non-object at ${entry.key.join(".")}`);
 	const replaced = Object.hasOwn(map, server.name);
-	map[server.name] = denormalizeEntry(resolved, entry.dialect);
+	map[server.name] = replacementEntry(map[server.name], resolved, entry.dialect);
 	writeAtomically(path, `${JSON.stringify(root, null, 2)}\n`);
 	return {
 		path,
@@ -3474,6 +3623,9 @@ function withdrawMasterServersFromExcludedHarness(harness, existing, masterNames
 		results
 	};
 }
+function cannotHold(error) {
+	return error instanceof McpEnvError || error instanceof McpTransportError;
+}
 function syncIncludedHarness(harness, master, existing, masterNames, initialPath, options) {
 	const results = [];
 	let path = initialPath;
@@ -3494,7 +3646,7 @@ function syncIncludedHarness(harness, master, existing, masterNames, initialPath
 			action: written.replaced ? "replaced" : "added"
 		});
 	} catch (error) {
-		if (!(error instanceof McpEnvError)) throw error;
+		if (!cannotHold(error)) throw error;
 		results.push({
 			name: server.name,
 			action: "skipped",
@@ -4149,6 +4301,6 @@ function syncSkills(harnesses, check = false, options = {}) {
 	};
 }
 //#endregion
-export { agntnDataDir as C, agntnConfigDir as S, getHarness as _, McpEnvError as a, registerHarness as b, masterMcpPath as c, removeMcpServer as d, syncMcpServers as f, getAllHarnesses as g, detectProjectHarnesses as h, syncAgentsFiles as i, parseJsonc as l, detectHarnessFromEnv as m, syncPromptTemplates as n, addMcpServer as o, detectHarness as p, readAgentsConfig as r, listMcpServers as s, syncSkills as t, readMasterMcpServers as u, isHarnessId as v, resolvePathTemplate as w, Harness as x, listHarnesses as y };
+export { readOnlyVersionError as C, resolvePathTemplate as D, agntnDataDir as E, Harness as S, agntnConfigDir as T, getAllHarnesses as _, McpEnvError as a, listHarnesses as b, listMcpServers as c, readMasterMcpServers as d, removeMcpServer as f, detectProjectHarnesses as g, detectHarnessFromEnv as h, syncAgentsFiles as i, masterMcpPath as l, detectHarness as m, syncPromptTemplates as n, McpTransportError as o, syncMcpServers as p, readAgentsConfig as r, addMcpServer as s, syncSkills as t, parseJsonc as u, getHarness as v, selectionError as w, registerHarness as x, isHarnessId as y };
 
 //# sourceMappingURL=skills-sync.mjs.map