@sweny-ai/core 0.1.133 → 0.1.135

package/dist/harness/compat.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Bridges between the legacy `Claude` interface and `AgentHarness`.
+ * No agent SDK imports: the executor uses this.
+ */
+import type { Claude } from "../types.js";
+import type { AgentHarness } from "./types.js";
+/**
+ * Wrap a legacy `Claude` object (`ExecuteOptions.claude`) as an `AgentHarness`.
+ * The legacy object's own `ask` / `evaluate` keep winning, so a custom or mock
+ * `Claude` behaves exactly as it did before the seam.
+ */
+export declare function claudeCompat(claude: Claude): AgentHarness;
+/**
+ * View a harness as the `Claude` shape the executor, retry and judge code
+ * consume: `run` goes to the harness, `ask` / `evaluate` are core prompts over
+ * `complete()`. A harness made by {@link claudeCompat} unwraps to the original.
+ */
+export declare function asClaude(harness: AgentHarness): Claude;

package/dist/harness/compat.js

@@ -0,0 +1,62 @@
+/**
+ * Bridges between the legacy `Claude` interface and `AgentHarness`.
+ * No agent SDK imports: the executor uses this.
+ */
+import { CLAUDE_CODE_CAPABILITIES } from "./capabilities.js";
+import { ask, evaluate, legacyClaudeOf, registerLegacyClaude } from "./prompts.js";
+function isHarness(x) {
+    const h = x;
+    return !!h && typeof h.complete === "function" && typeof h.preflight === "function" && !!h.capabilities;
+}
+/**
+ * Wrap a legacy `Claude` object (`ExecuteOptions.claude`) as an `AgentHarness`.
+ * The legacy object's own `ask` / `evaluate` keep winning, so a custom or mock
+ * `Claude` behaves exactly as it did before the seam.
+ */
+export function claudeCompat(claude) {
+    if (isHarness(claude))
+        return claude;
+    const harness = {
+        id: "claude-code",
+        capabilities: CLAUDE_CODE_CAPABILITIES,
+        defaultJudgeModel: claude.defaultJudgeModel,
+        async preflight() {
+            return { ok: true, version: "legacy-compat" };
+        },
+        async run(req) {
+            const result = await claude.run(req);
+            return { ...result, harness: { id: "claude-code", version: "legacy-compat" }, degraded: [] };
+        },
+        async complete(req) {
+            // A legacy ask() with an empty context sends the instruction unchanged.
+            return claude.ask({
+                instruction: req.prompt,
+                context: {},
+                model: req.model,
+                timeoutMs: req.timeoutMs,
+                signal: req.signal,
+            });
+        },
+    };
+    registerLegacyClaude(harness, claude);
+    return harness;
+}
+/**
+ * View a harness as the `Claude` shape the executor, retry and judge code
+ * consume: `run` goes to the harness, `ask` / `evaluate` are core prompts over
+ * `complete()`. A harness made by {@link claudeCompat} unwraps to the original.
+ */
+export function asClaude(harness) {
+    const legacy = legacyClaudeOf(harness);
+    if (legacy)
+        return legacy;
+    // A harness that carries its own ask/evaluate (ClaudeCodeHarness delegates to
+    // core; MockHarness scripts them) keeps them. Others get the core prompts.
+    const own = harness;
+    return {
+        defaultJudgeModel: harness.defaultJudgeModel,
+        run: (req) => harness.run(req),
+        evaluate: (opts) => (own.evaluate ? own.evaluate(opts) : evaluate(harness, opts)),
+        ask: (opts) => (own.ask ? own.ask(opts) : ask(harness, opts)),
+    };
+}

