@noetic-tools/types 3.2.1 → 3.3.0

package/dist/types/context.d.ts

@@ -110,7 +110,7 @@ export interface Context<TContext = ContextData, TState = unknown> {
      *
      * Aborting rejects operations blocked on the context (channel `recv` waiters,
      * parked back-pressure senders) with `cancelled`, cuts short the in-flight
-     * model call or sub-harness turn, and makes the next step boundary throw
+     * model call or ACP agent turn, and makes the next step boundary throw
      * `cancelled`. Context-layer teardown is NOT run — use
      * `harness.cancel(ctx, reason)` for that.
      */

package/dist/types/output-codec.d.ts

@@ -5,7 +5,7 @@
  * `StepCallModel.output`: instead of JSON-parsing the assistant text once at turn
  * end, a codec is fed each text delta as it streams and produces a typed
  * value when the turn finishes. OpenUI Lang is one dialect; the contract
- * lives here — next to `ContextLayer` and `SubHarness` — so `core` and
+ * lives here — next to `ContextLayer` and `AcpAgent` — so `core` and
  * dialect packages both depend on it without forming a cycle.
  */
 /**

package/dist/types/output-codec.js

@@ -5,7 +5,7 @@
  * `StepCallModel.output`: instead of JSON-parsing the assistant text once at turn
  * end, a codec is fed each text delta as it streams and produces a typed
  * value when the turn finishes. OpenUI Lang is one dialect; the contract
- * lives here — next to `ContextLayer` and `SubHarness` — so `core` and
+ * lives here — next to `ContextLayer` and `AcpAgent` — so `core` and
  * dialect packages both depend on it without forming a cycle.
  */
 /**

package/dist/types/runtime.d.ts

@@ -101,12 +101,17 @@ interface CallModelRequestWithTools extends CallModelRequestBase {
     /** When set, restricts which tools the model may invoke for this call. */
     allowedToolNames?: string[];
 }
-/** @public Request shape when no tools are provided — ctx is only needed for tool
- *  execution callbacks in convertTools, so it is omitted here. */
+/**
+ * @public Request shape when no tools are provided. `ctx` is still accepted —
+ * it carries the session broadcaster, without which a tool-less call streams
+ * nothing to `getFullStream`/`getTextStream` — it just isn't *required* the
+ * way the tools variant needs it for execution callbacks.
+ */
 interface CallModelRequestWithoutTools extends CallModelRequestBase {
     tools?: undefined;
-    ctx?: undefined;
-    layers?: undefined;
+    ctx?: Context;
+    layers?: ContextLayer[];
+    allowedToolNames?: undefined;
 }
 /** @public Request object for `AgentHarnessContract.callModel()`. Encapsulates all parameters needed for an LLM call using only Noetic types. */
 export type CallModelRequest = CallModelRequestWithTools | CallModelRequestWithoutTools;
@@ -117,6 +122,13 @@ export interface ExecuteOptions {
     state?: unknown;
     /** Context layers to apply to the execution context. Overrides harness-level layers if provided. */
     contextLayers?: ContextLayer[];
+    /**
+     * Additional context layers appended AFTER the effective layer set
+     * (harness-level layers, or `contextLayers` when that override is given).
+     * Use this to inject a per-turn layer — a permission gate, an observer —
+     * without discarding the layers the harness was built with.
+     */
+    extraContextLayers?: ContextLayer[];
     /** Override the harness's default delivery mode for this message only. */
     deliveryMode?: DeliveryMode;
     /**
@@ -244,6 +256,8 @@ export interface AgentHarnessContract<TParams extends Record<string, unknown> =
         threadId?: string;
         resourceId?: string;
         contextLayers?: ContextLayer[];
+        /** Additional layers appended AFTER the effective layer set (see `ExecuteOptions.extraContextLayers`). */
+        extraContextLayers?: ContextLayer[];
         /** Override the new context's initial cwd. */
         cwdInit?: string;
     }): Context;
@@ -308,7 +322,7 @@ export interface AgentHarnessContract<TParams extends Record<string, unknown> =
      * (`onComplete` with `outcome: 'aborted'`, then `dispose`) bottom-up.
      *
      * Blocked channel operations reject with `cancelled`, the in-flight model
-     * call and sub-harness turn are cut short, and the next step boundary throws
+     * call and ACP agent turn are cut short, and the next step boundary throws
      * `cancelled`. Idempotent: cancelling an already-cancelled context is a
      * no-op. Use `ctx.abort()` when you want the signal without layer teardown.
      */
