@agntn/harnesses 0.1.0 → 0.1.1

package/README.md

@@ -55,20 +55,21 @@ import type { ClaudeSessionEntry, CodexThread, GeminiConversationRecord } from "
 
 ## Supported agents
 
-| Agent           | ID               | Detection     | Skills                | Hooks                    | Sessions       |
-| --------------- | ---------------- | ------------- | --------------------- | ------------------------ | -------------- |
-| Antigravity CLI | `antigravity`    | project       | `.agents/skills/`     | -                        | JSONL + SQLite |
-| Claude Code     | `claude`         | env + project | `.claude/skills/`     | `.claude/hooks/`         | JSONL          |
-| Codex CLI       | `codex`          | project       | `.agents/skills/`     | -                        | SQLite + JSONL |
-| Gemini CLI      | `gemini`         | env + project | `.gemini/skills/`     | -                        | JSON           |
-| Grok CLI        | `grok`           | env + project | `.grok/skills/`       | `.grok/hooks/`           | TOML + JSONL   |
-| OpenCode        | `opencode`       | project       | `.opencode/skills/`   | -                        | SQLite         |
-| Cursor          | `cursor`         | env + project | `.cursor/skills/`     | -                        | -              |
-| GitHub Copilot  | `github-copilot` | env + project | `.github/skills/`     | -                        | -              |
-| Mastra Code     | `mastracode`     | project       | `.mastracode/skills/` | `.mastracode/hooks.json` | SQLite         |
-| OMP (oh-my-pi)  | `omp`            | env + project | `.omp/skills/`        | -                        | JSONL + SQLite |
-| Pi Coding Agent | `pi`             | env + project | `.pi/skills/`         | -                        | JSON + JSONL   |
-| Freebuff        | `freebuff`       | project       | `.agents/skills/`     | -                        | JSON + JSONL   |
+| Agent           | ID               | Detection     | Skills                 | Hooks                    | Sessions       |
+| --------------- | ---------------- | ------------- | ---------------------- | ------------------------ | -------------- |
+| Antigravity CLI | `antigravity`    | project       | `.agents/skills/`      | -                        | JSONL + SQLite |
+| Claude Code     | `claude`         | env + project | `.claude/skills/`      | `.claude/hooks/`         | JSONL          |
+| Codex CLI       | `codex`          | project       | `.agents/skills/`      | -                        | SQLite + JSONL |
+| Gemini CLI      | `gemini`         | env + project | `.gemini/skills/`      | -                        | JSON           |
+| Grok CLI        | `grok`           | env + project | `.grok/skills/`        | `.grok/hooks/`           | TOML + JSONL   |
+| OpenCode        | `opencode`       | project       | `.opencode/skills/`    | -                        | SQLite         |
+| Cursor          | `cursor`         | env + project | `.cursor/skills/`      | -                        | -              |
+| GitHub Copilot  | `github-copilot` | env + project | `.github/skills/`      | -                        | -              |
+| Mastra Code     | `mastracode`     | project       | `.mastracode/skills/`  | `.mastracode/hooks.json` | SQLite         |
+| OMP (oh-my-pi)  | `omp`            | env + project | `.omp/skills/`         | -                        | JSONL + SQLite |
+| Pi Coding Agent | `pi`             | env + project | `.pi/skills/`          | -                        | JSON + JSONL   |
+| Prime Agent     | `prime-agent`    | env + project | `.prime/agent/skills/` | -                        | JSONL + JSON   |
+| Freebuff        | `freebuff`       | project       | `.agents/skills/`      | -                        | JSON + JSONL   |
 
 ### Native audio and video input
 
@@ -87,6 +88,7 @@ import type { ClaudeSessionEntry, CodexThread, GeminiConversationRecord } from "
 | Mastra Code     |  No   |  No   | No verified native route                                                    |
 | OMP (oh-my-pi)  |  No   |  No   | No verified native route                                                    |
 | Pi Coding Agent |  No   |  No   | No verified native route                                                    |
