zidane 2.1.1 → 2.2.0

package/README.md

@@ -20,12 +20,12 @@ bun start --prompt "create a hello world app"
 
 ```ts
 import { createAgent } from 'zidane'
-import { basic } from 'zidane/harnesses'
+import { basic } from 'zidane/presets'
 import { anthropic } from 'zidane/providers'
 
 const agent = createAgent({
+  ...basic,
   provider: anthropic({ apiKey: 'sk-ant-...' }),
-  harness: basic,
 })
 
 const stats = await agent.run({ prompt: 'build a REST API' })
@@ -37,8 +37,11 @@ All options on `createAgent`:
 ```ts
 createAgent({
   provider,                          // required: LLM provider
+  name: 'basic',                     // optional display name (shown in traces/logs)
+  system: 'You are a helpful...',    // default system prompt
+  tools: { shell, readFile },        // tool set (default: no tools)
+  toolAliases: { shell: 'Bash' },    // map canonical names to LLM-facing names
   session,                           // session for persistence
-  harness: basic,                    // tool set (default: noTools)
   behavior: {                        // agent-level defaults
     toolExecution: 'parallel',       // or 'sequential' (default: parallel)
     maxTurns: 50,                    // max loop iterations
@@ -51,6 +54,12 @@ createAgent({
 })
 ```
 
+Presets are just `Partial<AgentOptions>` — spread them in, override any field:
+
+```ts
+createAgent({ ...basic, provider, system: 'be concise' })
+```
+
 All options on `agent.run()`:
 
 ```ts
@@ -72,7 +81,7 @@ await agent.run({
 
 `prompt` is optional when a session with existing turns is provided — the agent resumes from the last turn. This supports apps where the user message is persisted to the session before the agent runs (e.g. WebSocket → session → queue → agent).
 
-Precedence: `run.behavior` > `agent.behavior` > `harness.behavior` > hardcoded defaults.
+Precedence: `run.behavior` > `agent.behavior` > hardcoded defaults.
 
 ## CLI
 
@@ -81,7 +90,7 @@ bun start \
   --prompt "your task"    \   # required
   --model claude-opus-4-6 \   # model id
   --provider anthropic    \   # anthropic | openai | openrouter | cerebras
-  --harness basic         \   # tool set
+  --preset basic          \   # preset name
   --system "be concise"   \   # system prompt
   --thinking off          \   # off | minimal | low | medium | high
   --context process       \   # process | docker
@@ -139,9 +148,11 @@ cerebras({ apiKey: 'csk-...', defaultModel: 'zai-glm-4.7' })
 
 Fallback: `params.apiKey` > `CEREBRAS_API_KEY` env
 
-## Harnesses
+## Presets
+
+Reusable slices of `AgentOptions` — spread them into `createAgent()`.
 
-Tools are grouped into **harnesses**. The `basic` harness includes:
+The `basic` preset bundles:
 
 | Tool | Description |
 |---|---|
@@ -151,22 +162,25 @@ Tools are grouped into **harnesses**. The `basic` harness includes:
 | `list_files` | List directory contents |
 | `spawn` | Spawn a sub-agent |
 
-Define a custom harness:
+Define a custom preset:
 
 ```ts
-import { defineHarness, basicTools } from 'zidane/harnesses'
+import { basicTools, definePreset } from 'zidane/presets'
 
-const harness = defineHarness({
+const researcher = definePreset({
   name: 'researcher',
   system: 'You are a research assistant.',
   tools: { ...basicTools },
 })
+
+createAgent({ ...researcher, provider })
 ```
 
-For pure chat with no tools, pass `tools: {}` on a specific run or use the `noTools` harness:
+For pure chat with no tools, omit `tools` or pass `{}` at run time:
 
 ```ts
-await agent.run({ prompt: 'just chat', tools: {} })
+createAgent({ provider })                                 // no tools
+await agent.run({ prompt: 'just chat', tools: {} })       // override for one run
 ```
 
 ## Thinking
@@ -189,7 +203,7 @@ await agent.run({ prompt: 'solve this', thinking: 'high' })
 await agent.run({ prompt: 'solve this', thinking: 'high', behavior: { thinkingBudget: 50000 } })
 
 // Agent-level default
-const agent = createAgent({ provider, harness, behavior: { thinkingBudget: 16384 } })
+const agent = createAgent({ ...basic, provider, behavior: { thinkingBudget: 16384 } })
 ```
 
 Thinking traces are stored in session turns as `{ type: 'thinking', text }` content blocks and streamed live via the `stream:thinking` hook. Supported by Anthropic (native) and OpenRouter/Cerebras (`reasoning_content`/`reasoning` SSE fields).
@@ -314,10 +328,10 @@ agent.followUp('now write tests for what you built')
 The `spawn` tool delegates tasks to child agents that run independently.
 
 ```ts
+import { basicTools, definePreset } from 'zidane/presets'
 import { createSpawnTool } from 'zidane/tools'
-import { defineHarness, basicTools } from 'zidane/harnesses'
 
-const harness = defineHarness({
+const orchestrator = definePreset({
   name: 'orchestrator',
   tools: {
     ...basicTools,
@@ -330,15 +344,15 @@ const harness = defineHarness({
 })
 ```
 
-Children inherit the parent's harness and can spawn their own children.
+Children inherit the parent's preset (tools, system prompt, aliases, MCP servers, skills, behavior) and can spawn their own children. Pass `preset` on `createSpawnTool()` to override the inherited slice per child.
 
 ## Interaction Tool
 
-Let the agent pause and request structured input from the outside world. Not included in any harness by default.
+Let the agent pause and request structured input from the outside world. Not included in any preset by default.
 
 ```ts
+import { basicTools, definePreset } from 'zidane/presets'
 import { createInteractionTool } from 'zidane/tools'
-import { defineHarness, basicTools } from 'zidane/harnesses'
 
 const askUser = createInteractionTool({
   name: 'ask_user',
@@ -353,7 +367,7 @@ const askUser = createInteractionTool({
   },
 })
 
-const harness = defineHarness({
+const interactive = definePreset({
   name: 'interactive',
   tools: { ...basicTools, ask_user: askUser },
 })
@@ -371,7 +385,7 @@ import { createAgent, createSession, createSqliteStore } from 'zidane'
 const store = createSqliteStore({ path: './sessions.db' })
 const session = await createSession({ store })
 
-const agent = createAgent({ harness, provider, session })
+const agent = createAgent({ ...basic, provider, session })
 await agent.run({ prompt: 'hello' })
 await session.save()
 ```
@@ -395,7 +409,7 @@ import { loadSession } from 'zidane/session'
 
 const session = await loadSession(store, 'my-session')
 if (session) {
-  const agent = createAgent({ harness, provider, session })
+  const agent = createAgent({ ...basic, provider, session })
   await agent.run({ prompt: 'continue' })
 }
 ```
@@ -414,7 +428,7 @@ Connect any MCP-compatible tool server. Tools are namespaced as `mcp_{server}_{t
 
 ```ts
 const agent = createAgent({
-  harness,
+  ...basic,
   provider,
   mcpServers: [
     { name: 'fs', transport: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem', '.'] },
@@ -423,7 +437,7 @@ const agent = createAgent({
 })
 ```
 
-MCP servers can also be declared on the harness. Connections are lazy (first `run()`) and reused.
+MCP servers can live on a preset too (they're just `AgentOptions` fields). Connections are lazy (first `run()`) and reused.
 
 ## Skills
 
@@ -467,7 +481,7 @@ Scan paths in priority order (first found wins):
 import { createAgent, defineSkill } from 'zidane'
 
 const agent = createAgent({
-  harness,
+  ...basic,
   provider,
   skills: {
     scan: ['./custom-skills'],
@@ -496,7 +510,7 @@ An execution context defines **where** tools run. Defaults to in-process.
 import { createAgent, createDockerContext } from 'zidane'
 
 const agent = createAgent({
-  harness,
+  ...basic,
   provider,
   execution: createDockerContext({
     image: 'node:22',
@@ -514,7 +528,7 @@ Implement `SandboxProvider` for your provider (E2B, Rivet, etc.):
 import { createAgent, createSandboxContext } from 'zidane'
 
 const agent = createAgent({
-  harness,
+  ...basic,
   provider,
   execution: createSandboxContext(myProvider),
 })

package/dist/{agent-DFkSTVKm.d.ts → agent-vPBFXnu-.d.ts}

@@ -6,7 +6,7 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
  * Typed error classes for agent runs.
  *
  * Providers classify native errors into one of these so downstream consumers
- * (e.g. harness adapters) can react without string-sniffing messages.
+ * can react without string-sniffing messages.
  *
  * Provider authors: implement `Provider.classifyError` to map native errors
  * (SDK exceptions, HTTP responses) to a `ClassifiedError`. The loop wraps
@@ -310,9 +310,9 @@ interface AgentRunOptions {
     images?: ImageContent[];
     /** Abort signal — when triggered, the agent stops after the current turn */
     signal?: AbortSignal;
-    /** Behavior overrides for this run (overrides agent and harness defaults) */
+    /** Behavior overrides for this run (overrides agent defaults) */
     behavior?: AgentBehavior;
-    /** Tool overrides for this run. Pass {} for no tools. Omit to use harness tools. */
+    /** Tool overrides for this run. Pass {} for no tools. Omit to use agent tools. */
     tools?: Record<string, ToolDef>;
     /**
      * Per-run hook registrations. Each hook is attached before the run starts and
@@ -405,11 +405,11 @@ interface ChildRunStats {
 /**
  * Base context for tool execution hooks.
  *
- * `name` is the canonical tool identity — the spec name defined in the harness (or the
+ * `name` is the canonical tool identity — the spec name registered on the agent (or the
  * `mcp_{server}_{tool}` name for MCP tools). Hooks should policy-match against `name`.
  *
  * `displayName` is the outward-facing name — the alias surfaced to the LLM when
- * `HarnessConfig.toolAliases` maps the canonical name; otherwise equal to `name`.
+ * `AgentOptions.toolAliases` maps the canonical name; otherwise equal to `name`.
  * UI/telemetry adapters should emit `displayName`.
  *
  * Canonical vs. alias matters on session resume: `session.turns` persists canonical
@@ -418,7 +418,7 @@ interface ChildRunStats {
 interface ToolHookContext {
     turnId: string;
     callId: string;
-    /** Canonical tool name (harness spec name). Stable across alias-map changes. */
+    /** Canonical tool name (spec name). Stable across alias-map changes. */
     name: string;
     /** Aliased (wire) name — equal to `name` when no alias is defined. */
     displayName: string;
@@ -430,8 +430,8 @@ interface ToolHookContext {
  * `tool` is the native tool name on the MCP server. `server` is the configured server
  * name. The canonical zidane-namespaced identity is `mcp_{server}_{tool}`.
  *
- * `displayName` equals the canonical namespaced name unless the harness has aliased
- * this MCP tool via `HarnessConfig.toolAliases`; in which case `displayName` is the
+ * `displayName` equals the canonical namespaced name unless the agent has aliased
+ * this MCP tool via `AgentOptions.toolAliases`; in which case `displayName` is the
  * alias that the LLM sees.
  */
 interface McpToolHookContext {
@@ -1130,18 +1130,12 @@ interface SkillsConfig {
     trustProjectSkills?: boolean;
 }
 
-/** Core tools available in every basic harness (without spawn) */
-declare const basicTools: {
-    shell: ToolDef;
-    readFile: ToolDef;
-    writeFile: ToolDef;
-    listFiles: ToolDef;
-};
-declare const _default: HarnessConfig;
-
 /**
  * Runtime context passed to every tool execution.
  * Provides access to the agent's provider, abort signal, execution environment, and hooks.
+ *
+ * The preset-y fields (`name`, `system`, `tools`, `toolAliases`, `mcpServers`, `skills`,
+ * `behavior`) mirror the agent's own options so child-spawning tools can inherit them.
  */
 interface ToolContext {
     /** The LLM provider for this agent run */
@@ -1154,8 +1148,29 @@ interface ToolContext {
     handle: ExecutionHandle;
     /** Agent hooks for emitting events (e.g. spawn:complete) */
     hooks: Hookable<AgentHooks>;
-    /** The harness config for this agent (tools available to the agent) */
-    harness: HarnessConfig;
+    /** Agent display name (preset or user-supplied) */
+    name?: string;
+    /** Agent default system prompt */
+    system?: string;
+    /** Source tool map the agent was created with (pre-MCP-merge, pre-skills-injection) */
+    tools: Record<string, ToolDef>;
+    /**
+     * Map canonical tool names to LLM-facing (aliased) names.
+     *
+     * Aliasing is **LLM-boundary-only**:
+     * - The alias is what the provider's tool spec carries, what the model calls it, and
+     *   what appears in `ToolHookContext.displayName` / `McpToolHookContext.displayName`.
+     * - The canonical name is what lives in `session.turns`, `ToolHookContext.name`, and
+     *   what the agent uses to look up the tool implementation. Alias changes never
+     *   desync persisted history.
+     */
+    toolAliases?: Record<string, string>;
+    /** MCP servers configured on the agent (for child inheritance) */
+    mcpServers?: McpServerConfig[];
+    /** Skills configuration (for child inheritance) */
+    skills?: SkillsConfig;
+    /** Behavior defaults (for child inheritance) */
+    behavior?: AgentBehavior;
     /** Turn ID that requested this tool call */
     turnId: string;
     /** Tool call ID from the model */
@@ -1196,55 +1211,6 @@ interface ToolDef {
     execute: (input: Record<string, unknown>, ctx: ToolContext) => Promise<string | ToolResultContent[]>;
 }
 type ToolMap = Map<string, ToolDef>;
-interface HarnessConfig {
-    /** Display name for this harness */
-    name: string;
-    /** Default system prompt injected when no system is provided at run time */
-    system?: string;
-    /** Tool definitions available to the agent */
-    tools: Record<string, ToolDef>;
-    /** MCP servers to connect and expose as tools */
-    mcpServers?: McpServerConfig[];
-    /** Skills configuration at the harness level */
-    skills?: SkillsConfig;
-    /** Default behavior for agents using this harness */
-    behavior?: AgentBehavior;
-    /**
-     * Map canonical tool names to LLM-facing (aliased) names.
-     *
-     * Aliasing is **LLM-boundary-only**:
-     * - The alias is what the provider's tool spec carries, what the model calls it, and
-     *   what appears in `ToolHookContext.displayName` / `McpToolHookContext.displayName`.
-     * - The canonical name is what lives in `session.turns`, `ToolHookContext.name`, and
-     *   what the agent uses to look up the tool implementation. Alias changes never
-     *   desync persisted history.
-     *
-     * Keys are canonical names from `tools` (or `mcp_{server}_{tool}` for MCP tools).
-     * Collisions between aliases are rejected by the loop.
-     *
-     * @example
-     * ```ts
-     * defineHarness({
-     *   tools: { ...basicTools },
-     *   toolAliases: { shell: 'Bash', read_file: 'Read', write_file: 'Write' },
-     * })
-     * ```
-     *
-     * @remarks Alias a tool only when the aliased name is semantically equivalent.
-     * `list_files` → `Glob` is NOT a valid alias because Glob is pattern-based.
-     */
-    toolAliases?: Record<string, string>;
-}
-/**
- * Define a harness with a name, optional system prompt, and tools.
- */
-declare function defineHarness(config: HarnessConfig): HarnessConfig;
-type Harness = HarnessConfig;
-/**
- * A harness with no tools — for pure chat mode.
- * Pass `tools: {}` in agent.run() or use this harness directly.
- */
-declare const noTools: HarnessConfig;
 
 /**
  * MCP (Model Context Protocol) server support.
@@ -1298,7 +1264,7 @@ declare function normalizeMcpBlocks(content: unknown): ToolResultContent[] | nul
  * Connect to MCP servers and discover their tools.
  *
  * Each tool is namespaced as `mcp_{serverName}_{toolName}` to avoid
- * collisions with harness tools or tools from other servers.
+ * collisions with agent tools or tools from other servers.
  *
  * @param configs - Array of MCP server configurations
  * @param _clientFactory - Internal: override client construction for testing
@@ -1544,9 +1510,21 @@ interface AgentHooks {
     'session:save': (ctx: SessionHookContext) => void;
 }
 interface AgentOptions {
-    /** Harness (tools + system prompt). Defaults to a no-tools harness if omitted. */
-    harness?: HarnessConfig;
     provider: Provider;
+    /** Display name for the agent (used in traces/logs). */
+    name?: string;
+    /** Default system prompt injected when no system is provided at run time. */
+    system?: string;
+    /** Tool definitions available to the agent. Defaults to no tools. */
+    tools?: Record<string, ToolDef>;
+    /**
+     * Map canonical tool names to LLM-facing (aliased) names.
+     *
+     * Aliasing is **LLM-boundary-only**: the alias is what the provider's tool spec
+     * carries and what the model calls the tool; the canonical name is what lives in
+     * `session.turns` and what the agent uses to look up the tool implementation.
+     */
+    toolAliases?: Record<string, string>;
     /** Agent-level behavior defaults (overridden by run-level behavior) */
     behavior?: AgentBehavior;
     /** Execution context: where tools run. Defaults to in-process. */
@@ -1555,7 +1533,7 @@ interface AgentOptions {
     mcpServers?: McpServerConfig[];
     /** Session for identity, turn persistence, and run tracking */
     session?: Session;
-    /** Skills configuration (merged with harness-level skills, agent takes precedence) */
+    /** Skills configuration */
     skills?: SkillsConfig;
     /** @internal */
     _mcpConnector?: (configs: McpServerConfig[]) => Promise<McpConnection>;
@@ -1599,6 +1577,6 @@ interface Agent {
     readonly activeSkills: readonly ActiveSkill[];
     meta: Record<string, unknown>;
 }
-declare function createAgent({ harness: harnessOption, provider, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, _mcpConnector }: AgentOptions): Agent;
+declare function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, _mcpConnector }: AgentOptions): Agent;
 
-export { type ToolDef as $, type Agent as A, type SessionContentBlock as B, CONTEXT_EXCEEDED_MESSAGE_PATTERNS as C, type SessionData as D, type SessionEndStatus as E, type SessionHookContext as F, type SessionMessage as G, type Harness as H, type ImageContent as I, type SessionRun as J, type SessionStore as K, type SessionTurn as L, type McpConnection as M, type SkillConfig as N, type OAuthRefreshHookContext as O, type PromptDocumentPart as P, type SkillResource as Q, type RemoteStoreOptions as R, type Session as S, type SkillsConfig as T, type SpawnHookContext as U, type StreamCallbacks as V, type StreamHookContext as W, type StreamOptions as X, type ThinkingLevel as Y, type ToolCall as Z, type ToolContext as _, AgentAbortedError as a, type ToolExecutionMode as a0, type ToolHookContext as a1, type ToolMap as a2, type ToolResult as a3, type ToolResultContent as a4, type ToolResultImageContent as a5, type ToolResultTextContent as a6, type ToolSpec as a7, type TurnFinishReason as a8, type TurnResult as a9, defineHarness as aA, fromAnthropic as aB, fromOpenAI as aC, loadSession as aD, mapOAIFinishReason as aE, noTools as aF, normalizeMcpBlocks as aG, normalizeMcpServers as aH, openai as aI, openaiCompat as aJ, openrouter as aK, resultToString as aL, toAnthropic as aM, toOpenAI as aN, toTypedError as aO, _default as aP, basicTools as aQ, type TurnUsage as aa, matchesContextExceeded as ab, toolResultToText as ac, type ActivationVia as ad, type ActiveSkill as ae, type DeactivationReason as af, type FileMapAdapter as ag, type FileMapStoreOptions as ah, type OpenAICompatAuthHeader as ai, OpenAICompatHttpError as aj, type OpenAICompatParams as ak, type SkillActivationState as al, type SkillActivationStateOptions as am, type SkillDiagnostic as an, type SkillSource as ao, anthropic as ap, autoDetectAndConvert as aq, cerebras as ar, classifyOpenAICompatError as as, connectMcpServers as at, createAgent as au, createFileMapStore as av, createMemoryStore as aw, createRemoteStore as ax, createSession as ay, createSkillActivationState as az, type AgentBehavior as b, AgentContextExceededError as c, type AgentHooks as d, type AgentOptions as e, AgentProviderError as f, type AgentRunOptions as g, type AgentStats as h, AgentToolNotAllowedError as i, type AnthropicParams as j, type CerebrasParams as k, type ChildRunStats as l, type ClassifiedError as m, type ClassifiedErrorKind as n, type CreateSessionOptions as o, type HarnessConfig as p, type McpServerConfig as q, type McpToolHookContext as r, type OpenAIParams as s, type OpenRouterParams as t, type PromptImagePart as u, type PromptPart as v, type PromptTextPart as w, type Provider as x, type ProviderCapabilities as y, type RunHookMap as z };
+export { type ToolHookContext as $, type Agent as A, type SessionData as B, CONTEXT_EXCEEDED_MESSAGE_PATTERNS as C, type SessionEndStatus as D, type SessionHookContext as E, type SessionMessage as F, type SessionRun as G, type SessionStore as H, type ImageContent as I, type SessionTurn as J, type SkillConfig as K, type SkillResource as L, type McpConnection as M, type SkillsConfig as N, type OAuthRefreshHookContext as O, type PromptDocumentPart as P, type SpawnHookContext as Q, type RemoteStoreOptions as R, type Session as S, type StreamCallbacks as T, type StreamHookContext as U, type StreamOptions as V, type ThinkingLevel as W, type ToolCall as X, type ToolContext as Y, type ToolDef as Z, type ToolExecutionMode as _, AgentAbortedError as a, type ToolMap as a0, type ToolResult as a1, type ToolResultContent as a2, type ToolResultImageContent as a3, type ToolResultTextContent as a4, type ToolSpec as a5, type TurnFinishReason as a6, type TurnResult as a7, type TurnUsage as a8, matchesContextExceeded as a9, loadSession as aA, mapOAIFinishReason as aB, normalizeMcpBlocks as aC, normalizeMcpServers as aD, openai as aE, openaiCompat as aF, openrouter as aG, resultToString as aH, toAnthropic as aI, toOpenAI as aJ, toTypedError as aK, toolResultToText as aa, type ActivationVia as ab, type ActiveSkill as ac, type DeactivationReason as ad, type FileMapAdapter as ae, type FileMapStoreOptions as af, type OpenAICompatAuthHeader as ag, OpenAICompatHttpError as ah, type OpenAICompatParams as ai, type SkillActivationState as aj, type SkillActivationStateOptions as ak, type SkillDiagnostic as al, type SkillSource as am, anthropic as an, autoDetectAndConvert as ao, cerebras as ap, classifyOpenAICompatError as aq, connectMcpServers as ar, createAgent as as, createFileMapStore as at, createMemoryStore as au, createRemoteStore as av, createSession as aw, createSkillActivationState as ax, fromAnthropic as ay, fromOpenAI as az, type AgentBehavior as b, AgentContextExceededError as c, type AgentHooks as d, type AgentOptions as e, AgentProviderError as f, type AgentRunOptions as g, type AgentStats as h, AgentToolNotAllowedError as i, type AnthropicParams as j, type CerebrasParams as k, type ChildRunStats as l, type ClassifiedError as m, type ClassifiedErrorKind as n, type CreateSessionOptions as o, type McpServerConfig as p, type McpToolHookContext as q, type OpenAIParams as r, type OpenRouterParams as s, type PromptImagePart as t, type PromptPart as u, type PromptTextPart as v, type Provider as w, type ProviderCapabilities as x, type RunHookMap as y, type SessionContentBlock as z };

package/dist/{chunk-IJORSHFI.js → chunk-37GD7NL3.js}

@@ -167,7 +167,7 @@ async function connectMcpServers(configs, _clientFactory, hooks) {
           },
           execute: async (input, ctx) => {
             const { turnId, callId, signal } = ctx;
-            const displayName = ctx.harness?.toolAliases?.[namespacedName] ?? namespacedName;
+            const displayName = ctx.toolAliases?.[namespacedName] ?? namespacedName;
             const gateCtx = {
               turnId,
               callId,

package/dist/{chunk-HJUB63VE.js → chunk-BW3WTFIR.js}

@@ -1,6 +1,6 @@
 import {
   validateSkillForWrite
-} from "./chunk-DCYJYM3E.js";
+} from "./chunk-TPXPVEH6.js";
 
 // src/skills/index.ts
 function defineSkill(config) {

package/dist/{chunk-AWDWJ2YJ.js → chunk-F5UBXERT.js}

@@ -3,16 +3,15 @@ import {
   createSkillActivationState,
   installAllowedToolsGate,
   interpolateShellCommands,
-  mergeSkillsConfig,
   resolveSkills,
   validateResourcePath
-} from "./chunk-DCYJYM3E.js";
+} from "./chunk-TPXPVEH6.js";
 import {
   createProcessContext
 } from "./chunk-2EQT4EHD.js";
 import {
   connectMcpServers
-} from "./chunk-IJORSHFI.js";
+} from "./chunk-37GD7NL3.js";
 import {
   AgentAbortedError,
   AgentProviderError,
@@ -775,7 +774,13 @@ async function executeSingleTool(ctx, call, turnId) {
       execution: ctx.execution,
       handle: ctx.handle,
       hooks: ctx.hooks,
-      harness: ctx.harness,
+      tools: ctx.agentTools,
+      ...ctx.agentName !== void 0 ? { name: ctx.agentName } : {},
+      ...ctx.agentSystem !== void 0 ? { system: ctx.agentSystem } : {},
+      ...ctx.agentToolAliases !== void 0 ? { toolAliases: ctx.agentToolAliases } : {},
+      ...ctx.agentMcpServers !== void 0 ? { mcpServers: ctx.agentMcpServers } : {},
+      ...ctx.agentSkills !== void 0 ? { skills: ctx.agentSkills } : {},
+      ...ctx.agentBehavior !== void 0 ? { behavior: ctx.agentBehavior } : {},
       turnId,
       callId,
       runId: ctx.runId,
@@ -927,7 +932,6 @@ function buildPromptMessage(provider, parts) {
 }
 
 // src/agent.ts
-var noTools = { name: "none", system: "You are a helpful assistant.", tools: {} };
 var HOOK_EVENT_NAMES = [
   "system:before",
   "turn:before",
@@ -979,37 +983,37 @@ var HOOK_EVENT_SET = new Set(HOOK_EVENT_NAMES);
 function isKnownHookEvent(event) {
   return HOOK_EVENT_SET.has(event);
 }
-function resolveBehavior(harnessBehavior, agentBehavior, runBehavior) {
+function resolveBehavior(agentBehavior, runBehavior) {
   return {
-    toolExecution: runBehavior?.toolExecution ?? agentBehavior?.toolExecution ?? harnessBehavior?.toolExecution ?? "parallel",
-    maxTurns: runBehavior?.maxTurns ?? agentBehavior?.maxTurns ?? harnessBehavior?.maxTurns,
-    maxTokens: runBehavior?.maxTokens ?? agentBehavior?.maxTokens ?? harnessBehavior?.maxTokens,
-    thinkingBudget: runBehavior?.thinkingBudget ?? agentBehavior?.thinkingBudget ?? harnessBehavior?.thinkingBudget,
-    schema: runBehavior?.schema ?? agentBehavior?.schema ?? harnessBehavior?.schema
+    toolExecution: runBehavior?.toolExecution ?? agentBehavior?.toolExecution ?? "parallel",
+    maxTurns: runBehavior?.maxTurns ?? agentBehavior?.maxTurns,
+    maxTokens: runBehavior?.maxTokens ?? agentBehavior?.maxTokens,
+    thinkingBudget: runBehavior?.thinkingBudget ?? agentBehavior?.thinkingBudget,
+    schema: runBehavior?.schema ?? agentBehavior?.schema
   };
 }
-function createAgent({ harness: harnessOption, provider, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, _mcpConnector }) {
+function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, _mcpConnector }) {
   const hooks = createHooks();
-  const harness = harnessOption ?? noTools;
   const executionContext = execution ?? createProcessContext();
+  const sourceTools = agentTools ?? {};
   let abortController;
   let running = false;
   let idleResolve;
   let idlePromise;
   let executionHandle = null;
   let mcpConnection = null;
-  const allMcpServers = [...harness.mcpServers ?? [], ...mcpServers ?? []];
+  const allMcpServers = mcpServers ?? [];
   const steeringQueue = [];
   const followUpQueue = [];
   let conversationTurns = session?.turns.slice() ?? [];
   let runCounter = session?.runs.length ?? 0;
-  const mergedSkillsConfig = mergeSkillsConfig(harness.skills, agentSkills);
-  const skillsEnabledValue = mergedSkillsConfig?.enabled;
+  const skillsConfig = agentSkills;
+  const skillsEnabledValue = skillsConfig?.enabled;
   const skillsDisabled = skillsEnabledValue === false || Array.isArray(skillsEnabledValue) && skillsEnabledValue.length === 0;
   let resolvedSkills = null;
   let skillsCatalog = null;
   const skillActivationState = createSkillActivationState({
-    maxActive: mergedSkillsConfig?.maxActive
+    maxActive: skillsConfig?.maxActive
   });
   async function run(options) {
     if (running) {
@@ -1078,10 +1082,10 @@ function createAgent({ harness: harnessOption, provider, behavior: agentBehavior
         mcpConnection = await connectMcpServers(allMcpServers, void 0, hooks);
       }
     }
-    if (!skillsDisabled && mergedSkillsConfig && !resolvedSkills) {
-      resolvedSkills = await resolveSkills(mergedSkillsConfig);
+    if (!skillsDisabled && skillsConfig && !resolvedSkills) {
+      resolvedSkills = await resolveSkills(skillsConfig);
       await hooks.callHook("skills:resolve", { skills: resolvedSkills });
-      const skillsToolRegistered = mergedSkillsConfig?.tool !== false && resolvedSkills.length > 0;
+      const skillsToolRegistered = skillsConfig?.tool !== false && resolvedSkills.length > 0;
       const catalogCtx = {
         catalog: buildCatalog(resolvedSkills, { skillsToolRegistered }),
         skills: resolvedSkills
@@ -1111,17 +1115,17 @@ function createAgent({ harness: harnessOption, provider, behavior: agentBehavior
     }
     const thinking = options.thinking ?? "off";
     const model = options.model ?? provider.meta.defaultModel;
-    const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema } = resolveBehavior(harness.behavior, agentBehavior, options.behavior);
-    let system = options.system || harness.system || "You are a helpful assistant.";
+    const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema } = resolveBehavior(agentBehavior, options.behavior);
+    let system = options.system || agentSystem || "You are a helpful assistant.";
     if (skillsCatalog) {
       system = `${system}
 
 ${skillsCatalog}`;
     }
-    const baseTools = options.tools !== void 0 ? options.tools : mcpConnection ? { ...harness.tools, ...mcpConnection.tools } : harness.tools;
-    const shouldInjectSkillTools = options.tools === void 0 && !!resolvedSkills && resolvedSkills.length > 0 && mergedSkillsConfig?.tool !== false;
+    const runBaseTools = options.tools !== void 0 ? options.tools : mcpConnection ? { ...sourceTools, ...mcpConnection.tools } : sourceTools;
+    const shouldInjectSkillTools = options.tools === void 0 && !!resolvedSkills && resolvedSkills.length > 0 && skillsConfig?.tool !== false;
     const mergedWithSkills = shouldInjectSkillTools ? {
-      // Auto-injected first so harness + MCP tools can override by name.
+      // Auto-injected first so agent + MCP tools can override by name.
       skills_use: createSkillsUseTool({
         catalog: resolvedSkills,
         state: skillActivationState,
@@ -1134,15 +1138,15 @@ ${skillsCatalog}`;
       skills_run_script: createSkillsRunScriptTool({
         catalog: resolvedSkills,
         state: skillActivationState,
-        scriptTimeoutMs: mergedSkillsConfig?.scriptTimeoutMs
+        scriptTimeoutMs: skillsConfig?.scriptTimeoutMs
       }),
-      ...baseTools
-    } : baseTools;
+      ...runBaseTools
+    } : runBaseTools;
     const tools = {};
     for (const tool of Object.values(mergedWithSkills)) {
       tools[tool.spec.name] = tool;
     }
-    const aliasMaps = buildAliasMaps(harness.toolAliases, Object.keys(tools));
+    const aliasMaps = buildAliasMaps(toolAliases, Object.keys(tools));
     const toolSpecs = Object.values(tools).map(
       (t) => ({
         name: aliasMaps.aliasByCanonical.get(t.spec.name) ?? t.spec.name,
@@ -1211,7 +1215,13 @@ ${skillsCatalog}`;
       const stats = await runLoop({
         provider,
         hooks,
-        harness,
+        agentName,
+        agentSystem,
+        agentTools: sourceTools,
+        agentToolAliases: toolAliases,
+        agentMcpServers: mcpServers,
+        agentSkills,
+        agentBehavior,
         tools,
         formattedTools,
         aliasMaps,
@@ -1322,7 +1332,7 @@ ${skillsCatalog}`;
     const outcome = skillActivationState.activate(skill, "explicit");
     if (outcome === "cap-reached") {
       throw new Error(
-        `Cannot activate skill "${name}" \u2014 the maxActive cap of ${mergedSkillsConfig?.maxActive} has been reached.`
+        `Cannot activate skill "${name}" \u2014 the maxActive cap of ${skillsConfig?.maxActive} has been reached.`
       );
     }
     if (outcome === "ok")
@@ -1534,8 +1544,18 @@ function createSpawnTool(options = {}) {
       let result = "";
       let unbubble;
       try {
+        const parentPreset = {
+          ...ctx.name !== void 0 ? { name: ctx.name } : {},
+          ...ctx.system !== void 0 ? { system: ctx.system } : {},
+          tools: ctx.tools,
+          ...ctx.toolAliases !== void 0 ? { toolAliases: ctx.toolAliases } : {},
+          ...ctx.mcpServers !== void 0 ? { mcpServers: ctx.mcpServers } : {},
+          ...ctx.skills !== void 0 ? { skills: ctx.skills } : {},
+          ...ctx.behavior !== void 0 ? { behavior: ctx.behavior } : {}
+        };
         const agent = createAgent({
-          harness: options.harness ?? ctx.harness,
+          ...parentPreset,
+          ...options.preset,
           provider: ctx.provider,
           execution: ctx.execution,
           // Share the parent's session on opt-in. Child turns get appended to

package/dist/{chunk-VUVLOTEY.js → chunk-SP5NA6WF.js}

@@ -4,29 +4,23 @@ import {
   shell,
   spawn,
   writeFile
-} from "./chunk-AWDWJ2YJ.js";
+} from "./chunk-F5UBXERT.js";
 
-// src/harnesses/basic.ts
+// src/presets/basic.ts
 var basicTools = { shell, readFile, writeFile, listFiles };
-var basic_default = defineHarness({
+var basic_default = definePreset({
   name: "basic",
   system: "You are a helpful assistant with access to shell, file reading, file writing, directory listing, and sub-agent spawning tools. Use them to accomplish tasks in the project directory.",
   tools: { ...basicTools, spawn }
 });
 
-// src/harnesses/index.ts
-function defineHarness(config) {
+// src/presets/index.ts
+function definePreset(config) {
   return config;
 }
-var noTools = defineHarness({
-  name: "none",
-  system: "You are a helpful assistant.",
-  tools: {}
-});
 
 export {
   basicTools,
   basic_default,
-  defineHarness,
-  noTools
+  definePreset
 };

package/dist/{chunk-DCYJYM3E.js → chunk-TPXPVEH6.js}

@@ -768,26 +768,6 @@ async function resolveSkills(config) {
   }
   return filtered;
 }
-function mergeSkillsConfig(harness, agent) {
-  if (!harness && !agent)
-    return void 0;
-  if (!harness)
-    return agent;
-  if (!agent)
-    return harness;
-  return {
-    // Agent-level takes precedence when explicitly set
-    enabled: agent.enabled !== void 0 ? agent.enabled : harness.enabled,
-    scan: [...harness.scan ?? [], ...agent.scan ?? []],
-    write: [...harness.write ?? [], ...agent.write ?? []],
-    exclude: [.../* @__PURE__ */ new Set([...harness.exclude ?? [], ...agent.exclude ?? []])],
-    skipDefaultPaths: agent.skipDefaultPaths ?? harness.skipDefaultPaths,
-    tool: agent.tool ?? harness.tool,
-    maxActive: agent.maxActive ?? harness.maxActive,
-    scriptTimeoutMs: agent.scriptTimeoutMs ?? harness.scriptTimeoutMs,
-    trustProjectSkills: agent.trustProjectSkills ?? harness.trustProjectSkills
-  };
-}
 
 // src/skills/interpolate.ts
 var SHELL_INTERPOLATION_RE = /!`([^`]+)`/g;
@@ -836,6 +816,5 @@ export {
   writeSkillToDisk,
   writeSkillsToDisk,
   resolveSkills,
-  mergeSkillsConfig,
   interpolateShellCommands
 };

package/dist/index.d.ts

@@ -1,11 +1,12 @@
-import { d as AgentHooks } from './agent-DFkSTVKm.js';
-export { ad as ActivationVia, ae as ActiveSkill, A as Agent, a as AgentAbortedError, b as AgentBehavior, c as AgentContextExceededError, e as AgentOptions, f as AgentProviderError, g as AgentRunOptions, h as AgentStats, i as AgentToolNotAllowedError, j as AnthropicParams, C as CONTEXT_EXCEEDED_MESSAGE_PATTERNS, k as CerebrasParams, m as ClassifiedError, n as ClassifiedErrorKind, o as CreateSessionOptions, af as DeactivationReason, ag as FileMapAdapter, ah as FileMapStoreOptions, H as Harness, p as HarnessConfig, I as ImageContent, M as McpConnection, q as McpServerConfig, r as McpToolHookContext, O as OAuthRefreshHookContext, ai as OpenAICompatAuthHeader, aj as OpenAICompatHttpError, ak as OpenAICompatParams, s as OpenAIParams, t as OpenRouterParams, P as PromptDocumentPart, u as PromptImagePart, v as PromptPart, w as PromptTextPart, x as Provider, y as ProviderCapabilities, R as RemoteStoreOptions, z as RunHookMap, S as Session, B as SessionContentBlock, D as SessionData, E as SessionEndStatus, F as SessionHookContext, G as SessionMessage, J as SessionRun, K as SessionStore, L as SessionTurn, al as SkillActivationState, am as SkillActivationStateOptions, N as SkillConfig, an as SkillDiagnostic, Q as SkillResource, ao as SkillSource, T as SkillsConfig, U as SpawnHookContext, V as StreamCallbacks, W as StreamHookContext, X as StreamOptions, Y as ThinkingLevel, Z as ToolCall, _ as ToolContext, $ as ToolDef, a0 as ToolExecutionMode, a1 as ToolHookContext, a2 as ToolMap, a3 as ToolResult, a4 as ToolResultContent, a5 as ToolResultImageContent, a6 as ToolResultTextContent, a7 as ToolSpec, a8 as TurnFinishReason, a9 as TurnResult, aa as TurnUsage, ap as anthropic, aq as autoDetectAndConvert, ar as cerebras, as as classifyOpenAICompatError, at as connectMcpServers, au as createAgent, av as createFileMapStore, aw as createMemoryStore, ax as createRemoteStore, ay as createSession, az as createSkillActivationState, aA as defineHarness, aB as fromAnthropic, aC as fromOpenAI, aD as loadSession, aE as mapOAIFinishReason, ab as matchesContextExceeded, aF as noTools, aG as normalizeMcpBlocks, aH as normalizeMcpServers, aI as openai, aJ as openaiCompat, aK as openrouter, aL as resultToString, aM as toAnthropic, aN as toOpenAI, aO as toTypedError, ac as toolResultToText } from './agent-DFkSTVKm.js';
+import { d as AgentHooks } from './agent-vPBFXnu-.js';
+export { ab as ActivationVia, ac as ActiveSkill, A as Agent, a as AgentAbortedError, b as AgentBehavior, c as AgentContextExceededError, e as AgentOptions, f as AgentProviderError, g as AgentRunOptions, h as AgentStats, i as AgentToolNotAllowedError, j as AnthropicParams, C as CONTEXT_EXCEEDED_MESSAGE_PATTERNS, k as CerebrasParams, m as ClassifiedError, n as ClassifiedErrorKind, o as CreateSessionOptions, ad as DeactivationReason, ae as FileMapAdapter, af as FileMapStoreOptions, I as ImageContent, M as McpConnection, p as McpServerConfig, q as McpToolHookContext, O as OAuthRefreshHookContext, ag as OpenAICompatAuthHeader, ah as OpenAICompatHttpError, ai as OpenAICompatParams, r as OpenAIParams, s as OpenRouterParams, P as PromptDocumentPart, t as PromptImagePart, u as PromptPart, v as PromptTextPart, w as Provider, x as ProviderCapabilities, R as RemoteStoreOptions, y as RunHookMap, S as Session, z as SessionContentBlock, B as SessionData, D as SessionEndStatus, E as SessionHookContext, F as SessionMessage, G as SessionRun, H as SessionStore, J as SessionTurn, aj as SkillActivationState, ak as SkillActivationStateOptions, K as SkillConfig, al as SkillDiagnostic, L as SkillResource, am as SkillSource, N as SkillsConfig, Q as SpawnHookContext, T as StreamCallbacks, U as StreamHookContext, V as StreamOptions, W as ThinkingLevel, X as ToolCall, Y as ToolContext, Z as ToolDef, _ as ToolExecutionMode, $ as ToolHookContext, a0 as ToolMap, a1 as ToolResult, a2 as ToolResultContent, a3 as ToolResultImageContent, a4 as ToolResultTextContent, a5 as ToolSpec, a6 as TurnFinishReason, a7 as TurnResult, a8 as TurnUsage, an as anthropic, ao as autoDetectAndConvert, ap as cerebras, aq as classifyOpenAICompatError, ar as connectMcpServers, as as createAgent, at as createFileMapStore, au as createMemoryStore, av as createRemoteStore, aw as createSession, ax as createSkillActivationState, ay as fromAnthropic, az as fromOpenAI, aA as loadSession, aB as mapOAIFinishReason, a9 as matchesContextExceeded, aC as normalizeMcpBlocks, aD as normalizeMcpServers, aE as openai, aF as openaiCompat, aG as openrouter, aH as resultToString, aI as toAnthropic, aJ as toOpenAI, aK as toTypedError, aa as toolResultToText } from './agent-vPBFXnu-.js';
 export { createDockerContext, createProcessContext } from './contexts.js';
 export { S as SandboxProvider, c as createSandboxContext } from './sandbox-CW72eLDP.js';
 export { C as ContextCapabilities, a as ContextType, E as ExecResult, b as ExecutionContext, c as ExecutionHandle, S as SpawnConfig } from './types-BpvTmawk.js';
-export { IMPLICITLY_ALLOWED_SKILL_TOOLS, SkillValidationIssue, SkillValidationResult, SourcedScanPath, buildCatalog, defineSkill, discoverSkills, installAllowedToolsGate, interpolateShellCommands, isToolAllowedByUnion, matchesAllowedTool, mergeSkillsConfig, parseAllowedToolPattern, parseSkillFile, resolveSkills, validateResourcePath, validateSkillForWrite, validateSkillName, writeSkillToDisk, writeSkillsToDisk } from './skills.js';
-export { S as SkillsReadToolOptions, a as SkillsRunScriptToolOptions, b as SkillsUseToolOptions, c as createSkillsReadTool, d as createSkillsRunScriptTool, e as createSkillsUseTool, g as glob } from './skills-use-DWprxufr.js';
-export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, c as createInteractionTool, b as createSpawnTool, s as spawn } from './spawn-CW5GEK-T.js';
+export { Preset, basic, basicTools, definePreset } from './presets.js';
+export { IMPLICITLY_ALLOWED_SKILL_TOOLS, SkillValidationIssue, SkillValidationResult, SourcedScanPath, buildCatalog, defineSkill, discoverSkills, installAllowedToolsGate, interpolateShellCommands, isToolAllowedByUnion, matchesAllowedTool, parseAllowedToolPattern, parseSkillFile, resolveSkills, validateResourcePath, validateSkillForWrite, validateSkillName, writeSkillToDisk, writeSkillsToDisk } from './skills.js';
+export { S as SkillsReadToolOptions, a as SkillsRunScriptToolOptions, b as SkillsUseToolOptions, c as createSkillsReadTool, d as createSkillsRunScriptTool, e as createSkillsUseTool, g as glob } from './skills-use-39cCsA7_.js';
+export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, c as createInteractionTool, b as createSpawnTool, s as spawn } from './spawn-Czx3owjX.js';
 import { Hookable } from 'hookable';
 import '@modelcontextprotocol/sdk/client/index.js';
 

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   defineSkill
-} from "./chunk-HJUB63VE.js";
+} from "./chunk-BW3WTFIR.js";
 import {
   toolResultToText
 } from "./chunk-MYWDHD7C.js";
@@ -11,9 +11,10 @@ import {
   openrouter
 } from "./chunk-CDRXC7A7.js";
 import {
-  defineHarness,
-  noTools
-} from "./chunk-VUVLOTEY.js";
+  basicTools,
+  basic_default,
+  definePreset
+} from "./chunk-SP5NA6WF.js";
 import {
   createAgent,
   createInteractionTool,
@@ -23,7 +24,7 @@ import {
   createSpawnTool,
   glob,
   spawn
-} from "./chunk-AWDWJ2YJ.js";
+} from "./chunk-F5UBXERT.js";
 import {
   IMPLICITLY_ALLOWED_SKILL_TOOLS,
   buildCatalog,
@@ -33,7 +34,6 @@ import {
   interpolateShellCommands,
   isToolAllowedByUnion,
   matchesAllowedTool,
-  mergeSkillsConfig,
   parseAllowedToolPattern,
   parseSkillFile,
   resolveSkills,
@@ -42,7 +42,7 @@ import {
   validateSkillName,
   writeSkillToDisk,
   writeSkillsToDisk
-} from "./chunk-DCYJYM3E.js";
+} from "./chunk-TPXPVEH6.js";
 import {
   createDockerContext,
   createProcessContext,
@@ -53,7 +53,7 @@ import {
   normalizeMcpBlocks,
   normalizeMcpServers,
   resultToString
-} from "./chunk-IJORSHFI.js";
+} from "./chunk-37GD7NL3.js";
 import {
   createFileMapStore,
   createMemoryStore,
@@ -204,6 +204,8 @@ export {
   OpenAICompatHttpError,
   anthropic,
   autoDetectAndConvert,
+  basic_default as basic,
+  basicTools,
   buildCatalog,
   cerebras,
   classifyOpenAICompatError,
@@ -223,7 +225,7 @@ export {
   createSkillsUseTool,
   createSpawnTool,
   createTracingHooks,
-  defineHarness,
+  definePreset,
   defineSkill,
   discoverSkills,
   fromAnthropic,
@@ -236,8 +238,6 @@ export {
   mapOAIFinishReason,
   matchesAllowedTool,
   matchesContextExceeded,
-  mergeSkillsConfig,
-  noTools,
   normalizeMcpBlocks,
   normalizeMcpServers,
   openai,

package/dist/mcp.d.ts

@@ -1,4 +1,4 @@
 import 'hookable';
-export { M as McpConnection, q as McpServerConfig, at as connectMcpServers, aG as normalizeMcpBlocks, aH as normalizeMcpServers, aL as resultToString } from './agent-DFkSTVKm.js';
+export { M as McpConnection, p as McpServerConfig, ar as connectMcpServers, aC as normalizeMcpBlocks, aD as normalizeMcpServers, aH as resultToString } from './agent-vPBFXnu-.js';
 import '@modelcontextprotocol/sdk/client/index.js';
 import './types-BpvTmawk.js';

package/dist/mcp.js

@@ -3,7 +3,7 @@ import {
   normalizeMcpBlocks,
   normalizeMcpServers,
   resultToString
-} from "./chunk-IJORSHFI.js";
+} from "./chunk-37GD7NL3.js";
 export {
   connectMcpServers,
   normalizeMcpBlocks,

package/dist/presets.d.ts

@@ -0,0 +1,33 @@
+import { Z as ToolDef, e as AgentOptions } from './agent-vPBFXnu-.js';
+import 'hookable';
+import './types-BpvTmawk.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+
+/** Core tools available in every basic preset (without spawn) */
+declare const basicTools: {
+    shell: ToolDef;
+    readFile: ToolDef;
+    writeFile: ToolDef;
+    listFiles: ToolDef;
+};
+declare const _default: Preset;
+
+/**
+ * A preset is a reusable slice of `AgentOptions` — spread it into `createAgent()`
+ * to configure tools, a default system prompt, aliases, and behavior defaults.
+ *
+ * `provider`, `execution`, `session`, and internal fields are excluded so presets
+ * remain shareable and composable.
+ *
+ * ```ts
+ * import { basic } from 'zidane/presets'
+ * createAgent({ ...basic, provider })
+ * ```
+ */
+type Preset = Omit<Partial<AgentOptions>, 'provider' | 'execution' | 'session' | '_mcpConnector'>;
+/**
+ * Identity helper for type inference when defining a preset.
+ */
+declare function definePreset(config: Preset): Preset;
+
+export { type Preset, _default as basic, basicTools, definePreset };

package/dist/presets.js

@@ -0,0 +1,15 @@
+import {
+  basicTools,
+  basic_default,
+  definePreset
+} from "./chunk-SP5NA6WF.js";
+import "./chunk-F5UBXERT.js";
+import "./chunk-TPXPVEH6.js";
+import "./chunk-2EQT4EHD.js";
+import "./chunk-37GD7NL3.js";
+import "./chunk-LNN5UTS2.js";
+export {
+  basic_default as basic,
+  basicTools,
+  definePreset
+};

package/dist/providers.d.ts

@@ -1,4 +1,4 @@
-export { j as AnthropicParams, k as CerebrasParams, ai as OpenAICompatAuthHeader, aj as OpenAICompatHttpError, ak as OpenAICompatParams, s as OpenAIParams, t as OpenRouterParams, x as Provider, y as ProviderCapabilities, V as StreamCallbacks, X as StreamOptions, Z as ToolCall, a3 as ToolResult, a7 as ToolSpec, a9 as TurnResult, ap as anthropic, ar as cerebras, as as classifyOpenAICompatError, aE as mapOAIFinishReason, aI as openai, aJ as openaiCompat, aK as openrouter } from './agent-DFkSTVKm.js';
+export { j as AnthropicParams, k as CerebrasParams, ag as OpenAICompatAuthHeader, ah as OpenAICompatHttpError, ai as OpenAICompatParams, r as OpenAIParams, s as OpenRouterParams, w as Provider, x as ProviderCapabilities, T as StreamCallbacks, V as StreamOptions, X as ToolCall, a1 as ToolResult, a5 as ToolSpec, a7 as TurnResult, an as anthropic, ap as cerebras, aq as classifyOpenAICompatError, aB as mapOAIFinishReason, aE as openai, aF as openaiCompat, aG as openrouter } from './agent-vPBFXnu-.js';
 import 'hookable';
 import './types-BpvTmawk.js';
 import '@modelcontextprotocol/sdk/client/index.js';

package/dist/session/sqlite.d.ts

@@ -1,4 +1,4 @@
-import { K as SessionStore } from '../agent-DFkSTVKm.js';
+import { H as SessionStore } from '../agent-vPBFXnu-.js';
 import 'hookable';
 import '../types-BpvTmawk.js';
 import '@modelcontextprotocol/sdk/client/index.js';

package/dist/session.d.ts

@@ -1,4 +1,4 @@
-export { o as CreateSessionOptions, ag as FileMapAdapter, ah as FileMapStoreOptions, R as RemoteStoreOptions, S as Session, B as SessionContentBlock, D as SessionData, G as SessionMessage, J as SessionRun, K as SessionStore, L as SessionTurn, aq as autoDetectAndConvert, av as createFileMapStore, aw as createMemoryStore, ax as createRemoteStore, ay as createSession, aB as fromAnthropic, aC as fromOpenAI, aD as loadSession, aM as toAnthropic, aN as toOpenAI } from './agent-DFkSTVKm.js';
+export { o as CreateSessionOptions, ae as FileMapAdapter, af as FileMapStoreOptions, R as RemoteStoreOptions, S as Session, z as SessionContentBlock, B as SessionData, F as SessionMessage, G as SessionRun, H as SessionStore, J as SessionTurn, ao as autoDetectAndConvert, at as createFileMapStore, au as createMemoryStore, av as createRemoteStore, aw as createSession, ay as fromAnthropic, az as fromOpenAI, aA as loadSession, aI as toAnthropic, aJ as toOpenAI } from './agent-vPBFXnu-.js';
 import 'hookable';
 import './types-BpvTmawk.js';
 import '@modelcontextprotocol/sdk/client/index.js';

package/dist/{skills-use-DWprxufr.d.ts → skills-use-39cCsA7_.d.ts}

@@ -1,4 +1,4 @@
-import { $ as ToolDef, N as SkillConfig, al as SkillActivationState, d as AgentHooks } from './agent-DFkSTVKm.js';
+import { Z as ToolDef, K as SkillConfig, aj as SkillActivationState, d as AgentHooks } from './agent-vPBFXnu-.js';
 import { Hookable } from 'hookable';
 
 declare const glob: ToolDef;
@@ -40,9 +40,9 @@ declare function createSkillsRunScriptTool(options: SkillsRunScriptToolOptions):
  *
  * Implements tier 2 of progressive disclosure per the Agent Skills spec.
  * Body is frontmatter-stripped (the model gets the markdown only, wrapped in
- * `<skill_content>` tags so the harness can identify it during context
- * management). Shell-interpolation (`!` `` `cmd` ``) runs per-activation rather
- * than once per agent, so values like `gh pr diff` reflect the current state.
+ * `<skill_content>` tags so downstream context management can identify it).
+ * Shell-interpolation (`!` `` `cmd` ``) runs per-activation rather than once
+ * per agent, so values like `gh pr diff` reflect the current state.
  */
 
 interface SkillsUseToolOptions {

package/dist/skills.d.ts

@@ -1,5 +1,5 @@
-import { d as AgentHooks, al as SkillActivationState, N as SkillConfig, ao as SkillSource, an as SkillDiagnostic, T as SkillsConfig } from './agent-DFkSTVKm.js';
-export { ad as ActivationVia, ae as ActiveSkill, af as DeactivationReason, am as SkillActivationStateOptions, Q as SkillResource, az as createSkillActivationState } from './agent-DFkSTVKm.js';
+import { d as AgentHooks, aj as SkillActivationState, K as SkillConfig, am as SkillSource, al as SkillDiagnostic, N as SkillsConfig } from './agent-vPBFXnu-.js';
+export { ab as ActivationVia, ac as ActiveSkill, ad as DeactivationReason, ak as SkillActivationStateOptions, L as SkillResource, ax as createSkillActivationState } from './agent-vPBFXnu-.js';
 import { Hookable } from 'hookable';
 import { b as ExecutionContext, c as ExecutionHandle } from './types-BpvTmawk.js';
 import '@modelcontextprotocol/sdk/client/index.js';
@@ -267,12 +267,6 @@ declare function interpolateShellCommands(instructions: string, execution: Execu
  * 4. Apply filters: `exclude`, `enabled` allowlist, optional project-skill trust gate
  */
 declare function resolveSkills(config: SkillsConfig): Promise<SkillConfig[]>;
-/**
- * Merge harness-level and agent-level SkillsConfig.
- * Agent-level settings take precedence for scalar fields.
- * Arrays (scan, write, exclude) are concatenated.
- */
-declare function mergeSkillsConfig(harness?: SkillsConfig, agent?: SkillsConfig): SkillsConfig | undefined;
 
 /**
  * Skill writer — materializes inline SkillConfig objects to disk as proper
@@ -307,4 +301,4 @@ declare function defineSkill(config: Omit<SkillConfig, 'source'> & {
     source?: SkillConfig['source'];
 }): SkillConfig;
 
-export { IMPLICITLY_ALLOWED_SKILL_TOOLS, SkillActivationState, SkillConfig, SkillDiagnostic, SkillSource, type SkillValidationIssue, type SkillValidationResult, SkillsConfig, type SourcedScanPath, buildCatalog, defineSkill, discoverSkills, getDefaultScanPaths, inferSource, installAllowedToolsGate, interpolateShellCommands, isToolAllowedByUnion, matchesAllowedTool, mergeSkillsConfig, parseAllowedToolPattern, parseFrontmatter, parseSkillFile, resolveSkills, validateResourcePath, validateSkillForWrite, validateSkillName, writeSkillToDisk, writeSkillsToDisk };
+export { IMPLICITLY_ALLOWED_SKILL_TOOLS, SkillActivationState, SkillConfig, SkillDiagnostic, SkillSource, type SkillValidationIssue, type SkillValidationResult, SkillsConfig, type SourcedScanPath, buildCatalog, defineSkill, discoverSkills, getDefaultScanPaths, inferSource, installAllowedToolsGate, interpolateShellCommands, isToolAllowedByUnion, matchesAllowedTool, parseAllowedToolPattern, parseFrontmatter, parseSkillFile, resolveSkills, validateResourcePath, validateSkillForWrite, validateSkillName, writeSkillToDisk, writeSkillsToDisk };

package/dist/skills.js

@@ -1,6 +1,6 @@
 import {
   defineSkill
-} from "./chunk-HJUB63VE.js";
+} from "./chunk-BW3WTFIR.js";
 import {
   IMPLICITLY_ALLOWED_SKILL_TOOLS,
   buildCatalog,
@@ -12,7 +12,6 @@ import {
   interpolateShellCommands,
   isToolAllowedByUnion,
   matchesAllowedTool,
-  mergeSkillsConfig,
   parseAllowedToolPattern,
   parseFrontmatter,
   parseSkillFile,
@@ -22,7 +21,7 @@ import {
   validateSkillName,
   writeSkillToDisk,
   writeSkillsToDisk
-} from "./chunk-DCYJYM3E.js";
+} from "./chunk-TPXPVEH6.js";
 import "./chunk-LNN5UTS2.js";
 export {
   IMPLICITLY_ALLOWED_SKILL_TOOLS,
@@ -36,7 +35,6 @@ export {
   interpolateShellCommands,
   isToolAllowedByUnion,
   matchesAllowedTool,
-  mergeSkillsConfig,
   parseAllowedToolPattern,
   parseFrontmatter,
   parseSkillFile,

package/dist/{spawn-CW5GEK-T.d.ts → spawn-Czx3owjX.d.ts}

@@ -1,9 +1,10 @@
-import { _ as ToolContext, $ as ToolDef, p as HarnessConfig, h as AgentStats, l as ChildRunStats } from './agent-DFkSTVKm.js';
+import { Y as ToolContext, Z as ToolDef, h as AgentStats, l as ChildRunStats } from './agent-vPBFXnu-.js';
+import { Preset } from './presets.js';
 
 /**
  * Interaction tool — lets the agent request structured input from the outside world.
  *
- * Not included in any harness by default. Add it explicitly:
+ * Not included in any preset by default. Add it explicitly:
  *
  *   import { createInteractionTool } from 'zidane'
  *
@@ -15,7 +16,7 @@ import { _ as ToolContext, $ as ToolDef, p as HarnessConfig, h as AgentStats, l
  *     },
  *   })
  *
- *   const harness = defineHarness({ name: 'interactive', tools: { ...basicTools, ask_user: askUser } })
+ *   const preset = definePreset({ name: 'interactive', tools: { ...basicTools, ask_user: askUser } })
  */
 
 interface InteractionToolOptions {
@@ -40,12 +41,13 @@ declare function createInteractionTool(options: InteractionToolOptions): ToolDef
 /**
  * Spawn tool — create sub-agents from a parent agent.
  *
- * A configurable factory that reads provider + harness from ToolContext.
+ * A configurable factory that reads the parent's preset-y fields from ToolContext.
  *
  * Usage — default (stateless, safe across parent agents):
  * ```ts
  * import { spawn } from 'zidane'
- * const harness = defineHarness({ name: 'orchestrator', tools: { ...basicTools, spawn } })
+ * import { definePreset, basicTools } from 'zidane/presets'
+ * const preset = definePreset({ name: 'orchestrator', tools: { ...basicTools, spawn } })
  * ```
  *
  * Usage — with shared state (telemetry, lifecycle callbacks):
@@ -98,8 +100,8 @@ interface SpawnToolOptions {
     system?: string;
     /** Child thinking level. */
     thinking?: 'off' | 'minimal' | 'low' | 'medium' | 'high';
-    /** Harness override for children. Defaults to the parent's harness. */
-    harness?: HarnessConfig;
+    /** Preset override for children. Shallow-merged over the parent's preset (parent fields still win for anything left unset). */
+    preset?: Preset;
     /**
      * Per-child timeout, in milliseconds. When the child exceeds it the spawn
      * tool returns a timeout marker, fires `spawn:error`, and destroys the

package/dist/tools.d.ts

@@ -1,8 +1,10 @@
-export { S as SkillsReadToolOptions, a as SkillsRunScriptToolOptions, b as SkillsUseToolOptions, c as createSkillsReadTool, d as createSkillsRunScriptTool, e as createSkillsUseTool, g as glob } from './skills-use-DWprxufr.js';
-export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, c as createInteractionTool, b as createSpawnTool, s as spawn } from './spawn-CW5GEK-T.js';
-import { $ as ToolDef } from './agent-DFkSTVKm.js';
+export { S as SkillsReadToolOptions, a as SkillsRunScriptToolOptions, b as SkillsUseToolOptions, c as createSkillsReadTool, d as createSkillsRunScriptTool, e as createSkillsUseTool, g as glob } from './skills-use-39cCsA7_.js';
+export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, c as createInteractionTool, b as createSpawnTool, s as spawn } from './spawn-Czx3owjX.js';
+import { Z as ToolDef } from './agent-vPBFXnu-.js';
+export { Y as ToolContext, a0 as ToolMap } from './agent-vPBFXnu-.js';
 export { V as ValidationResult, v as validateToolArgs } from './validation-DOY_k7lW.js';
 import 'hookable';
+import './presets.js';
 import './types-BpvTmawk.js';
 import '@modelcontextprotocol/sdk/client/index.js';
 
@@ -14,4 +16,4 @@ declare const shell: ToolDef;
 
 declare const writeFile: ToolDef;
 
-export { listFiles, readFile, shell, writeFile };
+export { ToolDef, listFiles, readFile, shell, writeFile };

package/dist/tools.js

@@ -11,10 +11,10 @@ import {
   spawn,
   validateToolArgs,
   writeFile
-} from "./chunk-AWDWJ2YJ.js";
-import "./chunk-DCYJYM3E.js";
+} from "./chunk-F5UBXERT.js";
+import "./chunk-TPXPVEH6.js";
 import "./chunk-2EQT4EHD.js";
-import "./chunk-IJORSHFI.js";
+import "./chunk-37GD7NL3.js";
 import "./chunk-LNN5UTS2.js";
 export {
   createInteractionTool,

package/dist/types.d.ts

@@ -1,7 +1,8 @@
-export { A as Agent, a as AgentAbortedError, b as AgentBehavior, c as AgentContextExceededError, d as AgentHooks, e as AgentOptions, f as AgentProviderError, g as AgentRunOptions, h as AgentStats, i as AgentToolNotAllowedError, j as AnthropicParams, C as CONTEXT_EXCEEDED_MESSAGE_PATTERNS, k as CerebrasParams, l as ChildRunStats, m as ClassifiedError, n as ClassifiedErrorKind, o as CreateSessionOptions, H as Harness, p as HarnessConfig, I as ImageContent, M as McpConnection, q as McpServerConfig, r as McpToolHookContext, O as OAuthRefreshHookContext, s as OpenAIParams, t as OpenRouterParams, P as PromptDocumentPart, u as PromptImagePart, v as PromptPart, w as PromptTextPart, x as Provider, y as ProviderCapabilities, R as RemoteStoreOptions, z as RunHookMap, S as Session, B as SessionContentBlock, D as SessionData, E as SessionEndStatus, F as SessionHookContext, G as SessionMessage, J as SessionRun, K as SessionStore, L as SessionTurn, N as SkillConfig, Q as SkillResource, T as SkillsConfig, U as SpawnHookContext, V as StreamCallbacks, W as StreamHookContext, X as StreamOptions, Y as ThinkingLevel, Z as ToolCall, _ as ToolContext, $ as ToolDef, a0 as ToolExecutionMode, a1 as ToolHookContext, a2 as ToolMap, a3 as ToolResult, a4 as ToolResultContent, a5 as ToolResultImageContent, a6 as ToolResultTextContent, a7 as ToolSpec, a8 as TurnFinishReason, a9 as TurnResult, aa as TurnUsage, ab as matchesContextExceeded, ac as toolResultToText } from './agent-DFkSTVKm.js';
+export { A as Agent, a as AgentAbortedError, b as AgentBehavior, c as AgentContextExceededError, d as AgentHooks, e as AgentOptions, f as AgentProviderError, g as AgentRunOptions, h as AgentStats, i as AgentToolNotAllowedError, j as AnthropicParams, C as CONTEXT_EXCEEDED_MESSAGE_PATTERNS, k as CerebrasParams, l as ChildRunStats, m as ClassifiedError, n as ClassifiedErrorKind, o as CreateSessionOptions, I as ImageContent, M as McpConnection, p as McpServerConfig, q as McpToolHookContext, O as OAuthRefreshHookContext, r as OpenAIParams, s as OpenRouterParams, P as PromptDocumentPart, t as PromptImagePart, u as PromptPart, v as PromptTextPart, w as Provider, x as ProviderCapabilities, R as RemoteStoreOptions, y as RunHookMap, S as Session, z as SessionContentBlock, B as SessionData, D as SessionEndStatus, E as SessionHookContext, F as SessionMessage, G as SessionRun, H as SessionStore, J as SessionTurn, K as SkillConfig, L as SkillResource, N as SkillsConfig, Q as SpawnHookContext, T as StreamCallbacks, U as StreamHookContext, V as StreamOptions, W as ThinkingLevel, X as ToolCall, Y as ToolContext, Z as ToolDef, _ as ToolExecutionMode, $ as ToolHookContext, a0 as ToolMap, a1 as ToolResult, a2 as ToolResultContent, a3 as ToolResultImageContent, a4 as ToolResultTextContent, a5 as ToolSpec, a6 as TurnFinishReason, a7 as TurnResult, a8 as TurnUsage, a9 as matchesContextExceeded, aa as toolResultToText } from './agent-vPBFXnu-.js';
 export { C as ContextCapabilities, a as ContextType, E as ExecResult, b as ExecutionContext, c as ExecutionHandle, S as SpawnConfig } from './types-BpvTmawk.js';
 export { S as SandboxProvider } from './sandbox-CW72eLDP.js';
-export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState } from './spawn-CW5GEK-T.js';
+export { Preset } from './presets.js';
+export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState } from './spawn-Czx3owjX.js';
 export { V as ValidationResult } from './validation-DOY_k7lW.js';
 import 'hookable';
 import '@modelcontextprotocol/sdk/client/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zidane",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "an agent that goes straight to the goal",
   "type": "module",
   "private": false,
@@ -30,9 +30,9 @@
       "import": "./dist/tools.js",
       "types": "./dist/tools.d.ts"
     },
-    "./harnesses": {
-      "import": "./dist/harnesses.js",
-      "types": "./dist/harnesses.d.ts"
+    "./presets": {
+      "import": "./dist/presets.js",
+      "types": "./dist/presets.d.ts"
     },
     "./contexts": {
       "import": "./dist/contexts.js",

package/dist/harnesses.d.ts

@@ -1,4 +0,0 @@
-import 'hookable';
-export { H as Harness, p as HarnessConfig, _ as ToolContext, $ as ToolDef, a2 as ToolMap, aP as basic, aQ as basicTools, aA as defineHarness, aF as noTools } from './agent-DFkSTVKm.js';
-import './types-BpvTmawk.js';
-import '@modelcontextprotocol/sdk/client/index.js';

package/dist/harnesses.js

@@ -1,17 +0,0 @@
-import {
-  basicTools,
-  basic_default,
-  defineHarness,
-  noTools
-} from "./chunk-VUVLOTEY.js";
-import "./chunk-AWDWJ2YJ.js";
-import "./chunk-DCYJYM3E.js";
-import "./chunk-2EQT4EHD.js";
-import "./chunk-IJORSHFI.js";
-import "./chunk-LNN5UTS2.js";
-export {
-  basic_default as basic,
-  basicTools,
-  defineHarness,
-  noTools
-};