@@ -318,7 +332,7 @@ export interface AgentHarnessContract<TParams extends Record<string, unknown> =
     createSpan(name: string, parent: Span | null): Span;
     getLayerState<T>(executionId: string, layerId: string): T | undefined;
     setLayerState<T>(executionId: string, layerId: string, state: T): void;
-    beforeToolCall(layers: ContextLayer[], toolName: string, toolArgs: unknown, ctx: Context): Promise<SteeringDecision>;
+    beforeToolCall(layers: ContextLayer[], toolName: string, toolArgs: unknown, ctx: Context, callId?: string): Promise<SteeringDecision>;
     afterModelCall(layers: ContextLayer[], response: LLMResponse, ctx: Context): Promise<SteeringDecision>;
     /**
      * Project the history items through every layer's `projectHistory` hook in

package/dist/types/steering.d.ts

@@ -42,6 +42,15 @@ export interface LedgerEntry {
 export interface BeforeToolCallParams<TState = unknown> {
     toolName: string;
     toolArgs: unknown;
+    /**
+     * Correlation id of the pending call — the same id carried by the
+     * `tool_call_started` framework event (the model's `callId` on model-driven
+     * calls, the step id on a direct `invokeTool`). Lets a gating layer tie its
+     * decision to the call it is reported as, e.g. when forwarding the request
+     * to an external approver. Optional because a custom caller of the gate may
+     * have no call identity; every built-in tool-executing path supplies it.
+     */
+    callId?: string;
     ctx: ExecutionContext;
     state: TState;
 }

package/dist/types/step.d.ts

@@ -1,11 +1,11 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { AcpAgent, AcpClientCapabilityConfig, AcpContentBlock, AcpMcpServer, AcpPermissionHandler, AcpPermissionPolicy, AcpSessionPolicy } from './acp.js';
 import type { Channel } from './channel.js';
 import type { ModelParams, RetryPolicy, ServerToolSpec, StepMeta } from './common.js';
 import type { Context } from './context.js';
 import type { ContextConfig, ContextData, ContextLayer, ProjectionPolicy } from './context-layer.js';
 import type { NoeticError } from './error.js';
 import type { OutputCodec } from './output-codec.js';
-import type { SubHarness, SubHarnessKind, SubHarnessSessionPolicy, SubHarnessSettings } from './sub-harness.js';
 import type { SubprocessAdapter } from './subprocess-adapter.js';
 import type { Tool } from './tool.js';
 /**
@@ -73,7 +73,7 @@ export interface SettleResult<O> {
     error?: NoeticError;
 }
 /** @public Discriminated union of all step kinds that can be composed into an execution tree. */
-export type Step<TContext = ContextData, I = unknown, O = unknown> = StepRunCode<TContext, I, O> | StepCallModel<TContext, I, O> | StepSubHarness<TContext, I, O> | StepInvokeTool<TContext, I, O> | StepConditional<TContext, I, O> | StepInParallel<TContext, I, O> | StepSpawn<TContext, I, O> | StepWithContext<TContext, I, O> | StepLoop<TContext, I, O> | StepSchedule<TContext, I, O>;
+export type Step<TContext = ContextData, I = unknown, O = unknown> = StepRunCode<TContext, I, O> | StepCallModel<TContext, I, O> | StepAcpAgent<TContext, I, O> | StepInvokeTool<TContext, I, O> | StepConditional<TContext, I, O> | StepInParallel<TContext, I, O> | StepSpawn<TContext, I, O> | StepWithContext<TContext, I, O> | StepLoop<TContext, I, O> | StepSchedule<TContext, I, O>;
 /** @public A step that executes arbitrary async logic via a user-supplied function. */
 export interface StepRunCode<TContext = ContextData, I = unknown, O = unknown> {
     kind: 'runCode';
@@ -123,32 +123,46 @@ export interface StepCallModel<TContext = ContextData, _I = unknown, O = unknown
     projection?: ProjectionPolicy;
 }
 /**
- * A step that delegates a turn to an external coding-agent harness
- * (Claude Code, Codex, opencode, pi). Each harness kind is a distinct
- * `Step.kind`, but every variant shares this shape and is executed by one
- * interpreter handler.
+ * A step that delegates a turn to an external coding agent over the Agent
+ * Client Protocol. One step kind serves every ACP-speaking agent — the agent
+ * itself is supplied as an adapter, so the set of supported agents is open.
  * @public
  */
