@agntn/harnesses 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,300 @@
+import { 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 } from "./_chunks/agents-sync.mjs";
+declare function registerHarness(HarnessClass: HarnessConstructor): Harness;
+declare function getHarness(id: HarnessId): Harness;
+declare function listHarnesses(): HarnessId[];
+declare function isHarnessId(id: string): id is HarnessId;
+declare function getAllHarnesses(): Harness[];
+/**
+ * Detect the active agent from environment variables.
+ * Returns the first match since env detection is unambiguous.
+ *
+ * @returns {Harness | null} The detected harness, or null when none matches.
+ */
+declare function detectHarnessFromEnv(): Harness | null;
+/**
+ * Detect which agents have project-level markers in the given directory.
+ * Returns all matches (multiple agents can be configured in the same project).
+ *
+ * @param cwd - Directory to inspect; defaults to the current working directory.
+ * @returns {Harness[]} Every harness whose project markers match.
+ */
+declare function detectProjectHarnesses(cwd?: string): Harness[];
+/**
+ * Detect the most likely active agent. Priority:
+ * 1. Env vars (running inside agent = unambiguous)
+ * 2. Single project-level match
+ * 3. null if ambiguous or no match
+ *
+ * @param cwd - Directory to inspect for project markers.
+ * @returns {Harness | null} The unambiguous active harness, or null.
+ */
+declare function detectHarness(cwd?: string): Harness | null;
+declare function resolvePathTemplate(template: string, options?: ResolveOptions): string;
+interface ClaudeTextBlock {
+  type: "text";
+  text: string;
+}
+interface ClaudeThinkingBlock {
+  type: "thinking";
+  thinking: string;
+  signature: string;
+}
+interface ClaudeToolUseBlock {
+  type: "tool_use";
+  id: string;
+  name: string;
+  input: unknown;
+}
+interface ClaudeToolResultBlock {
+  type: "tool_result";
+  tool_use_id: string;
+  content: string | unknown[];
+  is_error: boolean;
+}
+type ClaudeContentBlock = ClaudeTextBlock | ClaudeThinkingBlock | ClaudeToolUseBlock | ClaudeToolResultBlock;
+interface ClaudeUsage {
+  input_tokens: number;
+  cache_creation_input_tokens: number;
+  cache_read_input_tokens: number;
+  output_tokens: number;
+}
+interface ClaudeBaseEntry {
+  uuid: string;
+  timestamp: string;
+  sessionId: string;
+  parentUuid: string | null;
+  isSidechain: boolean;
+  userType: "external" | "ant";
+  cwd: string;
+  version: string;
+  gitBranch: string;
+}
+interface ClaudeUserEntry extends ClaudeBaseEntry {
+  type: "user";
+  message: {
+    role: "user";
+    content: string | ClaudeContentBlock[];
+  };
+  isMeta?: boolean;
+  toolUseResult?: {
+    stdout: string;
+    stderr: string;
+    interrupted: boolean;
+    isImage: boolean;
+  };
+}
+interface ClaudeAssistantEntry extends ClaudeBaseEntry {
+  type: "assistant";
+  requestId: string;
+  message: {
+    id: string;
+    role: "assistant";
+    type: "message";
+    model: string;
+    content: ClaudeContentBlock[];
+    stop_reason: string | null;
+    stop_sequence: string | null;
+    usage: ClaudeUsage;
+  };
+}
+interface ClaudeSummaryEntry {
+  type: "summary";
+  summary: string;
+  leafUuid: string;
+}
+type ClaudeSessionEntry = ClaudeUserEntry | ClaudeAssistantEntry | ClaudeSummaryEntry;
+interface ClaudeHistoryEntry {
+  display: string;
+  timestamp: number;
+  project: string;
+  sessionId: string;
+  pastedContents: Record<string, {
+    id: number;
+    type: "text";
+    content: string;
+  }>;
+}
+interface GeminiTokensSummary {
+  input: number;
+  output: number;
+  cached: number;
+  thoughts?: number;
+  tool?: number;
+  total: number;
+}
+interface GeminiToolCallRecord {
+  id: string;
+  name: string;
+  args: Record<string, unknown>;
+  result?: unknown[] | null;
+  status: "success" | "error" | "running";
+  timestamp: string;
+  displayName?: string;
+  renderOutputAsMarkdown?: boolean;
+}
+interface GeminiThought {
+  subject: string;
+  description: string;
+  timestamp: string;
+}
+interface GeminiMessageRecord {
+  id: string;
+  timestamp: string;
+  type: "user" | "gemini" | "info" | "error" | "warning";
+  content: unknown[];
+  displayContent?: unknown[];
+  model?: string;
+  tokens?: GeminiTokensSummary;
+  thoughts?: GeminiThought[];
+  toolCalls?: GeminiToolCallRecord[];
+}
+interface GeminiConversationRecord {
+  sessionId: string;
+  projectHash: string;
+  startTime: string;
+  lastUpdated: string;
+  messages: GeminiMessageRecord[];
+  summary?: string;
+  directories?: string[];
+  kind?: "main" | "subagent";
+}
+interface CodexHistoryEntry {
+  session_id: string;
+  ts: number;
+  text: string;
+}
+interface CodexThread {
+  id: string;
+  rollout_path: string;
+  created_at: number;
+  updated_at: number;
+  source: string;
+  model_provider: string;
+  cwd: string;
+  title: string;
+  sandbox_policy: string;
+  approval_mode: string;
+  tokens_used: number;
+  archived: number;
+  git_sha: string;
+}
+interface CodexLogEntry {
+  id: number;
+  ts: number;
+  ts_nanos: number;
+  level: string;
+  message: string;
+  thread_id: string | null;
+  process_uuid: string;
+}
+interface OpenCodeSession {
+  id: string;
+  project_id: string;
+  workspace_id: string | null;
+  parent_id: string | null;
+  slug: string;
+  directory: string;
+  title: string;
+  version: string;
+  share_url: string | null;
+  summary_additions: number | null;
+  summary_deletions: number | null;
+  summary_files: number | null;
+  time_created: number;
+  time_updated: number;
+  time_compacting: number | null;
+  time_archived: number | null;
+}
+interface OpenCodeMessage {
+  id: string;
+  session_id: string;
+  time_created: number;
+  time_updated: number;
+  data: unknown;
+}
+interface OpenCodeTextPart {
+  type: "text";
+  text: string;
+  synthetic?: boolean;
+  ignored?: boolean;
+}
+interface OpenCodeReasoningPart {
+  type: "reasoning";
+  text: string;
+}
+interface OpenCodeToolPart {
+  type: "tool";
+  callID: string;
+  tool: string;
+  state: "pending" | "running" | "completed" | "error";
+}
+interface OpenCodeFilePart {
+  type: "file";
+  mime: string;
+  filename: string;
+  url: string;
+  source?: string;
+}
+interface OpenCodeSubtaskPart {
+  type: "subtask";
+  prompt: string;
+  description: string;
+  agent?: string;
+  model?: string;
+  command?: string;
+}
+interface OpenCodeStepStartPart {
+  type: "step-start";
+  snapshot?: string;
+}
+interface OpenCodeStepFinishPart {
+  type: "step-finish";
+  reason: string;
+  cost?: number;
+  tokens?: unknown;
+  snapshot?: string;
+}
+interface OpenCodeSnapshotPart {
+  type: "snapshot";
+  snapshot: string;
+}
+interface OpenCodePatchPart {
+  type: "patch";
+  hash: string;
+  files: unknown;
+}
+interface OpenCodeAgentPart {
+  type: "agent";
+  name: string;
+  source?: string;
+}
+interface OpenCodeRetryPart {
+  type: "retry";
+  attempt: number;
+  error: string;
+  time?: number;
+}
+interface OpenCodeCompactionPart {
+  type: "compaction";
+  auto?: boolean;
+  overflow?: boolean;
+}
+type OpenCodePart = OpenCodeTextPart | OpenCodeReasoningPart | OpenCodeToolPart | OpenCodeFilePart | OpenCodeSubtaskPart | OpenCodeStepStartPart | OpenCodeStepFinishPart | OpenCodeSnapshotPart | OpenCodePatchPart | OpenCodeAgentPart | OpenCodeRetryPart | OpenCodeCompactionPart;
+interface OpenCodeTodo {
+  session_id: string;
+  content: string;
+  status: string;
+  priority: string;
+  position: number;
+  time_created: number;
+  time_updated: number;
+}
+interface OpenCodeProject {
+  id: string;
+  worktree: string;
+  vcs: string | null;
+  name: string | null;
+}
+declare const harnessIds: readonly HarnessId[];
+export { type AgentsCompanionTargetResult, type AgentsConfig, type AgentsSyncAction, type AgentsSyncReport, type AgentsTargetResult, type AvailableModel, type ClaudeAssistantEntry, type ClaudeBaseEntry, type ClaudeContentBlock, type ClaudeHistoryEntry, type ClaudeSessionEntry, type ClaudeSummaryEntry, type ClaudeTextBlock, type ClaudeThinkingBlock, type ClaudeToolResultBlock, type ClaudeToolUseBlock, type ClaudeUsage, type ClaudeUserEntry, type CodexHistoryEntry, type CodexLogEntry, type CodexThread, type EvidenceLevel, type GeminiConversationRecord, type GeminiMessageRecord, type GeminiThought, type GeminiTokensSummary, type GeminiToolCallRecord, Harness, type HarnessCapabilities, type HarnessConstructor, type HarnessDetection, type HarnessId, type HarnessInvocation, type HarnessInvocationModes, type HarnessModelListing, type InvokeOptions, type InvokeResult, type ListModelsOptions, type ListModelsResult, type McpConfigFile, type McpConfigListing, type McpServerConfig, type OpenCodeAgentPart, type OpenCodeCompactionPart, type OpenCodeFilePart, type OpenCodeMessage, type OpenCodePart, type OpenCodePatchPart, type OpenCodeProject, type OpenCodeReasoningPart, type OpenCodeRetryPart, type OpenCodeSession, type OpenCodeSnapshotPart, type OpenCodeStepFinishPart, type OpenCodeStepStartPart, type OpenCodeSubtaskPart, type OpenCodeTextPart, type OpenCodeTodo, type OpenCodeToolPart, type PathCandidate, type Platform, type ResolveOptions, type ResolvedPaths, type StorageDescriptor, type SyncReport, type SyncTargetResult, addMcpServer, detectHarness, detectHarnessFromEnv, detectProjectHarnesses, getAllHarnesses, getHarness, harnessIds, isHarnessId, listHarnesses, listMcpServers, masterMcpPath, parseJsonc, readAgentsConfig, readMasterMcpServers, registerHarness, removeMcpServer, resolvePathTemplate, syncAgentsFiles, syncMcpServers, version };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/registry.ts","../src/resolve.ts","../src/schemas/claude.ts","../src/schemas/gemini.ts","../src/schemas/codex.ts","../src/schemas/opencode.ts","../src/index.ts"],"mappings":";iBAiBgB,gBAAgB,cAAc,qBAAqB;iBAMnD,WAAW,IAAI,YAAY;iBAM3B,iBAAiB;iBAIjB,YAAY,aAAa,MAAM;iBAI/B,mBAAmB;;;;;;;iBAUnB,wBAAwB;;;;;;;;iBAcxB,uBAAuB,eAAe;;;;;;;;;;iBAatC,cAAc,eAAe;iBCtE7B,oBAAoB,kBAAkB,UAAS;UCJ9C;EACf;EACA;;UAGe;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;;KAGU,qBACR,kBACA,sBACA,qBACA;UAEa;EACf;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe,wBAAwB;EACvC;EACA;IACE;IACA,kBAAkB;;EAEpB;EACA;IACE;IACA;IACA;IACA;;;UAIa,6BAA6B;EAC5C;EACA;EACA;IACE;IACA;IACA;IACA;IACA,SAAS;IACT;IACA;IACA,OAAO;;;UAIM;EACf;EACA;EACA;;KAGU,qBAAqB,kBAAkB,uBAAuB;UAEzD;EACf;EACA;EACA;EACA;EACA,gBAAgB;IAGZ;IACA;IACA;;;UClGW;EACf;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA,MAAM;EACN;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA,SAAS;EACT,WAAW;EACX,YAAY;;UAGG;EACf;EACA;EACA;EACA;EACA,UAAU;EACV;EACA;EACA;;UC9Ce;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;UC7Be;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;;UAGe;EACf;EACA;;UAGe;EACf;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;;UAGe;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;;KAGU,eACR,mBACA,wBACA,mBACA,mBACA,sBACA,wBACA,yBACA,uBACA,oBACA,oBACA,oBACA;UAEa;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;;cCpCW,qBAAqB"}

