@anureo/conformance 0.0.0-stage → 0.3.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Yoichi
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,70 @@
-# Temporary Holding Version
+# @anureo/conformance
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The Anureo SDK conformance suites drive the revised AHP v1 client through the public runtime API.
+The shared suite, `runConformance`, drives any `HarnessAdapter` to verify the shared behavioral contract that AHP implies.
+Passing the shared suite establishes conformance only within that shared acceptance scope.
+Full adapter conformance also requires the native suite, `runNativeConformance`, which covers overlap,
+active close and independent observations, with native evidence supplied by adapter fixtures.
+Passing a subset does not establish full adapter conformance. See the [acceptance plan](../../docs/native-harness-lifecycle.md#9-实施顺序与验收).
+
+> Part of the [Anureo SDK workspace](../../README.md). Install with `npm install @anureo/conformance`.
+
+## Running a backend through the suite
+
+Implement a `ConformanceFactory` — one driver per scenario — and hand it to `runConformance`:
+
+```typescript
+import { runConformance, createScriptedAdapter, type ConformanceFactory } from '@anureo/conformance'
+
+const factory: ConformanceFactory = (scenario) => ({
+  adapter: createScriptedAdapter(),       // your adapter here
+  openParams: {
+    requestId: 'open', mode: 'new', cwd: process.cwd(),
+    binding: { sessionId: 'conformance', adapterId: 'scripted', runtimeConfigId: 'test' },
+  },
+  expectedText: 'conformance',
+})
+
+const report = await runConformance(factory, { timeoutMs: 3000 })
+if (!report.passed) {
+  for (const entry of report.cases) console.log(entry.scenario, entry.status, entry.message)
+}
+```
+
+Each case returns `passed`, `failed`, or `not-applicable`:
+
+- A scenario is **not-applicable** when its capability was not declared at initialization (e.g. `steer` for a backend without `input.steer.atomicMatch`).
+- A **declared** capability must actually pass its scenario — a missing fixture is a failure, not a skip. Declaring fork without a working fork is exactly the bug this suite exists to catch.
+
+## Scenarios
+
+`lifecycle`, `immediate`, `identity`, `approval`, `userInput`, `elicitation`, `dynamicTool`, `interrupt`, `steer`, `fork`, `revert`, `history`, `unknown-item`, `disconnect`, `backpressure`.
+
+The scenario list is the shared acceptance scope, not a claim that every protocol capability has exhaustive coverage. All four adapters in this workspace (Codex, Claude, ACP, AHP) are validated against the same suite; several adapters also use it as their unit-test backbone.
+
+## Exports
+
+| Entry | Contents |
+|---|---|
+| `@anureo/conformance` | `runConformance`, `ConformanceFactory`, `ConformanceDriver`, `ConformanceReport`, `CONFORMANCE_SCENARIOS`, plus everything from `/fake`, `/fixtures`, and the Claude fake below |
+| `@anureo/conformance/fake` | `createScriptedAdapter` (`ScriptedHarnessAdapter`), `FAKE_CAPABILITIES`, `FakeAdapterOptions` — an in-memory, official-API-shaped adapter that records calls and emits scripted results |
+| `@anureo/conformance/fixtures` | Native-wire fixture types: `ConformanceFixture`, `NativeFixtureFrame`, `WireFlavor` (`codex` / `claude` / `acp` / `ahp`), `MethodFixture` |
+
+Also included: `ScriptedClaudeQuery` / `createFakeClaudeQuery` — a minimal injectable query facade implementing the Claude SDK's structural surface (messages, interrupt, setModel, rewindFiles, supportedModels…), used to drive `@anureo/adapter-claude` without credentials.
+
+## Scripted backends under scripts/
+
+`scripts/` contains standalone fake backend processes (`fake-acp.ts`, `fake-ahp.ts`, `fake-codex.ts`, `fake-wire.ts`) that speak their real native wire protocols over stdio. Conformance tests use these processes to exercise real wire conversations over stdio.
+
+## Development
+
+```sh
+cd packages/conformance
+bun run typecheck
+bun test src
+```
+
+## Documentation
+
+- [Architecture](../../docs/architecture.md) — the conformance layer and validation scope (currently in Chinese)
+- [AHP v1 protocol](../../spec/ahp-v1.md)

package/examples/standalone.d.ts

@@ -0,0 +1 @@
+export {};

package/examples/standalone.js

@@ -0,0 +1,16 @@
+import { createClient } from '@anureo/sdk';
+import { createScriptedAdapter } from '@anureo/conformance/fake';
+// Runs a scripted backend without an account or model service.
+const client = await createClient({
+    adapter: createScriptedAdapter(),
+    identity: { adapterId: 'scripted', runtimeConfigId: 'local' },
+});
+try {
+    const session = await client.sessions.create({ cwd: process.cwd() });
+    const turn = await session.submit({ input: 'Hello from Anureo SDK' });
+    console.log((await turn.result()).text);
+    await session.close();
+}
+finally {
+    await client.dispose();
+}

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@anureo/conformance",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "Shared conformance suite and scripted fixtures for Anureo SDK adapters and AHP implementations",
+  "version": "0.3.0",
+  "license": "Apache-2.0",
+  "keywords": [
+    "anureo",
+    "ahp",
+    "harness",
+    "agent",
+    "conformance",
+    "testing"
+  ],
+  "homepage": "https://github.com/hi-youichi/anureo-sdk#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hi-youichi/anureo-sdk.git",
+    "directory": "packages/conformance"
+  },
+  "bugs": {
+    "url": "https://github.com/hi-youichi/anureo-sdk/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
+    },
+    "./fake": {
+      "types": "./src/fake.d.ts",
+      "import": "./src/fake.js",
+      "default": "./src/fake.js"
+    },
+    "./fixtures": {
+      "types": "./src/fixtures.d.ts",
+      "import": "./src/fixtures.js",
+      "default": "./src/fixtures.js"
+    }
+  },
+  "dependencies": {
+    "@anureo/protocol": "0.3.0",
+    "@anureo/sdk": "0.3.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "src",
+    "bin",
+    "schema",
+    "protocol",
+    "examples"
+  ]
+}

