@tangle-network/agent-interface 0.29.0 → 0.31.0

package/dist/agent-candidate-schema.d.ts

@@ -61,20 +61,7 @@ export declare const agentCandidateBundleSchema: z.ZodObject<{
             deny: "deny";
         }>>]>>>;
         tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
-        mcp: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            transport: z.ZodOptional<z.ZodLiteral<"stdio">>;
-            command: z.ZodOptional<z.ZodString>;
-            args: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                kind: z.ZodLiteral<"public">;
-                value: z.ZodString;
-            }, z.core.$strict>>>;
-            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-                kind: z.ZodLiteral<"public">;
-                value: z.ZodString;
-            }, z.core.$strict>>>;
-            cwd: z.ZodOptional<z.ZodString>;
-            enabled: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>>>;
+        mcp: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./agent-candidate.js").AgentCandidateMcpServer, unknown, z.core.$ZodTypeInternals<import("./agent-candidate.js").AgentCandidateMcpServer, unknown>>>>;
         subagents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             prompt: z.ZodOptional<z.ZodString>;
             permissions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{

package/dist/agent-candidate.d.ts

@@ -1,4 +1,4 @@
-import type { AgentProfile, AgentProfileFileMount, AgentProfileHookCommand, AgentProfileMcpServer, AgentProfileMode, AgentProfileModelHints, AgentProfileResources, AgentSubagentProfile, ReasoningEffort } from "./agent-profile.js";
+import type { AgentProfile, AgentProfileFileMount, AgentProfileHookCommand, AgentProfileMode, AgentProfileModelHints, AgentProfileResources, AgentSubagentProfile, ReasoningEffort } from "./agent-profile.js";
 import type { HarnessType } from "./harness.js";
 /** Full SHA-256 digest with an explicit algorithm prefix. */
 export type Sha256Digest = `sha256:${string}`;
@@ -78,11 +78,23 @@ export interface AgentCandidateResources extends Omit<AgentProfileResources, "fi
     instructions?: string | AgentCandidateResourceRef;
     failOnError: true;
 }
-export interface AgentCandidateMcpServer extends Omit<AgentProfileMcpServer, "transport" | "args" | "env" | "headers" | "url" | "metadata"> {
+interface AgentCandidateLocalMcpServer {
     transport?: "stdio";
+    command: string;
     args?: AgentCandidateConfigValue[];
     env?: Record<string, AgentCandidateConfigValue>;
-}
+    cwd?: string;
+    enabled?: true;
+}
+interface AgentCandidateDisabledMcpServer {
+    enabled: false;
+    transport?: never;
+    command?: never;
+    args?: never;
+    env?: never;
+    cwd?: never;
+}
+export type AgentCandidateMcpServer = AgentCandidateLocalMcpServer | AgentCandidateDisabledMcpServer;
 export type AgentCandidateModelHints = Omit<AgentProfileModelHints, "metadata">;
 export type AgentCandidateSubagentProfile = Omit<AgentSubagentProfile, "metadata">;
 export type AgentCandidateMode = Omit<AgentProfileMode, "metadata">;
@@ -297,6 +309,8 @@ export interface AgentCandidateProfilePlanMaterial {
     }>;
     env: Record<string, AgentCandidateConfigValue>;
     flags: AgentCandidateConfigValue[];