-export interface StepSubHarness<TContext = ContextData, _I = unknown, O = unknown> {
-    /** The harness kind, equal to the backing adapter's `harnessId`. */
-    kind: SubHarnessKind;
+export interface StepAcpAgent<TContext = ContextData, _I = unknown, O = unknown> {
+    kind: 'acp-agent';
     id: string;
     /**
-     * The harness adapter that runs the turn. Eager or `(ctx) => SubHarness`.
+     * The ACP agent adapter that runs the turn. Eager or `(ctx) => AcpAgent`.
      * Programmatic builders take it inline; the JSON hydrator resolves it from
-     * the workflow's harness registry and inlines it here.
+     * the workflow's agent registry and inlines it here.
      */
-    harness: Lazy<SubHarness, TContext>;
-    /** Turn prompt. Eager string or `(ctx) => string` getter. */
-    prompt: Lazy<string, TContext>;
-    /** Shared harness settings (model, permission mode, …). */
-    settings?: SubHarnessSettings;
-    /** System instructions applied on the first message of a fresh session. */
-    instructions?: Lazy<string | undefined, TContext>;
+    agent: Lazy<AcpAgent, TContext>;
+    /** Turn prompt as plain text. Eager string or `(ctx) => string` getter. */
+    prompt?: Lazy<string, TContext>;
+    /**
+     * Full ACP prompt content — images, audio, resource links, embedded context.
+     * Appended after `prompt` when both are given. Validated against the agent's
+     * advertised `promptCapabilities` before the turn is sent.
+     */
+    content?: Lazy<ReadonlyArray<AcpContentBlock> | undefined, TContext>;
+    /** MCP servers to expose to the agent for this session. */
+    mcpServers?: Lazy<ReadonlyArray<AcpMcpServer> | undefined, TContext>;
+    /** Working directory for the session. Defaults to `ctx.cwdState.cwd`. */
+    cwd?: Lazy<string | undefined, TContext>;
+    /** Session mode to switch to before prompting (e.g. `'plan'`). */
+    mode?: Lazy<string | undefined, TContext>;
+    /** Model to select before prompting, for agents that expose model selection. */
+    model?: Lazy<string | undefined, TContext>;
+    /** Declarative answer to the agent's permission requests. */
+    permissions?: AcpPermissionPolicy;
+    /** Async resolver consulted when policy and steering both abstain. */
+    onPermissionRequest?: AcpPermissionHandler;
+    /** Which client capabilities to advertise to the agent. */
+    clientCapabilities?: AcpClientCapabilityConfig;
     /** When set, the assistant text is JSON-parsed and validated against this Standard Schema. */
     output?: StandardSchemaV1<unknown, O>;
     /** Session reuse + teardown policy across steps. */
-    session?: SubHarnessSessionPolicy;
+    session?: AcpSessionPolicy;
     /** Controls framework event emission for this step. Defaults to `true`. */
     emit?: boolean | ((eventType: string, data: Record<string, unknown>) => boolean);
 }

package/dist/types/tool.d.ts

@@ -1,4 +1,5 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { AcpToolKind } from './acp.js';
 import type { FunctionCallItem, FunctionCallOutputItem, Item, ItemSchemaExtensions, ToolResultExtensionItem } from './items.js';
 import type { InferSchemaOutput } from './schema.js';
 type ToolExecutionResult<O extends StandardSchemaV1> = Promise<InferSchemaOutput<O>> | AsyncGenerator<unknown, InferSchemaOutput<O>>;
@@ -50,6 +51,33 @@ export interface ToolUiDeclaration<I extends StandardSchemaV1 = StandardSchemaV1
     /** Replaces the tool's region when execution throws. */
     error?(err: unknown, args: InferSchemaOutput<I>): UiFragment | null;
 }