package/src/fake-claude.d.ts

@@ -0,0 +1,78 @@
+import type { JsonObject, JsonValue } from "@anureo/protocol";
+/** Configure the initial output, input behavior and simulated capabilities of a Claude query fixture. */
+export interface ClaudeQueryScript {
+    /** Initial messages cloned and buffered in order within the default BoundedEventQueue limits. */
+    messages: JsonObject[];
+    /**
+     * Supply a response script that streamInput awaits after recording each input.
+     * Await emit to buffer a message or deliver it to a waiting reader. It can wait for
+     * queue capacity and reject on closure or admission failure. Keep emitted objects stable
+     * while buffered. Callback failures reject streamInput and leave admitted output available.
+     */
+    onInput?: (input: JsonValue, emit: (message: JsonObject) => Promise<void>) => Promise<void>;
+    /** Returned by reference when supplied, including an empty list; omission selects the fake model. */
+    models?: Array<{
+        value: string;
+        displayName: string;
+        description: string;
+    }>;
+    /** Set true to allow simulated rewind. Omission or false returns a "No checkpoint" denial. */
+    canRewind?: boolean;
+}
+/**
+ * Script a Claude query for a test without launching a peer. Controls record observations
+ * for assertions. To use one with a Claude adapter's queryFactory, bridge the factory's
+ * prompt into streamInput, project the output as native SDK messages and supply additional
+ * Query methods the adapter requires, such as applyFlagSettings.
+ * Direct callers end output with finish or close and drain or return the output iterator.
+ */
+export declare class ScriptedClaudeQuery implements AsyncIterable<JsonObject> {
+    private readonly script;
+    /** Ordered input/control observations; input values are retained by reference. */
+    readonly calls: Array<{
+        method: string;
+        value?: JsonValue;
+    }>;
+    /** Clone and buffer initial messages; cloning or queue admission failures throw synchronously. */
+    constructor(script: ClaudeQueryScript);
+    /**
+     * Claim exclusive output reads. A second acquisition throws EVENT_STREAM_ALREADY_OWNED
+     * until the first iterator releases ownership. Overlapping pending reads reject with
+     * CONCURRENT_EVENT_READ. Call return when stopping early. If finish or close settled
+     * an already pending read, call return or next again to release ownership.
+     */
+    [Symbol.asyncIterator](): AsyncIterator<JsonObject>;
+    /**
+     * Consume one input stream in order, resolving at EOF after its onInput calls complete.
+     * Input, callback and awaited emit failures reject without closing output. The caller
+     * owns input cancellation and output closure; consume output concurrently if emits fill the queue.
+     */
+    streamInput(stream: AsyncIterable<JsonValue>): Promise<void>;
+    /** Record an interrupt without cancelling input or ending output. */
+    interrupt(): Promise<void>;
+    /** Record a model selection; omitted or empty model strings produce a call without a value. */
+    setModel(model?: string): Promise<void>;
+    /** Record a permission mode without validating or applying it. */
+    setPermissionMode(mode: string): Promise<void>;
+    /** Record a thinking-token budget, including null, without validating or applying it. */
+    setMaxThinkingTokens(tokens: number | null): Promise<void>;
+    /** Record the checkpoint ID and return configured availability; denial is a result, and no files change. */
+    rewindFiles(id: string): Promise<{
+        canRewind: boolean;
+        error?: string;
+    }>;
+    /** Resolve with the supplied list by reference or a fresh single-model list. This adds no call record. */
+    supportedModels(): Promise<{
+        value: string;
+        displayName: string;
+        description: string;
+    }[]>;
+    /** End output admission once and wake blocked emits to reject. Buffered messages still drain and input stays open. */
+    finish(): void;
+    /** Record close once and end output admission; buffered messages still drain and input is not cancelled. */
+    close(): void;
+    private readonly queue;
+    private closeCalled;
+}
+/** Create a query with its own call log and output queue. Initial cloning or admission failures throw synchronously. */
+export declare function createFakeClaudeQuery(script: ClaudeQueryScript): ScriptedClaudeQuery;