package/dist/index.mjs

@@ -0,0 +1,6 @@
+import { version } from "./_chunks/types.mjs";
+import { Harness, addMcpServer, detectHarness, detectHarnessFromEnv, detectProjectHarnesses, getAllHarnesses, getHarness, isHarnessId, listHarnesses, listMcpServers, masterMcpPath, parseJsonc, readAgentsConfig, readMasterMcpServers, registerHarness, removeMcpServer, resolvePathTemplate, syncAgentsFiles, syncMcpServers } from "./_chunks/agents-sync.mjs";
+const harnessIds = Object.freeze(listHarnesses());
+export { Harness, addMcpServer, detectHarness, detectHarnessFromEnv, detectProjectHarnesses, getAllHarnesses, getHarness, harnessIds, isHarnessId, listHarnesses, listMcpServers, masterMcpPath, parseJsonc, readAgentsConfig, readMasterMcpServers, registerHarness, removeMcpServer, resolvePathTemplate, syncAgentsFiles, syncMcpServers, version };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["export { version } from \"./types.ts\";\nexport type {\n  HarnessId,\n  EvidenceLevel,\n  Platform,\n  PathCandidate,\n  StorageDescriptor,\n  HarnessCapabilities,\n  HarnessDetection,\n  HarnessInvocation,\n  HarnessInvocationModes,\n  HarnessModelListing,\n  AvailableModel,\n  ListModelsOptions,\n  ListModelsResult,\n  InvokeOptions,\n  InvokeResult,\n  McpServerConfig,\n  McpConfigFile,\n  ResolveOptions,\n  ResolvedPaths,\n} from \"./types.ts\";\n\nexport { Harness } from \"./harness.ts\";\nexport type { HarnessConstructor } from \"./harness.ts\";\nexport {\n  registerHarness,\n  getHarness,\n  isHarnessId,\n  listHarnesses,\n  getAllHarnesses,\n  detectHarness,\n  detectHarnessFromEnv,\n  detectProjectHarnesses,\n} from \"./registry.ts\";\nexport { resolvePathTemplate } from \"./resolve.ts\";\nexport {\n  listMcpServers,\n  addMcpServer,\n  removeMcpServer,\n  syncMcpServers,\n  readMasterMcpServers,\n  masterMcpPath,\n  parseJsonc,\n} from \"./mcp-servers.ts\";\nexport type { McpConfigListing, SyncReport, SyncTargetResult } from \"./mcp-servers.ts\";\nexport { syncAgentsFiles, readAgentsConfig } from \"./agents-sync.ts\";\nexport type {\n  AgentsConfig,\n  AgentsSyncAction,\n  AgentsCompanionTargetResult,\n  AgentsSyncReport,\n  AgentsTargetResult,\n} from \"./agents-sync.ts\";\n\nexport type {\n  ClaudeContentBlock,\n  ClaudeTextBlock,\n  ClaudeThinkingBlock,\n  ClaudeToolUseBlock,\n  ClaudeToolResultBlock,\n  ClaudeUsage,\n  ClaudeBaseEntry,\n  ClaudeUserEntry,\n  ClaudeAssistantEntry,\n  ClaudeSummaryEntry,\n  ClaudeSessionEntry,\n  ClaudeHistoryEntry,\n  GeminiTokensSummary,\n  GeminiToolCallRecord,\n  GeminiThought,\n  GeminiMessageRecord,\n  GeminiConversationRecord,\n  CodexHistoryEntry,\n  CodexThread,\n  CodexLogEntry,\n  OpenCodeSession,\n  OpenCodeMessage,\n  OpenCodeTextPart,\n  OpenCodeReasoningPart,\n  OpenCodeToolPart,\n  OpenCodeFilePart,\n  OpenCodeSubtaskPart,\n  OpenCodeStepStartPart,\n  OpenCodeStepFinishPart,\n  OpenCodeSnapshotPart,\n  OpenCodePatchPart,\n  OpenCodeAgentPart,\n  OpenCodeRetryPart,\n  OpenCodeCompactionPart,\n  OpenCodePart,\n  OpenCodeTodo,\n  OpenCodeProject,\n} from \"./schemas/index.ts\";\n\nimport type { HarnessId } from \"./types.ts\";\nimport { listHarnesses } from \"./registry.ts\";\n\nexport const harnessIds: readonly HarnessId[] = Object.freeze(listHarnesses());\n"],"mappings":";;AAkGA,MAAa,aAAmC,OAAO,OAAO,cAAc,CAAC"}