+/**
+ * How a tool call presents in an ACP client's UI when the harness is served
+ * as an ACP agent (`toAcpAgent`/`serveAcp` in `@noetic-tools/acp`).
+ *
+ * Presentation only — it never gates anything. An undeclared tool falls back
+ * to kind `other` with its name as the title. Declared as methods (bivariant
+ * params) for the same reason as `ToolUiDeclaration`.
+ * @public
+ */
+export interface ToolAcpDeclaration<I extends StandardSchemaV1 = StandardSchemaV1> {
+    /** ACP tool kind (`read`, `edit`, `execute`, …) for editor rendering. */
+    kind?: AcpToolKind;
+    /** Human-readable title; a function receives the call's parsed args. */
+    title?: string | ToolAcpTitleFn<I>;
+    /** File paths the call affects, surfaced as ACP `locations`. */
+    locations?(args: InferSchemaOutput<I>): string[];
+}
+/**
+ * Bivariant function type for `ToolAcpDeclaration.title` — a union member
+ * cannot use method syntax, so the method-bearing object type is indexed to
+ * recover the same bivariance `ToolUiDeclaration`'s methods get, keeping a
+ * concretely-typed tool assignable to the erased `Tool` form.
+ * @public
+ */
+export type ToolAcpTitleFn<I extends StandardSchemaV1 = StandardSchemaV1> = {
+    bivariant(args: InferSchemaOutput<I>): string;
+}['bivariant'];
 /**
  * A tool definition that an LLM can invoke during execution.
  *
@@ -105,5 +133,7 @@ export interface Tool<I extends StandardSchemaV1 = StandardSchemaV1, O extends S
     context?: ToolContextDeclaration;
     /** Optional UI declaration — the runtime emits the rendered fragments at call/progress/result points. */
     ui?: ToolUiDeclaration<I, O>;
+    /** Optional ACP presentation — how the call renders in an ACP client when the harness is served as an agent. */
+    acp?: ToolAcpDeclaration<I>;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noetic-tools/types",
-  "version": "3.2.1",
+  "version": "3.3.0",
   "type": "module",
   "description": "Foundational type contracts and primitives shared across the Noetic framework (items, LLM config, adapters, steering, errors).",
   "license": "Apache-2.0",