package/dist/harness/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Harness seam entry point: the factory, the legacy-`Claude` bridge, and the
+ * public harness types. Every construction site goes through `createHarness`.
+ */
+import { ClaudeCodeHarness, type ClaudeCodeHarnessOptions } from "./claude-code.js";
+export { claudeCompat, asClaude } from "./compat.js";
+export type { AgentHarness, HarnessCapabilities, HarnessCompleteRequest, HarnessId, HarnessInfo, HarnessRunRequest, HarnessRunResult, NodePolicy, PolicyGateResult, PolicyWrappers, ToolClass, } from "./types.js";
+export { policyGate } from "./policy.js";
+export { ask, evaluate, buildAskPrompt, buildEvaluatePrompt } from "./prompts.js";
+export { ClaudeCodeHarness, CLAUDE_CODE_CAPABILITIES } from "./claude-code.js";
+export type { ClaudeCodeHarnessOptions } from "./claude-code.js";
+/**
+ * Build the harness for an agent id. `claude` is the historical `--agent` /
+ * `coding-agent-provider` value and means the same as `claude-code`.
+ * Unknown ids fail with the same error `sweny` has always given.
+ */
+export declare function createHarness(id: string, opts?: ClaudeCodeHarnessOptions): ClaudeCodeHarness;

package/dist/harness/index.js

@@ -0,0 +1,24 @@
+/**
+ * Harness seam entry point: the factory, the legacy-`Claude` bridge, and the
+ * public harness types. Every construction site goes through `createHarness`.
+ */
+import { ClaudeCodeHarness } from "./claude-code.js";
+export { claudeCompat, asClaude } from "./compat.js";
+export { policyGate } from "./policy.js";
+export { ask, evaluate, buildAskPrompt, buildEvaluatePrompt } from "./prompts.js";
+export { ClaudeCodeHarness, CLAUDE_CODE_CAPABILITIES } from "./claude-code.js";
+/**
+ * Build the harness for an agent id. `claude` is the historical `--agent` /
+ * `coding-agent-provider` value and means the same as `claude-code`.
+ * Unknown ids fail with the same error `sweny` has always given.
+ */
+export function createHarness(id, opts = {}) {
+    switch (id) {
+        case "claude":
+        case "claude-code":
+            return new ClaudeCodeHarness(opts);
+        default:
+            throw new Error(`Unsupported coding agent "${id}": the only supported agent is "claude" ` +
+                `(headless Claude Code). Remove --agent / coding-agent-provider or set it to claude.`);
+    }
+}

package/dist/harness/policy.d.ts

@@ -0,0 +1,8 @@
+/**
+ * policyGate: the one place that decides "degrade" versus "refuse".
+ *
+ * Pure. Called before every harness run. For Claude Code every opinion is
+ * enforced natively, so the result is always `{ degraded: [] }`.
+ */
+import type { HarnessCapabilities, NodePolicy, PolicyGateResult, PolicyWrappers } from "./types.js";
+export declare function policyGate(caps: HarnessCapabilities, policy: NodePolicy, wrappers?: PolicyWrappers): PolicyGateResult;

package/dist/harness/policy.js

@@ -0,0 +1,33 @@
+/**
+ * policyGate: the one place that decides "degrade" versus "refuse".
+ *
+ * Pure. Called before every harness run. For Claude Code every opinion is
+ * enforced natively, so the result is always `{ degraded: [] }`.
+ */
+export function policyGate(caps, policy, wrappers = {}) {
+    const degraded = [];
+    if (policy.readOnly && caps.readOnly === "none" && !wrappers.readOnlyMount) {
+        degraded.push("read-only: harness cannot enforce it and no read-only mount is active");
+    }
+    if (policy.deny.length > 0) {
+        if (caps.builtinDeny === "none") {
+            degraded.push(`deny [${policy.deny.join(", ")}]: harness cannot deny built-in tools`);
+        }
+        else if (caps.builtinDeny === "shell-only") {
+            const unmappable = policy.deny.filter((c) => c !== "shell");
+            if (unmappable.length > 0) {
+                degraded.push(`deny [${unmappable.join(", ")}]: harness can only deny the shell tool`);
+            }
+        }
+    }
+    if ((policy.nativeDeny?.length ?? 0) > 0 && caps.builtinDeny === "none") {
+        degraded.push("disallowed_tools: harness cannot deny built-in tools");
+    }
+    if (policy.egress.length > 0 && !caps.sandbox.network && !wrappers.egress) {
+        degraded.push("egress allowlist: harness has no network sandbox and no egress wrapper is active");
+    }
+    if (degraded.length > 0 && policy.strict) {
+        return { degraded, refuse: `strict policy: ${degraded.join("; ")}` };
+    }
+    return { degraded };
+}