package/src/fake-claude.js

@@ -0,0 +1,68 @@
+import { BoundedEventQueue } from "@anureo/sdk";
+/**
+ * Script a Claude query for a test without launching a peer. Controls record observations
+ * for assertions. To use one with a Claude adapter's queryFactory, bridge the factory's
+ * prompt into streamInput, project the output as native SDK messages and supply additional
+ * Query methods the adapter requires, such as applyFlagSettings.
+ * Direct callers end output with finish or close and drain or return the output iterator.
+ */
+export class ScriptedClaudeQuery {
+    script;
+    /** Ordered input/control observations; input values are retained by reference. */
+    calls = [];
+    /** Clone and buffer initial messages; cloning or queue admission failures throw synchronously. */
+    constructor(script) {
+        this.script = script;
+        for (const message of script.messages)
+            this.queue.push(structuredClone(message));
+    }
+    /**
+     * Claim exclusive output reads. A second acquisition throws EVENT_STREAM_ALREADY_OWNED
+     * until the first iterator releases ownership. Overlapping pending reads reject with
+     * CONCURRENT_EVENT_READ. Call return when stopping early. If finish or close settled
+     * an already pending read, call return or next again to release ownership.
+     */
+    [Symbol.asyncIterator]() { return this.queue[Symbol.asyncIterator](); }
+    /**
+     * Consume one input stream in order, resolving at EOF after its onInput calls complete.
+     * Input, callback and awaited emit failures reject without closing output. The caller
+     * owns input cancellation and output closure; consume output concurrently if emits fill the queue.
+     */
+    async streamInput(stream) {
+        for await (const input of stream) {
+            this.calls.push({ method: "input", value: input });
+            await this.script.onInput?.(input, (message) => this.queue.write(message));
+        }
+    }
+    /** Record an interrupt without cancelling input or ending output. */
+    async interrupt() { this.calls.push({ method: "interrupt" }); }
+    /** Record a model selection; omitted or empty model strings produce a call without a value. */
+    async setModel(model) { this.calls.push({ method: "setModel", ...(model ? { value: model } : {}) }); }
+    /** Record a permission mode without validating or applying it. */
+    async setPermissionMode(mode) { this.calls.push({ method: "setPermissionMode", value: mode }); }
+    /** Record a thinking-token budget, including null, without validating or applying it. */
+    async setMaxThinkingTokens(tokens) { this.calls.push({ method: "setMaxThinkingTokens", value: tokens }); }
+    /** Record the checkpoint ID and return configured availability; denial is a result, and no files change. */
+    async rewindFiles(id) {
+        this.calls.push({ method: "rewindFiles", value: id });
+        return this.script.canRewind ? { canRewind: true } : { canRewind: false, error: "No checkpoint" };
+    }
+    /** Resolve with the supplied list by reference or a fresh single-model list. This adds no call record. */
+    async supportedModels() { return this.script.models ?? [{ value: "fake-model", displayName: "Fake", description: "Fixture" }]; }
+    /** End output admission once and wake blocked emits to reject. Buffered messages still drain and input stays open. */
+    finish() { this.queue.end(); }
+    /** Record close once and end output admission; buffered messages still drain and input is not cancelled. */
+    close() {
+        if (this.closeCalled)
+            return;
+        this.closeCalled = true;
+        this.calls.push({ method: "close" });
+        this.queue.end();
+    }
+    queue = new BoundedEventQueue();
+    closeCalled = false;
+}
+/** Create a query with its own call log and output queue. Initial cloning or admission failures throw synchronously. */
+export function createFakeClaudeQuery(script) {
+    return new ScriptedClaudeQuery(script);
+}