@@ -56,6 +56,7 @@
   "dependencies": {
     "@openrouter/agent": "^0.6.0",
     "@standard-schema/spec": "1.1.0",
+    "@zed-industries/agent-client-protocol": "^0.4.5",
     "zod": "^4.0.0"
   },
   "scripts": {

package/dist/types/sub-harness.d.ts

@@ -1,273 +0,0 @@
-/**
- * Coding-agent harness contract.
- *
- * A "harness" here is a pluggable backend that drives an external agentic
- * coding tool — Claude Code, Codex, opencode, pi — as a Noetic step. It is the
- * direct analogue of the `ContextLayer` contract: defined in the dependency-free
- * `@noetic-tools/types` foundation so both `@noetic-tools/core` (which executes
- * harness steps) and the per-tool `@noetic-tools/sub-harness-*` packages (which
- * implement them) can depend on it without forming a cycle.
- *
- * Modelled on Vercel's `HarnessV1` spec: a tagged spec version, a small set of
- * descriptive fields, and a single `doStart` entry point that yields a session.
- * Optional capabilities are signalled by the presence of optional methods, not
- * a static capabilities object — an adapter that cannot satisfy a request
- * throws {@link SubHarnessCapabilityError} from the relevant method.
- */
-import { z } from 'zod';
-import type { TokenUsage } from './common.js';
-import type { FsAdapter } from './fs-adapter.js';
-import type { Item } from './items.js';
-import type { ShellAdapter } from './shell-adapter.js';
-import type { SubprocessAdapter } from './subprocess-adapter.js';
-/**
- * The set of harness step kinds. Each value is a distinct `Step.kind`, so a
- * `step.claudeCode(...)` and a `step.codex(...)` are separate, individually
- * typed step variants — while the interpreter routes all of them through a
- * single shared `executeSubHarness` handler.
- * @public
- */
-export declare const SubHarnessKind: {
-    readonly ClaudeCode: 'claude-code';
-    readonly Codex: 'codex';
-    readonly Opencode: 'opencode';
-    readonly Pi: 'pi';
-};
-/** @public Union of all harness step kinds. */
-export type SubHarnessKind = (typeof SubHarnessKind)[keyof typeof SubHarnessKind];
-/** @public Ordered list of every harness kind — the single source of truth consumed by the JSON schema and the interpreter. */
-export declare const SUB_HARNESS_KINDS: ReadonlyArray<SubHarnessKind>;
-/**
- * Settings shared by every harness step. Tool-specific knobs that don't map to
- * a shared concept go through `extra`, which each adapter interprets (and may
- * reject with {@link SubHarnessCapabilityError}).
- * @public
- */
-export interface SubHarnessSettings {
-    /** Model identifier for the underlying agent (e.g. `claude-opus-4-8`). */
-    model?: string;
-    /** Permission posture for tool/file mutations the agent attempts. */
-    permissionMode?: 'default' | 'plan' | 'acceptEdits' | 'bypassPermissions';
-    /** Hard cap on internal agent turns before it must yield. */
-    maxTurns?: number;
-    /** Restrict the agent to this set of built-in tool names. */
-    allowedTools?: ReadonlyArray<string>;
-    /** Tool-specific passthrough options interpreted by the adapter. */
-    extra?: Record<string, unknown>;
-}
-/**
- * Controls how a harness session is reused and torn down across steps.
- * @public
- */
-export interface SubHarnessSessionPolicy {
-    /**
-     * Reuse a live session keyed by this id across multiple harness steps. When
-     * omitted, each step gets a fresh session that is stopped on completion.
-     */
-    reuse?: string;
-    /**
-     * Lifecycle action when the step completes. `'stop'` (default) persists state
-     * and stops the runtime; `'detach'` parks it for later resume; `'destroy'`
-     * discards it with no resume state.
-     */
-    onComplete?: 'stop' | 'detach' | 'destroy';
-}
-/** @public Why an agentic turn ended. */
-export type SubHarnessFinishReason = 'stop' | 'length' | 'aborted' | 'error' | 'tool-calls';
-/**
- * Runtime validation schema for {@link SubHarnessStreamPart}. Adapters that move
- * events across a process or transport boundary (e.g. a sandbox bridge)
- * validate with this before forwarding.
- * @public
- */
-export declare const SubHarnessStreamPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"stream-start">;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"text-delta">;
-    delta: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"reasoning-delta">;
-    delta: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool-call">;
-    toolCallId: z.ZodString;
-    toolName: z.ZodString;
-    input: z.ZodUnknown;
-    providerExecuted: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool-result">;
-    toolCallId: z.ZodString;
-    toolName: z.ZodString;
-    output: z.ZodUnknown;
-    isError: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"file-change">;
-    path: z.ZodOptional<z.ZodString>;
-    summary: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"finish">;
-    finishReason: z.ZodEnum<{
-        aborted: "aborted";
-        error: "error";
-        length: "length";
-        stop: "stop";
-        "tool-calls": "tool-calls";
-    }>;
-    usage: z.ZodOptional<z.ZodObject<{
-        input: z.ZodNumber;
-        output: z.ZodNumber;
-        total: z.ZodOptional<z.ZodNumber>;
-        cached: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    cost: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"error">;
-    error: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"raw">;
-    value: z.ZodUnknown;
-}, z.core.$strip>], "type">;
-/**
- * A single event emitted by a harness during a turn. Mirrors the model-stream
- * primitives so the interpreter can forward them as framework events with
- * minimal translation. Adapter-specific metadata rides on `raw`.
- * @public
- */
-export type SubHarnessStreamPart = z.infer<typeof SubHarnessStreamPartSchema>;
-/**
- * The workspace surface a harness session may touch during a turn. A focused
- * subset of {@link Context} so adapters don't depend on the full runtime type.
- * @public
- */
-export interface SubHarnessRunContext {
-    /** Working directory the agent runs in (resolved from `ctx.cwdState.cwd`). */
-    readonly cwd: string;
-    readonly fs: FsAdapter;
-    readonly shell: ShellAdapter;
-    readonly subprocess: SubprocessAdapter;
-    /** Conversation thread id, for adapters that persist per-thread session state. */
-    readonly threadId: string;
-    /** Abort signal for the surrounding execution. */
-    readonly signal?: AbortSignal;
-}
-/** @public Opaque, adapter-defined state for resuming a stopped/detached session. */
-export interface SubHarnessResumeState {
-    readonly harnessId: string;
-    readonly sessionId: string;
-    readonly state: unknown;
-}
-/** @public Opaque, adapter-defined state for continuing a turn frozen mid-flight. */
-export interface SubHarnessContinueState {
-    readonly harnessId: string;
-    readonly sessionId: string;
-    readonly state: unknown;
-}
-/** @public Options handed to {@link SubHarness.doStart}. */
-export interface SubHarnessStartOptions<TSettings = SubHarnessSettings> {
-    /** Per-step settings (model, permission mode, …). */
-    settings?: TSettings;
-    /**
-     * System instructions applied once on the first message of a fresh session.
-     * Never re-applied on resume.
-     */
-    instructions?: string;
-    /**
-     * Prior conversation history (from earlier LLM/sub-harness steps and turns)
-     * used to seed a fresh session so the agent has full context of the
-     * conversation so far. Empty for the very first step of a run.
-     */
-    history?: ReadonlyArray<Item>;
-    /** The workspace surface for this run. */
-    ctx: SubHarnessRunContext;
-    /** Resume a previously stopped/detached session. */
-    resumeFrom?: SubHarnessResumeState;
-    /** Continue a turn previously frozen via {@link SubHarnessSession.doSuspendTurn}. */
-    continueFrom?: SubHarnessContinueState;
-    signal?: AbortSignal;
-}
-/** @public Options for a single agentic turn. */
-export interface SubHarnessPromptTurnOptions {
-    /** Fresh turn input only — the session owns conversation history. */
-    prompt: string;
-    /** Sink for stream events produced during the turn. */
-    emit: (part: SubHarnessStreamPart) => void;
-    signal?: AbortSignal;
-}
-/** @public Options for continuing a turn frozen mid-flight. */
-export interface SubHarnessContinueTurnOptions {
-    emit: (part: SubHarnessStreamPart) => void;
-    signal?: AbortSignal;
-}
-/**
- * Result of a completed agentic turn. The interpreter appends `items` to the
- * item log, charges `usage`/`cost`, and returns `text` (or parses it through
- * the step's output schema).
- * @public
- */
-export interface SubHarnessTurnResult {
-    /** Noetic Items produced this turn (assistant message, tool calls/results). */
-    items: Item[];
-    /** Final assistant text of the turn. */
-    text: string;
-    usage?: TokenUsage;
-    cost?: number;
-    finishReason?: SubHarnessFinishReason;
-    /** Adapter-specific metadata (peer to provider metadata, not a subtype). */
-    harnessMetadata?: Record<string, unknown>;
-}
-/**
- * Describes a tool the underlying agent executes natively, mapped to a shared
- * `commonName` so consumers can recognise "the same kind of tool" across
- * harnesses (Claude's `Bash`, Codex's `shell`, pi's `bash` → `shell`).
- * @public
- */
-export interface SubHarnessBuiltinTool {
-    /** The agent's native tool name. */
-    readonly nativeName: string;
-    /** Shared cross-harness name, when one exists. */
-    readonly commonName?: string;
-    readonly description?: string;
-}
-/**
- * A live harness session: one workspace + one conversation history + one
- * running runtime, kept across turns by the interpreter.
- * @public
- */
-export interface SubHarnessSession {
-    readonly sessionId: string;
-    /** True when this session was resumed rather than freshly started. */
-    readonly isResume: boolean;
-    /** The model the session resolved to, when the runtime reports it. */
-    readonly modelId?: string;
-    /** Run one agentic turn to completion. */
-    doPromptTurn(opts: SubHarnessPromptTurnOptions): Promise<SubHarnessTurnResult>;
-    /** Continue a turn previously frozen via {@link doSuspendTurn}. */
-    doContinueTurn?(opts: SubHarnessContinueTurnOptions): Promise<SubHarnessTurnResult>;
-    /** Freeze the current turn at a precise event cursor; runtime stays alive. */
-    doSuspendTurn?(): Promise<SubHarnessContinueState>;
-    /** Manually compact conversation history. Throws {@link SubHarnessCapabilityError} if unsupported. */
-    doCompact?(customInstructions?: string): Promise<void>;
-    /** Park the session between turns; runtime stays alive. */
-    doDetach?(): Promise<SubHarnessResumeState>;
-    /** Persist state and stop the runtime. */
-    doStop(): Promise<SubHarnessResumeState>;
-    /** Stop the runtime with no resume state. */
-    doDestroy?(): Promise<void>;
-}
-/**
- * A coding-agent harness. Each `@noetic-tools/sub-harness-*` package exports a
- * factory returning one of these (e.g. `claudeCode({ model })`).
- * @public
- */
-export interface SubHarness<TSettings = SubHarnessSettings> {
-    /** Spec tag for forward-compatibility. */
-    readonly specificationVersion: 'harness-v1';
-    /** Stable identifier, equal to the step kind it backs (e.g. `claude-code`). */
-    readonly harnessId: SubHarnessKind;
-    /** Tools the underlying agent executes natively. */
-    readonly builtinTools?: ReadonlyArray<SubHarnessBuiltinTool>;
-    /** Validates `resumeFrom`/`continueFrom` payloads, when the adapter persists them. */
-    readonly lifecycleStateSchema?: z.ZodType;
-    /** Start (or resume/continue) a session. */
-    doStart(opts: SubHarnessStartOptions<TSettings>): Promise<SubHarnessSession>;
-}