package/dist/harness/prompts.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Harness-agnostic prompts: `ask()` and `evaluate()` build the prompt in core
+ * and run it over `harness.complete()`. The strings are byte-identical to what
+ * `ClaudeClient.ask` / `ClaudeClient.evaluate` built before the harness seam
+ * (#330); prompts.test.ts pins them against the old builders.
+ */
+import type { Claude, Logger } from "../types.js";
+import type { AgentHarness } from "./types.js";
+/** @internal Registers the legacy object behind a compat harness. */
+export declare function registerLegacyClaude(harness: AgentHarness, claude: Claude): void;
+/** @internal The legacy `Claude` behind a compat harness, if any. */
+export declare function legacyClaudeOf(harness: AgentHarness): Claude | undefined;
+/** The `ask` prompt: the instruction, then the fenced context when there is any. */
+export declare function buildAskPrompt(instruction: string, context: Record<string, unknown>): string;
+/**
+ * Build the prompt used by `evaluate()` to pick a routing edge.
+ *
+ * Extracted as a pure function so the prompt body can be unit tested without
+ * spinning up an SDK query. The body is part of the routing contract: workflow
+ * authors and downstream maintainers rely on the model leaning on structured
+ * fields rather than prose narrative when picking an edge, especially in the
+ * fallback case where a source node did not declare an `output` schema (the
+ * executor's schema-strict filter only kicks in when a schema is present;
+ * see `buildRouteEvalEntry` in executor.ts).
+ *
+ * Any change to this prompt should keep:
+ *   - The three "Evaluation rules" pointing the model at structured fields
+ *     and away from prose narrative.
+ *   - A terminal directive to return ONLY the choice ID.
+ */
+export declare function buildEvaluatePrompt(question: string, context: Record<string, unknown>, choices: {
+    id: string;
+    description: string;
+}[]): string;
+/**
+ * Single-completion free-text query (retry reflection, judge scoring).
+ * A failed completion is the empty string, same as before the seam.
+ */
+export declare function ask(harness: AgentHarness, opts: {
+    instruction: string;
+    context: Record<string, unknown>;
+    model?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<string>;
+/**
+ * Route evaluation: pick one of N choices. Fails closed: null when the
+ * completion failed or the answer names no valid choice.
+ */
+export declare function evaluate(harness: AgentHarness, opts: {
+    question: string;
+    context: Record<string, unknown>;
+    choices: {
+        id: string;
+        description: string;
+    }[];
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}, logger?: Logger): Promise<string | null>;

package/dist/harness/prompts.js

@@ -0,0 +1,107 @@
+/**
+ * Harness-agnostic prompts: `ask()` and `evaluate()` build the prompt in core
+ * and run it over `harness.complete()`. The strings are byte-identical to what
+ * `ClaudeClient.ask` / `ClaudeClient.evaluate` built before the harness seam
+ * (#330); prompts.test.ts pins them against the old builders.
+ */
+import { consoleLogger } from "../types.js";
+import { fenceUntrustedJson } from "../untrusted.js";
+/** Legacy `Claude` objects wrapped by `claudeCompat()`, so their own ask/evaluate still win. */
+const LEGACY = new WeakMap();
+/** @internal Registers the legacy object behind a compat harness. */
+export function registerLegacyClaude(harness, claude) {
+    LEGACY.set(harness, claude);
+}
+/** @internal The legacy `Claude` behind a compat harness, if any. */
+export function legacyClaudeOf(harness) {
+    return LEGACY.get(harness);
+}
+/** The `ask` prompt: the instruction, then the fenced context when there is any. */
+export function buildAskPrompt(instruction, context) {
+    return [instruction, Object.keys(context).length > 0 ? `\nContext:\n${fenceUntrustedJson(context, "context")}` : ""]
+        .filter(Boolean)
+        .join("\n");
+}
+/**
+ * Build the prompt used by `evaluate()` to pick a routing edge.
+ *
+ * Extracted as a pure function so the prompt body can be unit tested without
+ * spinning up an SDK query. The body is part of the routing contract: workflow
+ * authors and downstream maintainers rely on the model leaning on structured
+ * fields rather than prose narrative when picking an edge, especially in the
+ * fallback case where a source node did not declare an `output` schema (the
+ * executor's schema-strict filter only kicks in when a schema is present;
+ * see `buildRouteEvalEntry` in executor.ts).
+ *
+ * Any change to this prompt should keep:
+ *   - The three "Evaluation rules" pointing the model at structured fields
+ *     and away from prose narrative.
+ *   - A terminal directive to return ONLY the choice ID.
+ */
+export function buildEvaluatePrompt(question, context, choices) {
+    const choiceList = choices.map((c) => `- "${c.id}": ${c.description}`).join("\n");
+    return [
+        question,
+        `\nContext:\n${fenceUntrustedJson(context, "context")}`,
+        `\nChoices:\n${choiceList}`,
+        `\nEvaluation rules:`,
+        `1. Read each choice's condition literally and match against the structured fields in the context (e.g. status, counts, enum values, boolean flags).`,
+        `2. Ignore prose narrative fields ("summary", free-form rationale, conversational commentary). They are not the contract.`,
+        `3. When a field's value contradicts what a prose field claims, trust the field's value.`,
+        `4. A field whose value is explicitly null means the source node DECLARED that field but did NOT emit a value. Treat null as "unknown" and do NOT match it against any specific value (do not match "is 0", "is N", "is true", "is false", or "is undefined" against a null field). Prefer a default/fallback edge when the field needed for a decision is null.`,
+        `\nRespond with ONLY the choice ID, nothing else.`,
+    ].join("\n");
+}
+/**
+ * Single-completion free-text query (retry reflection, judge scoring).
+ * A failed completion is the empty string, same as before the seam.
+ */
+export async function ask(harness, opts) {
+    const legacy = legacyClaudeOf(harness);
+    if (legacy)
+        return legacy.ask(opts);
+    const { instruction, context, model, timeoutMs, signal } = opts;
+    const response = await harness.complete({
+        prompt: buildAskPrompt(instruction, context),
+        model,
+        timeoutMs,
+        signal,
+        purpose: "ask",
+    });
+    return (response ?? "").trim();
+}
+/**
+ * Route evaluation: pick one of N choices. Fails closed: null when the
+ * completion failed or the answer names no valid choice.
+ */
+export async function evaluate(harness, opts, logger) {
+    const legacy = legacyClaudeOf(harness);
+    if (legacy)
+        return legacy.evaluate(opts);
+    const log = logger ?? harness.logger ?? consoleLogger;
+    const { question, context, choices, timeoutMs, signal } = opts;
+    const response = await harness.complete({
+        prompt: buildEvaluatePrompt(question, context, choices),
+        timeoutMs,
+        signal,
+        purpose: "evaluate",
+    });
+    // The adapter already logged why; fail closed with no decision.
+    if (response === null)
+        return null;
+    const text = response.trim().replace(/^["']|["']$/g, "");
+    const validIds = choices.map((c) => c.id);
+    // Exact match
+    if (validIds.includes(text))
+        return text;
+    // Fuzzy: look for an ID embedded in the response
+    const match = validIds.find((id) => text.includes(id));
+    if (match)
+        return match;
+    // Fail closed. An unparseable answer is not a decision. Returning
+    // validIds[0] here is the fail-open bug: on a node with a single
+    // conditional out-edge, the "first choice" is always that edge, so a
+    // garbled model answer would always take it. Signal no-decision instead.
+    log.warn(`Could not parse route choice from: "${text.slice(0, 100)}". Failing closed (no route decision).`);
+    return null;
+}

package/dist/harness/types.d.ts

@@ -0,0 +1,111 @@
+/**
+ * AgentHarness: the seam between the executor and whatever agent runs a node.
+ *
+ * Design: research/2026-09-30-sota/harness-design.md, section 1. Claude Code
+ * (`ClaudeCodeHarness`) is the only adapter today. `evaluate` and `ask` are
+ * not adapter methods: core builds the prompt and calls `complete()` (see
+ * prompts.ts), so every adapter gets routing and judging for free.
+ *
+ * Browser-safe: types only, no runtime imports.
+ */
+import type { Claude, Logger, NodeResult } from "../types.js";
+export type HarnessId = "claude-code" | "mock" | "codex" | "pi" | "hermes" | "gemini" | `acp:${string}`;
+/** Portable tool vocabulary for node policy. */
+export type ToolClass = "shell" | "write" | "edit" | "net" | "subagent";
+export interface HarnessCapabilities {
+    /** native = the harness validates a JSON schema; prompt = sweny prompts, parses, validates. */
+    structuredOutput: "native" | "prompt";
+    /** full = built-in tool calls are visible with status; skill-only = only skill tools are traced. */
+    toolTrace: "full" | "skill-only";
+    builtinDeny: "by-name" | "by-class" | "shell-only" | "none";
+    mcp: {
+        inject: boolean;
+        exclusive: "native" | "home-isolation" | "none";
+    };
+    /** Native sandbox, before any sweny wrapper. */
+    sandbox: {
+        fs: boolean;
+        network: boolean;
+    };
+    readOnly: "native" | "tool-allowlist" | "none";
+    turnLimit: "native" | "watchdog" | "none";
+    usage: {
+        tokens: boolean;
+        costUsd: boolean;
+        live: boolean;
+    };
+    cancel: "signal" | "rpc" | "kill";
+    resume: boolean;
+}
+/** What a node is allowed to do, compiled per adapter by the harness. */
+export interface NodePolicy {
+    /** Dry run: the node must not change anything. */
+    readOnly: boolean;
+    /** Portable deny list. */
+    deny: ToolClass[];
+    /** Legacy `disallowed_tools` passthrough, harness-native names. */
+    nativeDeny?: string[];
+    /** Allowed egress hosts. */
+    egress: string[];
+    /** Refuse instead of degrade when an opinion cannot be enforced. */
+    strict: boolean;
+}
+/** Process-level wrappers the host provides (OS sandbox, egress proxy, read-only mount). */
+export interface PolicyWrappers {
+    sandbox?: boolean;
+    egress?: boolean;
+    readOnlyMount?: boolean;
+}
+export interface PolicyGateResult {
+    /** Every opinion this run could not honor natively. Empty for Claude Code. */
+    degraded: string[];
+    /** Set only in strict mode when at least one opinion cannot be honored. */
+    refuse?: string;
+}
+/** Which harness produced a result. Recorded on `NodeResult` and in run history. */
+export interface HarnessInfo {
+    id: HarnessId;
+    version: string;
+}
+/** `Claude.run` request shape, kept verbatim so every existing caller still type-checks. */
+export type ClaudeRunRequest = Parameters<Claude["run"]>[0];
+export interface HarnessRunRequest extends ClaudeRunRequest {
+    /**
+     * Node policy. Optional: when absent the adapter derives it from the legacy
+     * `readOnly` / `disallowedTools` / `agentAccess` fields.
+     */
+    policy?: NodePolicy;
+}
+export interface HarnessRunResult extends NodeResult {
+    harness: HarnessInfo;
+    degraded: string[];
+}
+export interface HarnessCompleteRequest {
+    prompt: string;
+    model?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    /**
+     * Which core call this is for. Adapters use it only to word their failure
+     * logs ("claude.ask: ..." vs "claude.evaluate: ..."); it never changes the query.
+     */
+    purpose?: "ask" | "evaluate";
+}
+export interface AgentHarness {
+    readonly id: HarnessId;
+    readonly capabilities: HarnessCapabilities;
+    /** Default model for judge evaluators when nothing else names one. */
+    readonly defaultJudgeModel?: string;
+    /** Logger the adapter reports to; core reuses it for routing parse warnings. */
+    readonly logger?: Logger;
+    preflight(): Promise<{
+        ok: true;
+        version: string;
+    } | {
+        ok: false;
+        reason: string;
+    }>;
+    run(req: HarnessRunRequest): Promise<HarnessRunResult>;
+    /** One completion, no tools, no MCP. null = failed (callers fail closed). */
+    complete(req: HarnessCompleteRequest): Promise<string | null>;
+}

package/dist/harness/types.js

@@ -0,0 +1,11 @@
+/**
+ * AgentHarness: the seam between the executor and whatever agent runs a node.
+ *
+ * Design: research/2026-09-30-sota/harness-design.md, section 1. Claude Code
+ * (`ClaudeCodeHarness`) is the only adapter today. `evaluate` and `ask` are
+ * not adapter methods: core builds the prompt and calls `complete()` (see
+ * prompts.ts), so every adapter gets routing and judging for free.
+ *
+ * Browser-safe: types only, no runtime imports.
+ */
+export {};

package/dist/index.d.ts

@@ -8,15 +8,15 @@
  *
  * @example
  * ```ts
- * import { execute, ClaudeClient, createSkillMap, github, sentry, slack } from '@sweny-ai/core'
+ * import { execute, createHarness, createSkillMap, github, sentry, slack } from '@sweny-ai/core'
  * import { triageWorkflow } from '@sweny-ai/core/workflows'
  *
  * const skills = createSkillMap([github, sentry, slack])
- * const claude = new ClaudeClient()
+ * const harness = createHarness("claude-code")
  *
  * const results = await execute(triageWorkflow, alertPayload, {
  *   skills,
- *   claude,
+ *   harness,
  *   observer: (event) => console.log(event),
  * })
  * ```
@@ -27,8 +27,10 @@ export { EVALUATOR_KINDS, EVAL_POLICIES, REQUIRES_ON_FAIL, NODE_ON_FAIL, MCP_TRA
 export { consoleLogger } from "./types.js";
 export { execute, RouteEvaluationError } from "./executor.js";
 export type { ExecuteOptions } from "./executor.js";
-export { ClaudeClient, resolveAuthEnv } from "./claude.js";
-export type { ClaudeClientOptions, SwenyAuthMode, ResolveAuthEnvOpts } from "./claude.js";
+export { createHarness, claudeCompat, asClaude, policyGate, ClaudeCodeHarness } from "./harness/index.js";
+export type { AgentHarness, HarnessCapabilities, HarnessId, HarnessInfo, HarnessRunRequest, HarnessRunResult, NodePolicy, PolicyGateResult, PolicyWrappers, ToolClass, ClaudeCodeHarnessOptions, } from "./harness/index.js";
+export { ClaudeClient, resolveAuthEnv } from "./harness/claude-code.js";
+export type { ClaudeClientOptions, SwenyAuthMode, ResolveAuthEnvOpts } from "./harness/claude-code.js";
 export { resolveExecutionModel } from "./model.js";
 export { github, linear, slack, sentry, datadog, notification, supabase, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredBuiltinSkills, validateWorkflowSkills, } from "./skills/index.js";
 export type { SkillValidationResult } from "./skills/index.js";

package/dist/index.js

@@ -8,15 +8,15 @@
  *
  * @example
  * ```ts
- * import { execute, ClaudeClient, createSkillMap, github, sentry, slack } from '@sweny-ai/core'
+ * import { execute, createHarness, createSkillMap, github, sentry, slack } from '@sweny-ai/core'
  * import { triageWorkflow } from '@sweny-ai/core/workflows'
  *
  * const skills = createSkillMap([github, sentry, slack])
- * const claude = new ClaudeClient()
+ * const harness = createHarness("claude-code")
  *
  * const results = await execute(triageWorkflow, alertPayload, {
  *   skills,
- *   claude,
+ *   harness,
  *   observer: (event) => console.log(event),
  * })
  * ```
@@ -27,8 +27,10 @@ export { EVALUATOR_KINDS, EVAL_POLICIES, REQUIRES_ON_FAIL, NODE_ON_FAIL, MCP_TRA
 export { consoleLogger } from "./types.js";
 // Executor
 export { execute, RouteEvaluationError } from "./executor.js";
-// Claude client
-export { ClaudeClient, resolveAuthEnv } from "./claude.js";
+// Agent harness (the seam) and its Claude Code adapter
+export { createHarness, claudeCompat, asClaude, policyGate, ClaudeCodeHarness } from "./harness/index.js";
+// Claude client (back-compat: ClaudeClient is ClaudeCodeHarness, @deprecated)
+export { ClaudeClient, resolveAuthEnv } from "./harness/claude-code.js";
 // Execution model resolution
 export { resolveExecutionModel } from "./model.js";
 // Skills

package/dist/testing.d.ts

@@ -19,7 +19,8 @@
  * })
  * ```
  */
-import type { Claude, NodeResult, Tool, JSONSchema, Workflow } from "./types.js";
+import type { Claude, Tool, JSONSchema, Workflow } from "./types.js";
+import type { AgentHarness, HarnessCapabilities, HarnessRunResult } from "./harness/types.js";
 export interface MockNodeResponse {
     /** Tool calls to execute (optional — handlers will be called) */
     toolCalls?: {
@@ -31,7 +32,7 @@ export interface MockNodeResponse {
     /** Status (default: "success") */
     status?: "success" | "skipped" | "failed";
 }
-export interface MockClaudeOptions {
+export interface MockHarnessOptions {
     /** Node ID → scripted response */
     responses: Record<string, MockNodeResponse>;
     /** Route decisions: "fromNode" → chosen target node ID */
@@ -49,21 +50,32 @@ export interface MockClaudeOptions {
  * routes map. With no scripted route (or an invalid one) it returns
  * `null`, mirroring the real client failing closed on a route-eval failure.
  */
-export declare class MockClaude implements Claude {
+export declare class MockHarness implements Claude, AgentHarness {
+    readonly id: "mock";
+    readonly capabilities: HarnessCapabilities;
     private callOrder;
     private responses;
     private routes;
     private instructionMap;
     private askFn?;
-    constructor(opts: MockClaudeOptions);
+    constructor(opts: MockHarnessOptions);
     /** Returns the order in which nodes were executed */
     get executedNodes(): string[];
+    preflight(): Promise<{
+        ok: true;
+        version: string;
+    }>;
+    /** One scripted completion: the `ask` script, or the empty string. */
+    complete(req: {
+        prompt: string;
+    }): Promise<string | null>;
     run(opts: {
         instruction: string;
         context: Record<string, unknown>;
         tools: Tool[];
         outputSchema?: JSONSchema;
-    }): Promise<NodeResult>;
+    }): Promise<HarnessRunResult>;
+    private runScripted;
     evaluate(opts: {
         question: string;
         context: Record<string, unknown>;
@@ -85,6 +97,12 @@ export declare class MockClaude implements Claude {
      */
     private identifyNode;
 }
+/** @deprecated Use {@link MockHarnessOptions}. */
+export type MockClaudeOptions = MockHarnessOptions;
+/** @deprecated Use {@link MockHarness}. */
+export declare const MockClaude: typeof MockHarness;
+/** @deprecated Use {@link MockHarness}. */
+export type MockClaude = MockHarness;
 import type { Skill } from "./types.js";
 /**
  * Create a file-based skill for local testing.

package/dist/testing.js

@@ -20,6 +20,19 @@
  * ```
  */
 import { consoleLogger } from "./types.js";
+// ─── Mock harness ────────────────────────────────────────────────
+const MOCK_CAPABILITIES = {
+    structuredOutput: "prompt",
+    toolTrace: "skill-only",
+    builtinDeny: "none",
+    mcp: { inject: false, exclusive: "none" },
+    sandbox: { fs: false, network: false },
+    readOnly: "none",
+    turnLimit: "none",
+    usage: { tokens: false, costUsd: false, live: false },
+    cancel: "signal",
+    resume: false,
+};
 /**
  * A mock Claude client that follows a script.
  *
@@ -28,7 +41,9 @@ import { consoleLogger } from "./types.js";
  * routes map. With no scripted route (or an invalid one) it returns
  * `null`, mirroring the real client failing closed on a route-eval failure.
  */
-export class MockClaude {
+export class MockHarness {
+    id = "mock";
+    capabilities = MOCK_CAPABILITIES;
     callOrder = [];
     responses;
     routes;
@@ -53,7 +68,18 @@ export class MockClaude {
     get executedNodes() {
         return [...this.callOrder];
     }
+    async preflight() {
+        return { ok: true, version: "mock" };
+    }
+    /** One scripted completion: the `ask` script, or the empty string. */
+    async complete(req) {
+        return this.ask({ instruction: req.prompt, context: {} });
+    }
     async run(opts) {
+        const result = await this.runScripted(opts);
+        return { ...result, harness: { id: "mock", version: "mock" }, degraded: [] };
+    }
+    async runScripted(opts) {
         // Identify which node this is by matching instruction text against responses
         // The executor wraps tools with event tracking, so we can find the node
         // by checking which response key's instruction appears
@@ -132,6 +158,8 @@ export class MockClaude {
         return unused[0] ?? `unknown-${this.callOrder.length}`;
     }
 }
+/** @deprecated Use {@link MockHarness}. */
+export const MockClaude = MockHarness;
 /**
  * Create a file-based skill for local testing.
  *