package/src/fake.d.ts

@@ -0,0 +1,122 @@
+import { type BackendSession, type HarnessAdapter, type SessionEventSink, type SessionMethod } from "@anureo/sdk";
+import { type Capabilities, type AhpRequestMap, type AhpResultMap, type HistoryItem, type InitializeParams, type InitializeResult, type SessionBinding, type SessionOpenParams, type SessionState, type AhpEventPayload } from "@anureo/protocol";
+import type { ConformanceFactory } from "./suite.js";
+/** One backend dispatch, recorded before any custom hook runs. */
+export interface FakeCall {
+    method: SessionMethod;
+    /** The dispatched object also used by the default handler if the hook returns undefined. */
+    params: AhpRequestMap[SessionMethod];
+}
+/** Configure an injectable in-memory backend for SDK, workflow and application fixtures. */
+export interface FakeAdapterOptions {
+    /** Replaces the complete default capability set. Adapter capability reads clone it. */
+    capabilities?: Capabilities;
+    /**
+     * ScriptedBackendSession.execute awaits this hook after recording a call. Return undefined to
+     * continue with default dispatch, or return a method-matching result to supply the entire
+     * response. In the latter case the hook owns the call's events and state changes. A throw or
+     * rejection rejects backend dispatch.
+     */
+    execute?: (call: FakeCall, sink: SessionEventSink) => Promise<AhpResultMap[SessionMethod] | undefined>;
+    /**
+     * Publish setup events or hold session acquisition. ScriptedHarnessAdapter.openSession awaits
+     * this hook after recording the backend and copying any fork history. A throw or rejection
+     * rejects acquisition and leaves the recorded fixture state available.
+     */
+    onOpen?: (params: SessionOpenParams, sink: SessionEventSink) => Promise<void>;
+}
+/** Default advertised capabilities. Adapter reads clone the current contents of this mutable template. */
+export declare const FAKE_CAPABILITIES: Capabilities;
+/** Create a fresh adapter to pass to createClient. Await disposal of the client when the fixture is done. */
+export declare function createScriptedAdapter(options?: FakeAdapterOptions): ScriptedHarnessAdapter;
+/**
+ * Supply runConformance with a fresh in-memory adapter per case, including held turns and
+ * observation faults. A supplied capability set replaces the defaults for applicability checks.
+ * The runner owns each client and its adapter.
+ */
+export declare function createScriptedConformanceFactory(capabilities?: Capabilities): ConformanceFactory;
+/**
+ * Exercise the SDK with an in-memory adapter that records opens and backend dispatches. By default
+ * a submission echoes text and publishes completion before acknowledging it. Hooks can supply
+ * other behavior. Await Client.dispose to release SDK ownership while retaining fixture records
+ * for assertions.
+ */
+export declare class ScriptedHarnessAdapter implements HarnessAdapter {
+    readonly options: FakeAdapterOptions;
+    /** Retain fixture options by reference for subsequent capability reads, opens and dispatches. */
+    constructor(options?: FakeAdapterOptions);
+    /** Backend dispatches in arrival order, including calls intercepted by execute. */
+    readonly calls: FakeCall[];
+    /** Detached open attempts, including attempts whose hook or fork validation fails. */
+    readonly opened: SessionOpenParams[];
+    /** Latest supplied event sink per session ID, retained for fixture-controlled publication/failure. */
+    readonly sinks: Map<string, SessionEventSink>;
+    /** Latest created backend per session ID, recorded before fork validation and onOpen. */
+    readonly backends: Map<string, ScriptedBackendSession>;
+    /** Number of disposal calls received, including any repeated direct calls. */
+    disposeCount: number;
+    /** Return detached declared capabilities, using FAKE_CAPABILITIES when omitted. */
+    get capabilities(): Capabilities;
+    /**
+     * Return scripted runtime metadata and cloned capabilities after negotiating AHP v1. The SDK
+     * adapter wrapper forwards the result to Client.initialize for validation and storage. Malformed
+     * requests and unsupported versions reject.
+     */
+    initialize(params: InitializeParams): Promise<InitializeResult>;
+    /**
+     * Supply OutputSession.open with a backend for SDK attachment. Record the backend and sink
+     * before copying fork history so a failed setup is observable. Missing source or boundary
+     * rejects with SESSION_NOT_FOUND or TURN_NOT_FOUND, respectively. Await onOpen before returning
+     * the backend. Hook failures reject and leave the recorded fixture state available.
+     */
+    openSession(params: SessionOpenParams, sink: SessionEventSink): Promise<BackendSession>;
+    /** Count adapter release. The SDK wrapper calls this after session cleanup attempts. */
+    dispose(): Promise<void>;
+    /**
+     * Give openSession a detached prefix of the source history before setup hooks run. A missing
+     * source or boundary throws so open rejects with the fork's fixture records still available.
+     */
+    private copyForkHistory;
+}
+/**
+ * Inspect or customize the in-memory session recorded by ScriptedHarnessAdapter.openSession.
+ * OutputSession dispatches validated SDK requests to this backend. Direct fixture calls to execute
+ * bypass those SDK guards.
+ */
+export declare class ScriptedBackendSession implements BackendSession {
+    private readonly adapter;
+    /** Callbacks supplied at open for event publication, interactions and source faults. */
+    readonly sink: SessionEventSink;
+    /** Requested identity with a deterministic scripted nativeRef, adopted by the SDK at attachment. */
+    readonly binding: SessionBinding;
+    /** Capabilities cloned from the adapter at construction and shared with the fixture state. */
+    readonly capabilities: Capabilities;
+    /** Mutable native history. Default backend history/read returns this array by reference. */
+    readonly history: HistoryItem[];
+    /** Number of disposal calls received, including any repeated direct calls. */
+    disposeCount: number;
+    /** Initial attachment snapshot. Default configuration dispatch replaces it without publishing a state event. */
+    state: SessionState;
+    /** Build a ready attachment snapshot and retain the adapter and event sink for dispatch. */
+    constructor(adapter: ScriptedHarnessAdapter, params: SessionOpenParams, 
+    /** Callbacks supplied at open for event publication, interactions and source faults. */
+    sink: SessionEventSink);
+    /** Await ordered sink publication. Supply the owning turn ID for item events. Sink failures reject. */
+    emit(payload: AhpEventPayload, turnId?: string): Promise<void>;
+    /**
+     * Resolve a scripted result for OutputSession.execute, which uses receipts to bind submissions
+     * before returning to Session for request-result validation. Record the call and await the
+     * custom hook before using defaults. Defaults that publish events await them before returning
+     * a receipt. Sink and hook failures reject dispatch. Default interaction dispatch rejects
+     * because Session handles it in its registry.
+     */
+    execute<M extends SessionMethod>(method: M, params: AhpRequestMap[M]): Promise<AhpResultMap[M]>;
+    /** Count backend release calls from the SDK or direct fixture callers and retain state for assertions. */
+    dispose(): Promise<void>;
+    /**
+     * Produce the default submission receipt after publishing start, preview, final item and terminal.
+     * Reuse an item ID across turns to exercise SDK scoping. Store the completed item before terminal
+     * publication, where a sink failure can still reject the dispatch.
+     */
+    private submitInput;
+}