+    /** Exact system-prompt replacement supplied to the harness, when supported. */
+    systemPrompt?: AgentCandidateConfigValue;
     unsupported: Array<{
         dimension: string;
         reason: string;
@@ -792,6 +806,7 @@ export interface AgentImprovementActivationTarget {
     /** Current target state that activation is allowed to replace. */
     expectedBaseDigest: Sha256Digest;
 }
+export type AgentImprovementActivationIntent = "activate-candidate" | "restore-baseline";
 /** Authority receipt permitting activation of one already-measured candidate. */
 export interface AgentImprovementActivation {
     kind: "agent-improvement-activation";
@@ -799,10 +814,56 @@ export interface AgentImprovementActivation {
     reviewDigest: Sha256Digest;
     experimentDigest: Sha256Digest;
     candidateBundleDigest: Sha256Digest;
+    intent: AgentImprovementActivationIntent;
     targets: [AgentImprovementActivationTarget, ...AgentImprovementActivationTarget[]];
     fundingOwner: string;
     authorizedBy: string;
     authorizedAt: string;
+    expiresAt: string;
+    digest: Sha256Digest;
+}
+export interface AgentImprovementActivationTargetTransition {
+    surface: AgentImprovementSurface;
+    identity: string;
+    beforeDigest: Sha256Digest;
+    afterDigest: Sha256Digest;
+}
+export interface AgentImprovementActivationTargetState {
+    surface: AgentImprovementSurface;
+    identity: string;
+    currentDigest: Sha256Digest;
+}
+export type AgentImprovementActivationOutcome = {
+    /** Every target changed atomically from the authorized state to the requested bundle. */
+    status: "applied";
+    transactionId: string;
+    targets: [
+        AgentImprovementActivationTargetTransition,
+        ...AgentImprovementActivationTargetTransition[]
+    ];
+} | {
+    /** No write occurred; targets are already desired or no longer match the authorized base. */
+    status: "already-applied" | "conflict";
+    targets: [
+        AgentImprovementActivationTargetState,
+        ...AgentImprovementActivationTargetState[]
+    ];
+} | {
+    status: "expired";
+} | {
+    /** `failed` proves no write; `indeterminate` means commit state must be reconciled. */
+    status: "unsupported" | "failed" | "indeterminate";
+    code: string;
+    message: string;
+};
+/** Immutable outcome of one idempotent, transaction-wide activation attempt. */
+export interface AgentImprovementActivationResult {
+    kind: "agent-improvement-activation-result";
+    /** The activation digest is also its stable retry key. */
+    idempotencyKey: Sha256Digest;
+    attemptedAt: string;
+    completedAt: string;
+    outcome: AgentImprovementActivationOutcome;
     digest: Sha256Digest;
 }
 /** Complete execution of one exact experiment attempt. */
@@ -909,3 +970,4 @@ export interface AgentCandidateBenchmarkResultEvidence {
 }
 /** Declare a candidate bundle while retaining literal inference. */
 export declare function defineAgentCandidateBundle<T extends AgentCandidateBundle>(bundle: T): T;
+export {};

package/dist/agent-profile.d.ts

@@ -92,9 +92,9 @@ export interface AgentProfileResources {
  *   - `none`     — extended thinking OFF (no reasoning budget at all)
  *   - `minimal`  — thinking ON, the lowest budget (distinct from `none`)
  *   - `low` / `medium` / `high` / `xhigh`
- *   - `ultracode` — maximum (claude-code's "ultracode" run mode; codex's `max` reconciles here).
- * A backend without a matching native tier clamps to its nearest (e.g. codex maps `ultracode` → `xhigh`
- * on models that support it).
+ *   - `ultracode` — maximum (Claude Code's `max` and Codex's `ultra` reconcile here).
+ * A backend without a matching native tier may clamp down to its strongest supported level, but it
+ * must never turn reasoning on for `none` or silently increase a requested effort.
  */
 export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "ultracode";
 /**
@@ -191,17 +191,40 @@ export interface AgentProfileConfidential {
 /**
  * Generic MCP server configuration.
  */
-export interface AgentProfileMcpServer {
-    transport?: "stdio" | "sse" | "http";
-    command?: string;
+interface AgentProfileMcpServerBase {
+    metadata?: Record<string, unknown>;
+}
+interface AgentProfileLocalMcpServer extends AgentProfileMcpServerBase {
+    enabled?: true;
+    transport?: "stdio";
+    command: string;
     args?: string[];
     env?: Record<string, string>;
     cwd?: string;
-    url?: string;
+    url?: never;
+    headers?: never;
+}
+interface AgentProfileRemoteMcpServer extends AgentProfileMcpServerBase {
+    enabled?: true;
+    transport?: "sse" | "http";
+    command?: never;
+    args?: never;
+    env?: never;
+    cwd?: never;
+    url: string;
     headers?: Record<string, string>;
-    enabled?: boolean;
-    metadata?: Record<string, unknown>;
 }
+interface AgentProfileDisabledMcpServer extends AgentProfileMcpServerBase {
+    enabled: false;
+    transport?: never;
+    command?: never;
+    args?: never;
+    env?: never;
+    cwd?: never;
+    url?: never;
+    headers?: never;
+}
+export type AgentProfileMcpServer = AgentProfileLocalMcpServer | AgentProfileRemoteMcpServer | AgentProfileDisabledMcpServer;
 /**
  * Hub-managed integration grant. The sandbox runtime resolves each declared
  * connection/capability pair into an MCP tool backed by Tangle Hub policy.
@@ -317,3 +340,4 @@ export interface AgentProfileValidationResult {
  * Overlay fields win on conflicts. Array-like instruction sets are appended.
  */
 export declare function mergeAgentProfiles(base: AgentProfile | undefined, overlay: AgentProfile | undefined): AgentProfile | undefined;
+export {};

package/dist/harness-capabilities.d.ts

@@ -11,8 +11,8 @@ import { type HarnessType } from "./harness.js";
  * cli-bridge backends, the sandbox UI pickers, and the router all read one truth instead of each
  * hand-rolling a divergent copy.
  *
- * Grounded in cli-bridge's real backend clamps (codex is `low..xhigh` for current models, kimi is
- * binary on/off, claude carries the full range, cli-base has no agent) — NOT a guessed matrix. The
+ * Grounded in the native CLI controls (Codex is `minimal..ultra`, Kimi is binary on/off, Claude is
+ * `low..max`, cli-base has no agent) — NOT a guessed matrix. The
  * per-MODEL reasoning capability (does this specific model reason at all) is dynamic catalog data the
  * caller supplies.
  */

package/dist/harness-capabilities.js

@@ -10,8 +10,8 @@ import { canonicalizeHarness } from "./harness.js";
  * cli-bridge backends, the sandbox UI pickers, and the router all read one truth instead of each
  * hand-rolling a divergent copy.
  *
- * Grounded in cli-bridge's real backend clamps (codex is `low..xhigh` for current models, kimi is
- * binary on/off, claude carries the full range, cli-base has no agent) — NOT a guessed matrix. The
+ * Grounded in the native CLI controls (Codex is `minimal..ultra`, Kimi is binary on/off, Claude is
+ * `low..max`, cli-base has no agent) — NOT a guessed matrix. The
  * per-MODEL reasoning capability (does this specific model reason at all) is dynamic catalog data the
  * caller supplies.
  */
@@ -125,21 +125,30 @@ export function snapHarnessToModel(harness, modelId) {
 /**
  * The explicit reasoning-effort set a harness's runtime accepts when it ISN'T a plain `none…ceiling`
  * slice — grounded in the cli-bridge adapters (NOT the canonical ladder):
- *   - codex: current models advertise `low|medium|high|xhigh`; `none` is omitted (use `auto`) and
- *     legacy `minimal` requests clamp up to `low`.
- *   - claude-code: `--effort` accepts `low|medium|high|xhigh|max`. `ultracode` is the ladder's stand-in
- *     for claude's `max` (clamped at runtime); `minimal`→`low` and `none`/`auto`→no flag, so both are
- *     dropped as redundant.
- *   - pi / openclaw: `--thinking` accepts `minimal…xhigh` (max/ultracode clamp to `xhigh`; no `none`).
- *   - kimi-code: `--thinking` is BINARY (off/on) — `minimal` is the only value that emits
- *     `--no-thinking`, `high` is "thinking on". So two levels, not five.
+ *   - codex: `model_reasoning_effort` accepts `minimal|low|medium|high|xhigh|max|ultra`; canonical
+ *     `ultracode` maps to native `ultra`. Per-model catalog data narrows this list.
+ *   - claude-code: `--effort` accepts `low|medium|high|xhigh|max`; canonical `ultracode` maps to
+ *     native `max`. It cannot express `none` or `minimal`.
+ *   - pi: `--thinking` accepts `off|minimal|low|medium|high|xhigh`; canonical `none` maps to `off`.
+ *   - openclaw: `--thinking` accepts `off|minimal|low|medium|high|xhigh|max`; canonical `none` maps
+ *     to `off` and `ultracode` maps to `max`.
+ *   - kimi-code: `--thinking` is binary. Canonical `none` emits `--no-thinking`; any non-none level
+ *     emits `--thinking`, represented here by `high`.
  */
 const harnessReasoningEffortsOverride = {
-    codex: ["low", "medium", "high", "xhigh"],
+    codex: ["minimal", "low", "medium", "high", "xhigh", "ultracode"],
     "claude-code": ["low", "medium", "high", "xhigh", "ultracode"],
-    pi: ["minimal", "low", "medium", "high", "xhigh"],
-    openclaw: ["minimal", "low", "medium", "high", "xhigh"],
-    "kimi-code": ["minimal", "high"],
+    pi: ["none", "minimal", "low", "medium", "high", "xhigh"],
+    openclaw: [
+        "none",
+        "minimal",
+        "low",
+        "medium",
+        "high",
+        "xhigh",
+        "ultracode",
+    ],
+    "kimi-code": ["none", "high"],
 };
 /**
  * The ceiling for harnesses whose set IS a plain `none…ceiling` slice. Only the no-thinking runners