package/dist/mcp.d.mts

@@ -0,0 +1,15 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+/**
+ * Creates an unconnected MCP server exposing the harness registry tools.
+ *
+ * Built on the low-level `Server` even though the SDK marks it `@deprecated`,
+ * because `McpServer.registerTool` accepts Standard Schema (Zod) only. TypeBox 1.x
+ * does not implement Standard Schema, and this package's tool schemas are TypeBox,
+ * shared with the Pi and OMP extensions. The high-level API would force a second
+ * definition of every parameter.
+ *
+ * @returns {Server} An unconnected MCP server.
+ */
+declare function createMcpServer(): Server;
+export { createMcpServer };
+//# sourceMappingURL=mcp.d.mts.map

package/dist/mcp.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.mts","names":[],"sources":["../src/mcp.ts"],"mappings":";;;;;;;;;;;;iBAqOgB,mBAAmB"}

package/dist/mcp.mjs

@@ -0,0 +1,2 @@
+import { createMcpServer } from "./_chunks/mcp.mjs";
+export { createMcpServer };

package/dist/tool-operations.d.mts

@@ -0,0 +1,222 @@
+import { AgentsSyncReport, AvailableModel, HarnessCapabilities, HarnessDetection, HarnessId, HarnessInvocationModes, McpConfigListing, McpServerConfig, PathCandidate, ResolvedPaths, StorageDescriptor, SyncReport } from "./_chunks/agents-sync.mjs";
+import { HARNESS_INFO_MAX_ITEMS } from "./_chunks/tool-schemas.mjs";
+/** Text for the model plus details for the harness, shared by every tool surface. */
+interface ToolResult<Details> {
+  content: Array<{
+    type: "text";
+    text: string;
+  }>;
+  details: Details;
+  /** Set when the tool could not answer. */
+  isError?: boolean;
+}
+/** Install state of one harness on this machine. */
+interface HarnessStatus {
+  id: HarnessId;
+  name: string;
+  installed: boolean;
+  version: string | null;
+}
+/** Every registered harness with its install state, as scanned by {@link detectHarnesses}. */
+interface HarnessListing {
+  harnesses: HarnessStatus[];
+}
+/** Full metadata for one harness, including paths resolved for this platform. */
+interface HarnessMetadata {
+  id: HarnessId;
+  name: string;
+  binaries: string[];
+  capabilities: HarnessCapabilities;
+  invocationModes: HarnessInvocationModes;
+  modelListing: boolean;
+  modelSelection: boolean;
+  config: PathCandidate[];
+  sessions: PathCandidate[];
+  instructions: PathCandidate[];
+  skills: PathCandidate[];
+  commands: PathCandidate[];
+  hooks: PathCandidate[];
+  persistence: StorageDescriptor[];
+  detection: HarnessDetection;
+  resolved: ResolvedPaths;
+}
+/** Returned when the requested harness id is not registered. */
+interface UnknownHarness {
+  error: string;
+  known: HarnessId[];
+}
+/** Returned when a direct batch call bypasses the tool schema limits. */
+interface HarnessInfoInputError {
+  error: string;
+}
+/** One harness lookup result. */
+type HarnessInfoResult = HarnessMetadata | UnknownHarness;
+/** Scalar, batch, or rejected batch details from {@link harnessInfo}. */
+type HarnessInfoDetails = HarnessInfoResult | HarnessInfoResult[] | HarnessInfoInputError;
+/** Default wall-clock budget for one harness run, in seconds. */
+declare const RUN_DEFAULT_TIMEOUT_SECONDS = 600;
+/** The run tool's per-stream cap: harness output is unbounded, model context is not. */
+declare const RUN_MAX_OUTPUT_CHARS = 8000;
+/**
+ * Scans every registered harness for its binaries and version.
+ *
+ * @returns {ToolResult<HarnessListing>} The complete installation listing.
+ */
+declare function detectHarnesses(): ToolResult<HarnessListing>;
+/** Full metadata for one harness, with paths resolved for the current platform. */
+declare function harnessInfo(id: string): ToolResult<HarnessInfoResult>;
+/** Full metadata for several harnesses, preserving input order and errors for each item. */
+declare function harnessInfo(ids: readonly string[]): ToolResult<HarnessInfoResult[] | HarnessInfoInputError>;
+declare function harnessInfo(input: string | readonly string[]): ToolResult<HarnessInfoDetails>;
+/** Options accepted by {@link listHarnessModels}. */
+interface ModelsOptions {
+  search?: string;
+  cwd?: string;
+  /** Wall-clock budget in seconds; defaults to {@link RUN_DEFAULT_TIMEOUT_SECONDS}. */
+  timeoutSeconds?: number;
+}
+/** One completed native model-listing query. */
+interface ModelsOutcome {
+  id: HarnessId;
+  command: string;
+  args: string[];
+  search?: string;
+  models: AvailableModel[];
+  exitCode: number | null;
+  timedOut: boolean;
+  stderr: string;
+}
+/**
+ * Lists the models currently available to one harness through its native CLI.
+ *
+ * @param id - Harness id to query.
+ * @param options - Search, working-directory, and timeout options.
+ * @returns {Promise<ToolResult<ModelsOutcome | RunFailure>>} The model listing or failure.
+ */
+declare function listHarnessModels(id: string, options?: ModelsOptions): Promise<ToolResult<ModelsOutcome | RunFailure>>;
+/** Options accepted by {@link runHarness}. */
+interface RunOptions {
+  cwd?: string;
+  /** Harness-native model id or selector. */
+  model?: string;
+  /** Wall-clock budget in seconds; defaults to {@link RUN_DEFAULT_TIMEOUT_SECONDS}. */
+  timeoutSeconds?: number;
+  /** Use the harness's structured (JSON) output mode instead of plain text. */
+  structured?: boolean;
+  /** Enable tools; defaults to a native advisor without tools invocation. */
+  tools?: boolean;
+  /** Require native enforcement of read-only tool access. Implies tools. */
+  readOnly?: boolean;
+}
+/** One completed (or failed) harness run, with output capped for the model. */
+interface RunOutcome {
+  id: HarnessId;
+  command: string;
+  args: string[];
+  model?: string;
+  structured: boolean;
+  tools: boolean;
+  readOnly: boolean;
+  exitCode: number | null;
+  timedOut: boolean;
+  stdout: string;
+  stderr: string;
+}
+/** Returned when the harness cannot be run at all. */
+interface RunFailure {
+  error: string;
+  known?: HarnessId[];
+  /** Modes accepted by the selected harness when invocation mode caused the failure. */
+  invocationModes?: HarnessInvocationModes;
+  /** Explicit mode change that makes the same invocation shape executable. */
+  retry?: {
+    tools: boolean;
+  };
+}
+/**
+ * Runs one prompt through a harness's normalized non-interactive invocation.
+ *
+ * Tool use defaults to a native advisor without tools invocation. Harnesses that
+ * cannot disable tools reject that mode; setting `tools` selects their full
+ * agent invocation. `model` is translated through the harness-specific recipe.
+ * This layer also closes stdin, enforces the timeout, and
+ * caps the echoed output.
+ *
+ * @param id - Harness id to run.
+ * @param prompt - Prompt sent to the selected harness.
+ * @param options - Model, mode, working-directory, and timeout options.
+ * @returns {Promise<ToolResult<RunOutcome | RunFailure>>} The capped run outcome or failure.
+ */
+declare function runHarness(id: string, prompt: string, options?: RunOptions): Promise<ToolResult<RunOutcome | RunFailure>>;
+/** MCP server listings for one harness or all of them. */
+interface McpListing {
+  harnesses: Array<{
+    id: HarnessId;
+    configs: McpConfigListing[];
+  }>;
+}
+/** Result of one MCP config mutation. */
+interface McpMutation {
+  id: HarnessId;
+  path: string;
+  action: "added" | "replaced" | "removed" | "noop";
+}
+/** Flat tool parameters describing one MCP server, shared by every surface. */
+interface McpServerParams {
+  name: string;
+  transport?: McpServerConfig["transport"];
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  url?: string;
+  headers?: Record<string, string>;
+}
+/**
+ * Builds the normalized server shape from flat tool parameters.
+ *
+ * @param params - Flat MCP server parameters.
+ * @returns {McpServerConfig} The normalized server configuration.
+ */
+declare function toMcpServerConfig(params: McpServerParams): McpServerConfig;
+/**
+ * Lists configured MCP servers, normalized across harness config dialects.
+ *
+ * @param id - Optional harness id; omission lists every harness.
+ * @returns {ToolResult<McpListing | UnknownHarness>} The normalized listing or id error.
+ */
+declare function mcpList(id?: string): ToolResult<McpListing | UnknownHarness>;
+/**
+ * Adds or replaces one MCP server in a harness's config.
+ *
+ * @param id - Target harness id.
+ * @param params - Server parameters to normalize and write.
+ * @param scope - User or project config scope.
+ * @returns {ToolResult<McpMutation | RunFailure>} The mutation outcome or failure.
+ */
+declare function mcpAdd(id: string, params: McpServerParams, scope?: "user" | "project"): ToolResult<McpMutation | RunFailure>;
+/**
+ * Removes one MCP server from a harness's config.
+ *
+ * @param id - Target harness id.
+ * @param name - Server name to remove.
+ * @param scope - User or project config scope.
+ * @returns {ToolResult<McpMutation | RunFailure>} The mutation outcome or failure.
+ */
+declare function mcpRemove(id: string, name: string, scope?: "user" | "project"): ToolResult<McpMutation | RunFailure>;
+/**
+ * Pushes the master MCP list from ~/.config/agntn/mcp.jsonc into harness configs.
+ *
+ * @param id - Optional harness id; omission targets every harness.
+ * @returns {ToolResult<SyncReport | RunFailure>} The sync report or failure.
+ */
+declare function mcpSync(id?: string): ToolResult<SyncReport | RunFailure>;
+/**
+ * Links every harness's global instructions file to the master AGENTS.md.
+ *
+ * @param id - Optional harness id; omission targets every harness.
+ * @param check - Report intended changes without writing them.
+ * @returns {ToolResult<AgentsSyncReport | RunFailure>} The sync report or failure.
+ */
+declare function agentsSync(id?: string, check?: boolean): ToolResult<AgentsSyncReport | RunFailure>;
+export { type AgentsSyncReport, HARNESS_INFO_MAX_ITEMS, HarnessInfoDetails, HarnessInfoInputError, HarnessInfoResult, type HarnessInvocationModes, HarnessListing, HarnessMetadata, HarnessStatus, McpListing, McpMutation, McpServerParams, ModelsOptions, ModelsOutcome, RUN_DEFAULT_TIMEOUT_SECONDS, RUN_MAX_OUTPUT_CHARS, RunFailure, RunOptions, RunOutcome, type SyncReport, ToolResult, UnknownHarness, agentsSync, detectHarnesses, harnessInfo, listHarnessModels, mcpAdd, mcpList, mcpRemove, mcpSync, runHarness, toMcpServerConfig };
+//# sourceMappingURL=tool-operations.d.mts.map