package/dist/types/sub-harness.js

@@ -1,106 +0,0 @@
-/**
- * Coding-agent harness contract.
- *
- * A "harness" here is a pluggable backend that drives an external agentic
- * coding tool — Claude Code, Codex, opencode, pi — as a Noetic step. It is the
- * direct analogue of the `ContextLayer` contract: defined in the dependency-free
- * `@noetic-tools/types` foundation so both `@noetic-tools/core` (which executes
- * harness steps) and the per-tool `@noetic-tools/sub-harness-*` packages (which
- * implement them) can depend on it without forming a cycle.
- *
- * Modelled on Vercel's `HarnessV1` spec: a tagged spec version, a small set of
- * descriptive fields, and a single `doStart` entry point that yields a session.
- * Optional capabilities are signalled by the presence of optional methods, not
- * a static capabilities object — an adapter that cannot satisfy a request
- * throws {@link SubHarnessCapabilityError} from the relevant method.
- */
-import { z } from 'zod';
-//#region Step-kind discriminator
-/**
- * The set of harness step kinds. Each value is a distinct `Step.kind`, so a
- * `step.claudeCode(...)` and a `step.codex(...)` are separate, individually
- * typed step variants — while the interpreter routes all of them through a
- * single shared `executeSubHarness` handler.
- * @public
- */
-export const SubHarnessKind = {
-    ClaudeCode: 'claude-code',
-    Codex: 'codex',
-    Opencode: 'opencode',
-    Pi: 'pi',
-};
-/** @public Ordered list of every harness kind — the single source of truth consumed by the JSON schema and the interpreter. */
-export const SUB_HARNESS_KINDS = [
-    SubHarnessKind.ClaudeCode,
-    SubHarnessKind.Codex,
-    SubHarnessKind.Opencode,
-    SubHarnessKind.Pi,
-];
-const HarnessFinishReasonSchema = z.enum([
-    'stop',
-    'length',
-    'aborted',
-    'error',
-    'tool-calls',
-]);
-const TokenUsageSchema = z.object({
-    input: z.number(),
-    output: z.number(),
-    total: z.number().optional(),
-    cached: z.number().optional(),
-});
-/**
- * Runtime validation schema for {@link SubHarnessStreamPart}. Adapters that move
- * events across a process or transport boundary (e.g. a sandbox bridge)
- * validate with this before forwarding.
- * @public
- */
-export const SubHarnessStreamPartSchema = z.discriminatedUnion('type', [
-    z.object({
-        type: z.literal('stream-start'),
-    }),
-    z.object({
-        type: z.literal('text-delta'),
-        delta: z.string(),
-    }),
-    z.object({
-        type: z.literal('reasoning-delta'),
-        delta: z.string(),
-    }),
-    z.object({
-        type: z.literal('tool-call'),
-        toolCallId: z.string(),
-        toolName: z.string(),
-        input: z.unknown(),
-        /** True when the underlying agent executed the tool itself (vs. host dispatch). */
-        providerExecuted: z.boolean().optional(),
-    }),
-    z.object({
-        type: z.literal('tool-result'),
-        toolCallId: z.string(),
-        toolName: z.string(),
-        output: z.unknown(),
-        isError: z.boolean().optional(),
-    }),
-    z.object({
-        type: z.literal('file-change'),
-        path: z.string().optional(),
-        summary: z.string().optional(),
-    }),
-    z.object({
-        type: z.literal('finish'),
-        finishReason: HarnessFinishReasonSchema,
-        usage: TokenUsageSchema.optional(),
-        cost: z.number().optional(),
-    }),
-    z.object({
-        type: z.literal('error'),
-        error: z.string(),
-    }),
-    /** Adapter-specific passthrough for events with no canonical mapping. */
-    z.object({
-        type: z.literal('raw'),
-        value: z.unknown(),
-    }),
-]);
-//#endregion