+| Prime Agent     |  No   |  No   | No verified native route                                                    |
 | Freebuff        |  No   |  No   | No verified native route                                                    |
 
 Primary references: [Antigravity prompting](https://antigravity.google/docs/cli/prompting/), [Antigravity changelog](https://github.com/google-antigravity/antigravity-cli/blob/main/CHANGELOG.md), [Gemini CLI tools](https://github.com/google-gemini/gemini-cli/blob/main/docs/reference/tools.md), [Gemini CLI video request](https://github.com/google-gemini/gemini-cli/issues/27194), [OpenCode attachments](https://opencode.ai/v2/docs/attachments/), [Cursor prompting](https://cursor.com/docs/agent/prompting), and [Copilot CLI voice input](https://docs.github.com/en/copilot/how-tos/copilot-cli/use-copilot-cli/voice-input).
@@ -109,7 +111,7 @@ console.log(result.aborted);
 
 This is command cleanup, not a sandbox. Descendants that leave the POSIX process group, or outlive an already exited root on Windows, cannot be reliably reached by these mechanisms. Inherited output pipes do not extend the wait after cleanup. Scheduling and OS delays can exceed the stated budgets.
 
-Each agent is a concrete subclass of the abstract `Harness` class. Custom subclasses can be added with `registerHarness`. Every harness exposes config paths, session locations, instruction files, skills dirs, hooks, commands, persistence formats, capabilities (MCP, vision, audio, video, tools, streaming), detection rules, a normalized non-interactive invocation (`harness.invoke(prompt, { model })`) where the CLI has a headless mode, native model listing (`harness.listModels()`) where the CLI supports it, and its MCP server config files (`listMcpServers`/`addMcpServer`/`removeMcpServer` normalize the dialects; writes rewrite JSON and surgically edit TOML with comments preserved). `syncMcpServers` treats `~/.config/agntn/mcp.jsonc` (JSONC, XDG-aware) as the single source of truth and resets every harness's user-scope MCP config to exactly that list; a top-level `"excludes": ["codex"]` array opts individual harnesses out of the sync (their own servers stay, master-listed names are withdrawn), and `~`/`${HOME}` in commands, args, and env values expand to absolute paths at sync time (harnesses spawn MCP servers without a shell). `syncAgentsFiles` links every harness's global instructions file (CLAUDE.md/AGENTS.md/GEMINI.md) to one master file as symlinks, so an edit made through any harness lands in the single physical copy; `~/.config/agntn/agents.jsonc` sets the `source`, `companions`, and `excludes`, diverged regular files are backed up and relinked, and check mode reports without writing. Companion paths are relative to the source directory and are linked at the same relative path beside each harness target.
+Each agent is a concrete subclass of the abstract `Harness` class. Custom subclasses can be added with `registerHarness`. Every harness exposes config paths, session locations, instruction files, skills dirs, hooks, commands, persistence formats, capabilities (MCP, vision, audio, video, tools, streaming), detection rules, a normalized non-interactive invocation (`harness.invoke(prompt, { model })`) where the CLI has a headless mode, native model listing (`harness.listModels()`) where the CLI supports it, and its MCP server config files (`listMcpServers`/`addMcpServer`/`removeMcpServer` normalize the dialects; writes rewrite JSON and surgically edit TOML with comments preserved). `syncMcpServers` treats `~/.config/agntn/mcp.jsonc` (JSONC, XDG-aware) as the single source of truth and resets every harness's user-scope MCP config to exactly that list; a top-level `"excludes": ["codex"]` array opts individual harnesses out of the sync (their own servers stay, master-listed names are withdrawn), and `~`/`${HOME}` in commands, args, and env values expand to absolute paths at sync time (harnesses spawn MCP servers without a shell). An env value that is exactly `${NAME}` references that variable of the harness environment: Prime Agent stores it natively as `{"env": "NAME"}`, the other harnesses receive the value from the syncing process, and a server one dialect cannot hold is reported as `skipped` with a reason while the rest of the list syncs. `syncAgentsFiles` links every harness's global instructions file (CLAUDE.md/AGENTS.md/GEMINI.md) to one master file as symlinks, so an edit made through any harness lands in the single physical copy; `~/.config/agntn/agents.jsonc` sets the `source`, `companions`, and `excludes`, diverged regular files are backed up and relinked, and check mode reports without writing. Companion paths are relative to the source directory and are linked at the same relative path beside each harness target.
 
 ```jsonc
 {
@@ -121,7 +123,7 @@ Each agent is a concrete subclass of the abstract `Harness` class. Custom subcla
 
 All paths carry `scope` (user/project/system/data), `level` (official/community/inferred), and optional `platforms` tags.
 
-The `harnesses_info` agent tool accepts one harness id or a batch of up to 20 ids. Batch results keep the input order and include errors for unknown ids beside successful metadata.
+The `harnesses_info` agent tool accepts one harness id or a batch of up to 20 ids. Batch results keep the input order and include errors for unknown ids beside successful metadata. Paths come once, resolved for the current platform. The templates stay with `harnesses info`.
 
 ## CLI
 
@@ -151,7 +153,7 @@ harnesses mcp                   # run the MCP server over stdio
 
 [unagent](https://github.com/onmax/unagent) covers similar ground but makes different tradeoffs.
 
-**harnesses is deep and narrow.** Each harness gets verified, platform-specific paths with scope, evidence level, and platform tags. Session formats are typed per harness. Twelve harnesses, each fully mapped.
+**harnesses is deep and narrow.** Each harness gets verified, platform-specific paths with scope, evidence level, and platform tags. Session formats are typed per harness. Thirteen harnesses, each fully mapped.
 
 **unagent is wide and shallow.** 40+ agents detected by env vars, but each definition is just `configDir` + `rulesFile` + `skillsDir`. No platform-specific paths, no session schemas. In exchange, it ships runtime primitives harnesses doesn't touch yet: skill install/uninstall, vector stores, browser automation, sandboxes, queues, workflows.
 

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

@@ -1,5 +1,5 @@
 declare const version: string;
-type HarnessId = "antigravity" | "codex" | "gemini" | "grok" | "claude" | "opencode" | "cursor" | "freebuff" | "github-copilot" | "mastracode" | "omp" | "pi";
+type HarnessId = "antigravity" | "codex" | "gemini" | "grok" | "claude" | "opencode" | "cursor" | "freebuff" | "github-copilot" | "mastracode" | "omp" | "pi" | "prime-agent";
 type EvidenceLevel = "official" | "community" | "inferred";
 type Platform = "linux" | "darwin" | "win32";
 interface PathCandidate {
@@ -122,6 +122,11 @@ interface McpServerConfig {
   transport: "stdio" | "http" | "sse";
   command?: string;
   args?: string[];
+  /**
+   * Environment for stdio servers. A value that is exactly "${NAME}" refers to
+   * the variable NAME of the harness environment: dialects with native
+   * references keep it, the others resolve it when the entry is written.
+   */
   env?: Record<string, string>;
   url?: string;
   headers?: Record<string, string>;
@@ -133,8 +138,11 @@ interface McpConfigFile extends PathCandidate {
   format: "json" | "toml";
   /** Object path to the server map inside the file, e.g. ["mcpServers"]. */
   key: string[];
-  /** Shape of individual entries; "standard" is the {command, args, env, url} family. */
-  dialect: "standard" | "antigravity" | "opencode" | "vscode";
+  /**
+   * Shape of individual entries; "standard" is the {command, args, env, url}
+   * family and "prime" is that family with env values as {"env": "NAME"} references.
+   */
+  dialect: "standard" | "antigravity" | "opencode" | "prime" | "vscode";
 }
 interface HarnessDetection {
   /** Environment variables that indicate running inside this agent. */
@@ -284,6 +292,10 @@ interface McpConfigListing {
   /** Set when the file exists but could not be parsed. */
   error?: string;
 }
+/** Thrown when a server's env cannot be written the way the target dialect requires. */
+declare class McpEnvError extends Error {
+  readonly name = "McpEnvError";
+}
 /**
  * Lists the MCP servers a harness has configured, per declared config file.
  * Missing files come back with `exists: false`; unparsable ones carry `error`.
@@ -346,7 +358,9 @@ interface SyncTargetResult {
   excluded?: true;
   results: Array<{
     name: string;
-    action: "added" | "replaced" | "removed" | "unchanged";
+    action: "added" | "replaced" | "removed" | "unchanged" | "skipped";
+    /** Why a master server could not be written to this harness. */
+    reason?: string;
   }>;
 }
 /** Outcome of resetting the harness configs to the master list. */
@@ -430,5 +444,5 @@ declare function readAgentsConfig(options?: ResolveOptions): AgentsConfig;
  * @returns {AgentsSyncReport} Per-harness synchronization outcomes.
  */
 declare function syncAgentsFiles(harnesses: readonly Harness[], check?: boolean, options?: ResolveOptions): AgentsSyncReport;
-export { AgentsCompanionTargetResult, AgentsConfig, AgentsSyncAction, AgentsSyncReport, AgentsTargetResult, AvailableModel, EvidenceLevel, Harness, HarnessCapabilities, HarnessConstructor, HarnessDetection, HarnessId, HarnessInvocation, HarnessInvocationModes, HarnessModelListing, InvokeOptions, InvokeResult, ListModelsOptions, ListModelsResult, McpConfigFile, McpConfigListing, McpServerConfig, PathCandidate, Platform, ResolveOptions, ResolvedPaths, StorageDescriptor, SyncReport, SyncTargetResult, addMcpServer, listMcpServers, masterMcpPath, parseJsonc, readAgentsConfig, readMasterMcpServers, removeMcpServer, syncAgentsFiles, syncMcpServers, version };
+export { AgentsCompanionTargetResult, AgentsConfig, AgentsSyncAction, AgentsSyncReport, AgentsTargetResult, AvailableModel, EvidenceLevel, Harness, HarnessCapabilities, HarnessConstructor, HarnessDetection, HarnessId, HarnessInvocation, HarnessInvocationModes, HarnessModelListing, InvokeOptions, InvokeResult, ListModelsOptions, ListModelsResult, McpConfigFile, McpConfigListing, McpEnvError, McpServerConfig, PathCandidate, Platform, ResolveOptions, ResolvedPaths, StorageDescriptor, SyncReport, SyncTargetResult, addMcpServer, listMcpServers, masterMcpPath, parseJsonc, readAgentsConfig, readMasterMcpServers, removeMcpServer, syncAgentsFiles, syncMcpServers, version };
 //# sourceMappingURL=agents-sync.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"agents-sync.d.mts","names":[],"sources":["../../src/types.ts","../../src/harness.ts","../../src/mcp-servers.ts","../../src/agents-sync.ts"],"mappings":"AAEA,cAAa;KAED;KAaA;KACA;UAEK;EACf;EACA;EACA,OAAO;EACP,YAAY;EACZ;;UAGe;EACf;EACA,OAAO;EACP;;UAGe;EACf;EACA;;EAEA;;EAEA;EACA;EACA;;;UAIe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA,OAAO;EACP;;;UAIe;EACf;EACA;EACA;EACA;EACA;EACA;;;UAIe;;EAEf;;EAEA;EACA,OAAO;EACP;;;UAIe;EACf;EACA;EACA;EACA;EACA;EACA;;;UAIe;EACf;EACA;EACA,MAAM;;EAEN;;EAEA,SAAS;;UAGM;EACf;EACA,MAAM;;EAEN;;EAEA;;EAEA;;EAEA;;EAEA,SAAS;;EAET;;UAGe;EACf;EACA;EACA;EACA;;EAEA;EACA;;EAEA;;;UAIe,yBAAyB;;EAExC,QAAQ;;;UAIO;EACf;EACA;EACA;EACA;EACA,MAAM;EACN;EACA,UAAU;;EAEV;;;UAIe,sBAAsB;EACrC;;EAEA;;EAEA;;UAGe;;EAEf;;EAEA;;UAGe;EACf;EACA;EACA,WAAW;;UAGI;EACf,QAAQ;EACR,UAAU;EACV,cAAc;EACd,QAAQ;EACR,UAAU;EACV,OAAO;;KCnJJ,oBAAoB;EACvB;EACA;EACA;EACA;;uBA2OoB;oBACF,IAAI;oBACJ;oBACA;oBACA,QAAQ;oBACR,UAAU;oBACV,aAAa;oBACb,cAAc;oBACd,QAAQ;oBACR,UAAU;oBACV,OAAO;oBACP,cAAc;oBACd,WAAW;;oBAEX,YAAY;;WAErB,cAAc;;WAEd,YAAY;;;;;;WAMZ;EAET;EAYA;EAIA,cAAc;MAKV;;;;;;MAsBA,mBAAmB;;;;;;;;;;EAoBvB,gBACE,gBACA,UAAS;IACN;IAAiB;;;;;;;;EAmBtB,gBAAgB,UAAS;;;;;;;;;;EAqBzB,OAAO,gBAAgB,UAAS,gBAAqB,QAAQ;;;;;;;;;UA2BrD;;;;;;;EAgBR,yBAAyB;IAAoB;IAAiB;;;;;;;;;EAmBxD,WAAW,UAAS,oBAAyB,QAAQ;;;;;;YAyBjD,wBAAwB,kBAAkB;;;;;;;;;;EAapD,kBAAkB,UAAU,eAC1B,kBAAkB,KAClB,UAAS,iBACR;EAcH,QAAQ,UAAS,iBAAsB;;KAY7B,+BAA+B;;UCxgB1B;EACf;EACA,OAAO;EACP,QAAQ;EACR,OAAO;EACP;EACA;EACA,SAAS;;EAET;;;;;;;;;;iBAmRc,eAAe,SAAS,SAAS,UAAS,iBAAsB;;;;;;;;;;;;iBAiLhE,aACd,SAAS,SACT,QAAQ,iBACR,4BACA,UAAS;EACN;EAAc;;;;;;;;;;;iBA0BH,gBACd,SAAS,SACT,cACA,4BACA,UAAS;EACN;EAAc;;;;;;;;;iBA8FH,WAAW;;;;;;;iBAwBX,cAAc,UAAS;;UAKtB;EACf;EACA;;EAEA;;EAEA;EACA,SAAS;IAAQ;IAAc;;;;UAIhB;EACf;EACA;EACA,SAAS;;;;;;;;iBAuEK,qBAAqB,UAAS;EAC5C;EACA,SAAS;;EAET;;;;;;;;;;;iBA2Hc,eACd,oBAAoB,WACpB,UAAS,iBACR;;UC1zBc;;EAEf;;EAEA;;EAEA;;EAEA;;KAGU;;UAGK;WACN;WACA;WACA,QAAQ,QAAQ;;WAEhB;;;UAIM;EACf;EACA;EACA,QAAQ;;EAER;;EAEA,sBAAsB;;;UAIP;EACf;EACA;EACA,SAAS;;;;;;;;iBA2FK,iBAAiB,UAAS,iBAAsB;;;;;;;;;;iBAiMhD,gBACd,oBAAoB,WACpB,iBACA,UAAS,iBACR"}
+{"version":3,"file":"agents-sync.d.mts","names":[],"sources":["../../src/types.ts","../../src/harness.ts","../../src/mcp-servers.ts","../../src/agents-sync.ts"],"mappings":"AAEA,cAAa;KAED;KAcA;KACA;UAEK;EACf;EACA;EACA,OAAO;EACP,YAAY;EACZ;;UAGe;EACf;EACA,OAAO;EACP;;UAGe;EACf;EACA;;EAEA;;EAEA;EACA;EACA;;;UAIe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA,OAAO;EACP;;;UAIe;EACf;EACA;EACA;EACA;EACA;EACA;;;UAIe;;EAEf;;EAEA;EACA,OAAO;EACP;;;UAIe;EACf;EACA;EACA;EACA;EACA;EACA;;;UAIe;EACf;EACA;EACA,MAAM;;EAEN;;EAEA,SAAS;;UAGM;EACf;EACA,MAAM;;EAEN;;EAEA;;EAEA;;EAEA;;EAEA,SAAS;;EAET;;UAGe;EACf;EACA;EACA;EACA;;EAEA;EACA;;EAEA;;;UAIe,yBAAyB;;EAExC,QAAQ;;;UAIO;EACf;EACA;EACA;EACA;;;;;;EAMA,MAAM;EACN;EACA,UAAU;;EAEV;;;UAIe,sBAAsB;EACrC;;EAEA;;;;;EAKA;;UAGe;;EAEf;;EAEA;;UAGe;EACf;EACA;EACA,WAAW;;UAGI;EACf,QAAQ;EACR,UAAU;EACV,cAAc;EACd,QAAQ;EACR,UAAU;EACV,OAAO;;KC5JJ,oBAAoB;EACvB;EACA;EACA;EACA;;uBA2OoB;oBACF,IAAI;oBACJ;oBACA;oBACA,QAAQ;oBACR,UAAU;oBACV,aAAa;oBACb,cAAc;oBACd,QAAQ;oBACR,UAAU;oBACV,OAAO;oBACP,cAAc;oBACd,WAAW;;oBAEX,YAAY;;WAErB,cAAc;;WAEd,YAAY;;;;;;WAMZ;EAET;EAYA;EAIA,cAAc;MAKV;;;;;;MAsBA,mBAAmB;;;;;;;;;;EAoBvB,gBACE,gBACA,UAAS;IACN;IAAiB;;;;;;;;EAmBtB,gBAAgB,UAAS;;;;;;;;;;EAqBzB,OAAO,gBAAgB,UAAS,gBAAqB,QAAQ;;;;;;;;;UA2BrD;;;;;;;EAgBR,yBAAyB;IAAoB;IAAiB;;;;;;;;;EAmBxD,WAAW,UAAS,oBAAyB,QAAQ;;;;;;YAyBjD,wBAAwB,kBAAkB;;;;;;;;;;EAapD,kBAAkB,UAAU,eAC1B,kBAAkB,KAClB,UAAS,iBACR;EAcH,QAAQ,UAAS,iBAAsB;;KAY7B,+BAA+B;;UCxgB1B;EACf;EACA,OAAO;EACP,QAAQ;EACR,OAAO;EACP;EACA;EACA,SAAS;;EAET;;;cA2JW,oBAAoB;WACb;;;;;;;;;;iBAkOJ,eAAe,SAAS,SAAS,UAAS,iBAAsB;;;;;;;;;;;;iBAiLhE,aACd,SAAS,SACT,QAAQ,iBACR,4BACA,UAAS;EACN;EAAc;;;;;;;;;;;iBA2BH,gBACd,SAAS,SACT,cACA,4BACA,UAAS;EACN;EAAc;;;;;;;;;iBA8FH,WAAW;;;;;;;iBAwBX,cAAc,UAAS;;UAKtB;EACf;EACA;;EAEA;;EAEA;EACA,SAAS;IACP;IACA;;IAEA;;;;UAKa;EACf;EACA;EACA,SAAS;;;;;;;;iBAuEK,qBAAqB,UAAS;EAC5C;EACA,SAAS;;EAET;;;;;;;;;;;iBAmIc,eACd,oBAAoB,WACpB,UAAS,iBACR;;UCn7Bc;;EAEf;;EAEA;;EAEA;;EAEA;;KAGU;;UAGK;WACN;WACA;WACA,QAAQ,QAAQ;;WAEhB;;;UAIM;EACf;EACA;EACA,QAAQ;;EAER;;EAEA,sBAAsB;;;UAIP;EACf;EACA;EACA,SAAS;;;;;;;;iBA2FK,iBAAiB,UAAS,iBAAsB;;;;;;;;;;iBAiMhD,gBACd,oBAAoB,WACpB,iBACA,UAAS,iBACR"}

package/dist/_chunks/agents-sync.mjs

@@ -1896,16 +1896,37 @@ const MODEL_HEADERS = [
 	"thinking",
 	"images"
 ];
-function parseTokenCount(value) {
+function parseTokenCount(value, harness) {
 	const match = /^(\d+(?:\.\d+)?)([KM])?$/.exec(value);
-	if (!match?.[1]) throw new Error(`Invalid Pi token count: ${JSON.stringify(value)}`);
+	if (!match?.[1]) throw new Error(`Invalid ${harness} token count: ${JSON.stringify(value)}`);
 	const multiplier = match[2] === "M" ? 1e6 : match[2] === "K" ? 1e3 : 1;
 	return Number(match[1]) * multiplier;
 }
-function parseBoolean(value, column) {
+function parseBoolean(value, column, harness) {
 	if (value === "yes") return true;
 	if (value === "no") return false;
-	throw new Error(`Invalid Pi ${column} value: ${JSON.stringify(value)}`);
+	throw new Error(`Invalid ${harness} ${column} value: ${JSON.stringify(value)}`);
+}
+function parsePiModelTable(stdout, harness) {
+	const lines = stripVTControlCharacters(stdout).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+	const first = lines[0];
+	if (!first) throw new Error(`Unexpected empty ${harness} model-list output`);
+	if (first.startsWith("No models available.") || first.startsWith("No models matching ")) return [];
+	const headers = first.split(/\s{2,}/);
+	if (headers.length !== MODEL_HEADERS.length || headers.some((value, i) => value !== MODEL_HEADERS[i])) throw new Error(`Unexpected ${harness} model-list header: ${JSON.stringify(first)}`);
+	return lines.slice(1).map((line) => {
+		const columns = line.split(/\s{2,}/);
+		const [provider, id, context, maxOutput, thinking, images] = columns;
+		if (columns.length !== MODEL_HEADERS.length || !provider || !id || !context || !maxOutput || !thinking || !images) throw new Error(`Unexpected ${harness} model-list row: ${JSON.stringify(line)}`);
+		return {
+			provider,
+			id,
+			contextWindow: parseTokenCount(context, harness),
+			maxOutputTokens: parseTokenCount(maxOutput, harness),
+			thinking: parseBoolean(thinking, "thinking", harness),
+			images: parseBoolean(images, "images", harness)
+		};
+	});
 }
 var Pi = class extends Harness {
 	id = "pi";
@@ -2046,25 +2067,172 @@ var Pi = class extends Harness {
 		projectMarkers: [".pi"]
 	};
 	parseModelListingOutput(stdout) {
-		const lines = stripVTControlCharacters(stdout).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-		const first = lines[0];
-		if (!first) throw new Error("Unexpected empty Pi model-list output");
-		if (first.startsWith("No models available.") || first.startsWith("No models matching ")) return [];
-		const headers = first.split(/\s{2,}/);
-		if (headers.length !== MODEL_HEADERS.length || headers.some((value, i) => value !== MODEL_HEADERS[i])) throw new Error(`Unexpected Pi model-list header: ${JSON.stringify(first)}`);
-		return lines.slice(1).map((line) => {
-			const columns = line.split(/\s{2,}/);
-			const [provider, id, context, maxOutput, thinking, images] = columns;
-			if (columns.length !== MODEL_HEADERS.length || !provider || !id || !context || !maxOutput || !thinking || !images) throw new Error(`Unexpected Pi model-list row: ${JSON.stringify(line)}`);
-			return {
-				provider,
-				id,
-				contextWindow: parseTokenCount(context),
-				maxOutputTokens: parseTokenCount(maxOutput),
-				thinking: parseBoolean(thinking, "thinking"),
-				images: parseBoolean(images, "images")
-			};
-		});
+		return parsePiModelTable(stdout, "Pi");
+	}
+};
+var PrimeAgent = class extends Harness {
+	id = "prime-agent";
+	name = "Prime Agent";
+	binaries = ["prime-agent"];
+	capabilities = {
+		mcp: true,
+		vision: true,
+		audio: false,
+		video: false,
+		tools: true,
+		streaming: true
+	};
+	config = [{
+		path: "~/.prime/agent/settings.json",
+		scope: "user",
+		level: "official",
+		note: "Config dir overridable with PRIME_AGENT_CODING_AGENT_DIR."
+	}, {
+		path: ".prime/agent/settings.json",
+		scope: "project",
+		level: "official"
+	}];
+	sessions = [{
+		path: "~/.prime/agent/sessions/<session-id>.jsonl",
+		scope: "data",
+		level: "official",
+		note: "Flat directory of JSONL transcripts whose header records the working directory; session ids are UUIDv7. Overridable with PRIME_AGENT_SESSION_DIR or --session-dir."
+	}, {
+		path: "~/.prime/agent/session-artifacts/<session-id>/",
+		scope: "data",
+		level: "official",
+		note: "Per-session Python kernel state, scheduled jobs, harness state and child session transcripts under sub-<id>/."
+	}];
+	persistence = [
+		{
+			format: "JSON",
+			level: "official",
+			note: "Settings, auth, telemetry, model cache and session artifact state files."
+		},
+		{
+			format: "JSONL",
+			level: "official",
+			note: "Session transcripts, the RLM spawn ledger and structured logs."
+		},
+		{
+			format: "dill",
+			level: "official",
+			note: "Pickled Python REPL state (kernel-state.dill) in session artifacts."
+		}
+	];
+	instructions = [
+		{
+			path: "AGENTS.md",
+			scope: "project",
+			level: "official",
+			note: "Loaded from parent directories and cwd; CLAUDE.md accepted as an alternative."
+		},
+		{
+			path: ".prime/agent/SYSTEM.md",
+			scope: "project",
+			level: "official",
+			note: "Replaces the default system prompt; APPEND_SYSTEM.md appends instead."
+		},
+		{
+			path: "~/.prime/agent/AGENTS.md",
+			scope: "user",
+			level: "official",
+			note: "Global user-level instructions; CLAUDE.md accepted as an alternative."
+		},
+		{
+			path: "~/.prime/agent/SYSTEM.md",
+			scope: "user",
+			level: "official",
+			note: "Global system prompt replacement; APPEND_SYSTEM.md appends instead."
+		}
+	];
+	skills = [
+		{
+			path: ".prime/agent/skills/",
+			scope: "project",
+			level: "official"
+		},
+		{
+			path: ".agents/skills/",
+			scope: "project",
+			level: "official",
+			note: "Also scanned in ancestor directories up to the Git repository root; root .md files are ignored there."
+		},
+		{
+			path: "~/.prime/agent/skills/",
+			scope: "user",
+			level: "official",
+			note: "Global user-level skills."
+		},
+		{
+			path: "~/.agents/skills/",
+			scope: "user",
+			level: "official",
+			note: "Shared skills directory; root .md files are ignored there."
+		}
+	];
+	commands = [{
+		path: ".prime/agent/prompts/",
+		scope: "project",
+		level: "official",
+		note: "Prompt templates invoked as slash commands."
+	}, {
+		path: "~/.prime/agent/prompts/",
+		scope: "user",
+		level: "official",
+		note: "Global user-level prompt templates."
+	}];
+	hooks = [];
+	invocation = {
+		args: ["-p", "{prompt}"],
+		jsonArgs: [
+			"-p",
+			"--mode",
+			"json",
+			"{prompt}"
+		],
+		noToolsArgs: [
+			"-p",
+			"--no-tools",
+			"{prompt}"
+		],
+		noToolsJsonArgs: [
+			"-p",
+			"--no-tools",
+			"--mode",
+			"json",
+			"{prompt}"
+		],
+		modelArgs: ["--model", "{model}"],
+		level: "official",
+		note: "Add --mode json for structured event output. No read-only mode: the only built-in tool is a Python REPL and the worker and kernel processes are not a security sandbox."
+	};
+	modelListing = {
+		args: ["model", "list"],
+		searchArgs: [
+			"model",
+			"list",
+			"{search}"
+		],
+		level: "official",
+		note: "Lists models with configured provider authentication; accepts an optional fuzzy search. --list-models was removed."
+	};
+	mcpConfigs = [{
+		path: "~/.prime/agent/settings.json",
+		scope: "user",
+		level: "official",
+		format: "json",
+		key: ["mcpServers"],
+		dialect: "prime",
+		note: "prime-agent mcp add/remove manage this map; project settings entries are ignored for execution. Stdio env values are {\"env\": \"NAME\"} references, written from \"${NAME}\" values; literals are refused because the kernel rejects them at connect time."
+	}];
+	agentsFile = "~/.prime/agent/AGENTS.md";
+	detection = {
+		envVars: ["PRIME_AGENT_KERNEL_OWNER_PID"],
+		projectMarkers: [".prime/agent"]
+	};
+	parseModelListingOutput(stdout) {
+		return parsePiModelTable(stdout, "Prime Agent");
 	}
 };
 const harnesses = [
@@ -2079,6 +2247,7 @@ const harnesses = [
 	MastraCode,
 	Omp,
 	OpenCode,
+	PrimeAgent,
 	Pi
 ];
 let registry;
@@ -2222,9 +2391,30 @@ function normalizeStandard(name, raw) {
 		enabled: booleanField(raw, "enabled")
 	});
 }
+const ENV_REFERENCE = /^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/;
+var McpEnvError = class extends Error {
+	name = "McpEnvError";
+};
+function envReference(value) {
+	return ENV_REFERENCE.exec(value)?.[1];
+}
+function primeEnv(value) {
+	if (!isObjectRecord(value) || Array.isArray(value)) return void 0;
+	const out = {};
+	for (const [key, raw] of Object.entries(value)) if (typeof raw === "string") out[key] = raw;
+	else if (isObjectRecord(raw) && typeof raw.env === "string") out[key] = `\${${raw.env}}`;
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function normalizePrime(name, raw) {
+	return compact({
+		...normalizeStandard(name, raw),
+		env: primeEnv(raw.env)
+	});
+}
 function normalizeEntry(name, raw, dialect) {
 	if (dialect === "antigravity") return normalizeAntigravity(name, raw);
 	if (dialect === "opencode") return normalizeOpenCode(name, raw);
+	if (dialect === "prime") return normalizePrime(name, raw);
 	return normalizeStandard(name, raw);
 }
 function denormalizeAntigravity(server) {
@@ -2260,9 +2450,44 @@ function denormalizeStandard(server) {
 		enabled: server.enabled
 	});
 }
+function denormalizePrime(server) {
+	const env = server.env ? Object.fromEntries(Object.entries(server.env).map(([key, value]) => [key, { env: requirePrimeReference(server, key, value) }])) : void 0;
+	return compact({
+		...denormalizeStandard(server),
+		env
+	});
+}
+function requirePrimeReference(server, key, value) {
+	const reference = envReference(value);
+	if (reference === void 0) throw new McpEnvError(`${server.name}: Prime Agent takes only environment references in env; write ${key} as "\${NAME}" and export NAME where prime-agent runs`);
+	return reference;
+}
+function resolveEnvReferences(server, dialect) {
+	if (!server.env) return server;
+	if (dialect === "prime") {
+		for (const [key, value] of Object.entries(server.env)) requirePrimeReference(server, key, value);
+		return server;
+	}
+	const env = {};
+	for (const [key, value] of Object.entries(server.env)) {
+		const reference = envReference(value);
+		if (reference === void 0) {
+			env[key] = value;
+			continue;
+		}
+		const resolved = Object.hasOwn(process.env, reference) ? process.env[reference] : void 0;
+		if (typeof resolved !== "string") throw new McpEnvError(`${server.name}: env ${key} references ${reference}, which is not set in this environment`);
+		env[key] = resolved;
+	}
+	return {
+		...server,
+		env
+	};
+}
 function denormalizeEntry(server, dialect) {
 	if (dialect === "antigravity") return denormalizeAntigravity(server);
 	if (dialect === "opencode") return denormalizeOpenCode(server);
+	if (dialect === "prime") return denormalizePrime(server);
 	return denormalizeStandard(server);
 }
 function listingBase(entry, path) {
@@ -2399,15 +2624,16 @@ function removeTomlServer(path, key, name) {
 }
 function addMcpServer(harness, server, scope = "user", options = {}) {
 	const { entry, path } = writableConfig(harness, scope, options);
+	const resolved = resolveEnvReferences(server, entry.dialect);
 	if (entry.format === "toml") return {
 		path,
-		replaced: addTomlServer(path, entry.key, server)
+		replaced: addTomlServer(path, entry.key, resolved)
 	};
 	const root = JSON.parse(readIfExists$1(path) ?? "{}");
 	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(server, entry.dialect);
+	map[server.name] = denormalizeEntry(resolved, entry.dialect);
 	writeAtomically(path, `${JSON.stringify(root, null, 2)}\n`);
 	return {
 		path,
@@ -2616,20 +2842,29 @@ function withdrawMasterServersFromExcludedHarness(harness, existing, masterNames
 function syncIncludedHarness(harness, master, existing, masterNames, initialPath, options) {
 	const results = [];
 	let path = initialPath;
-	for (const server of master.servers) {
-		if (existing.get(server.name) === canonical(server)) {
+	const { dialect } = writableConfig(harness, "user", options).entry;
+	for (const server of master.servers) try {
+		const resolved = resolveEnvReferences(server, dialect);
+		if (existing.get(server.name) === canonical(resolved)) {
 			results.push({
 				name: server.name,
 				action: "unchanged"
 			});
 			continue;
 		}
-		const written = addMcpServer(harness, server, "user", options);
+		const written = addMcpServer(harness, resolved, "user", options);
 		path = written.path;
 		results.push({
 			name: server.name,
 			action: written.replaced ? "replaced" : "added"
 		});
+	} catch (error) {
+		if (!(error instanceof McpEnvError)) throw error;
+		results.push({
+			name: server.name,
+			action: "skipped",
+			reason: error.message
+		});
 	}
 	for (const name of existing.keys()) {
 		if (masterNames.has(name)) continue;
@@ -2858,6 +3093,6 @@ function syncAgentsFiles(harnesses, check = false, options = {}) {
 		targets: harnesses.map((harness) => syncTarget(harness, config, check, options))
 	};
 }
-export { Harness, addMcpServer, detectHarness, detectHarnessFromEnv, detectProjectHarnesses, getAllHarnesses, getHarness, isHarnessId, listHarnesses, listMcpServers, masterMcpPath, parseJsonc, readAgentsConfig, readMasterMcpServers, registerHarness, removeMcpServer, resolvePathTemplate, syncAgentsFiles, syncMcpServers };
+export { Harness, McpEnvError, addMcpServer, detectHarness, detectHarnessFromEnv, detectProjectHarnesses, getAllHarnesses, getHarness, isHarnessId, listHarnesses, listMcpServers, masterMcpPath, parseJsonc, readAgentsConfig, readMasterMcpServers, registerHarness, removeMcpServer, resolvePathTemplate, syncAgentsFiles, syncMcpServers };
 
 //# sourceMappingURL=agents-sync.mjs.map