package/dist/tool-operations.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-operations.d.mts","names":[],"sources":["../src/tool-operations.ts"],"mappings":";;;UAsCiB,WAAW;EAC1B,SAAS;IAAQ;IAAc;;EAC/B,SAAS;;EAET;;;UAIe;EACf,IAAI;EACJ;EACA;EACA;;;UAIe;EACf,WAAW;;;UAII;EACf,IAAI;EACJ;EACA;EACA,cAAc;EACd,iBAAiB;EACjB;EACA;EACA,QAAQ;EACR,UAAU;EACV,cAAc;EACd,QAAQ;EACR,UAAU;EACV,OAAO;EACP,aAAa;EACb,WAAW;EACX,UAAU;;;UAIK;EACf;EACA,OAAO;;;UAIQ;EACf;;;KAIU,oBAAoB,kBAAkB;;KAGtC,qBAAqB,oBAAoB,sBAAsB;;cAM9D;;cAGA;;;;;;iBA4GG,mBAAmB,WAAW;;iBAyC9B,YAAY,aAAa,WAAW;;iBAEpC,YACd,yBACC,WAAW,sBAAsB;iBACpB,YAAY,oCAAoC,WAAW;;UAuB1D;EACf;EACA;;EAEA;;;UAIe;EACf,IAAI;EACJ;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA;;;;;;;;;iBAUoB,kBACpB,YACA,UAAS,gBACR,QAAQ,WAAW,gBAAgB;;UA0CrB;EACf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;UAIe;EACf,IAAI;EACJ;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;UAIe;EACf;EACA,QAAQ;;EAER,kBAAkB;;EAElB;IAAU;;;;;;;;;;;;;;;;;iBAyBU,WACpB,YACA,gBACA,UAAS,aACR,QAAQ,WAAW,aAAa;;UAgClB;EACf,WAAW;IAAQ,IAAI;IAAW,SAAS;;;;UAI5B;EACf,IAAI;EACJ;EACA;;;UAIe;EACf;EACA,YAAY;EACZ;EACA;EACA,MAAM;EACN;EACA,UAAU;;;;;;;;iBASI,kBAAkB,QAAQ,kBAAkB;;;;;;;iBAmB5C,QAAQ,cAAc,WAAW,aAAa;;;;;;;;;iBAqC9C,OACd,YACA,QAAQ,iBACR,6BACC,WAAW,cAAc;;;;;;;;;iBAeZ,UACd,YACA,cACA,6BACC,WAAW,cAAc;;;;;;;iBAaZ,QAAQ,cAAc,WAAW,aAAa;;;;;;;;iBA+B9C,WAAW,aAAa,kBAAgB,WAAW,mBAAmB"}

package/dist/tool-operations.mjs

@@ -0,0 +1,3 @@
+import { HARNESS_INFO_MAX_ITEMS } from "./_chunks/tool-schemas.mjs";
+import { RUN_DEFAULT_TIMEOUT_SECONDS, RUN_MAX_OUTPUT_CHARS, agentsSync, detectHarnesses, harnessInfo, listHarnessModels, mcpAdd, mcpList, mcpRemove, mcpSync, runHarness, toMcpServerConfig } from "./_chunks/tool-operations.mjs";
+export { HARNESS_INFO_MAX_ITEMS, RUN_DEFAULT_TIMEOUT_SECONDS, RUN_MAX_OUTPUT_CHARS, agentsSync, detectHarnesses, harnessInfo, listHarnessModels, mcpAdd, mcpList, mcpRemove, mcpSync, runHarness, toMcpServerConfig };

package/dist/tool-schemas.d.mts

@@ -0,0 +1,2 @@
+import { AgentsSyncParams, HARNESS_INFO_MAX_ITEMS, InfoParams, McpAddParams, McpListParams, McpRemoveParams, McpSchemaBuilder, McpSyncParams, ModelsParams, RUN_TIMEOUT_DEFAULT_SECONDS, RunParams, harnessToolSchemas } from "./_chunks/tool-schemas.mjs";
+export { AgentsSyncParams, HARNESS_INFO_MAX_ITEMS, InfoParams, McpAddParams, McpListParams, McpRemoveParams, McpSchemaBuilder, McpSyncParams, ModelsParams, RUN_TIMEOUT_DEFAULT_SECONDS, RunParams, harnessToolSchemas };

package/dist/tool-schemas.mjs

@@ -0,0 +1,2 @@
+import { HARNESS_INFO_MAX_ITEMS, RUN_TIMEOUT_DEFAULT_SECONDS, harnessToolSchemas } from "./_chunks/tool-schemas.mjs";
+export { HARNESS_INFO_MAX_ITEMS, RUN_TIMEOUT_DEFAULT_SECONDS, harnessToolSchemas };