@anureo/adapter-acp 0.0.0-stage → 0.2.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,61 @@
-# Temporary Holding Version
+# @anureo/adapter-acp
 
-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.
+Adapter connecting the Anureo SDK to agents implementing the [Agent Client Protocol](https://agentclientprotocol.com) (ACP), using the official `@agentclientprotocol/sdk` 1.4.0. ACP is an editor↔agent protocol; this adapter brings any standard ACP agent behind the AHP session model — the interoperability proof that AHP is a host-side semantic layer, not a competing agent protocol.
+
+> Part of the [Anureo SDK workspace](../../README.md). Install with `npm install @anureo/adapter-acp`.
+
+## Usage
+
+```typescript
+import { createHarnessRuntime } from '@anureo/sdk'
+import { createAcpAdapter } from '@anureo/adapter-acp'
+
+const runtime = createHarnessRuntime(createAcpAdapter({
+  command: 'my-acp-agent',        // spawn over stdio; or use connect() below
+  args: ['--stdio'],
+  cwd: '/workspace',
+}))
+
+// Remote or custom transports inject an official v1 message stream:
+// createAcpAdapter({ connect: () => openMyStream() })
+```
+
+## How capabilities are mapped
+
+ACP's core protocol covers sessions, turns, messages, and permission requests. AHP-only features are opt-in through an extension object in the agent's `initialize` response (`_meta.ahp`, version 1):
+
+- **Optional methods** — `fork`, `revert`, `steer`, `history`, `goalSet`, `goalClear`, `compact`, `review`, each declaring its private `_…` method name, plus fork boundaries and revert scopes where applicable
+- **Client requests** — `userInput` (`_ahp/user_input`) and `dynamicTool` (`_ahp/dynamic_tool`) interactions
+- **Features** — nested subagent events and custom instructions
+
+Agents that do not advertise the extension still work: the adapter publishes only the standard ACP baseline (interrupt, approval interactions, text/image/file input). fs and terminal capabilities are announced **only** when the host injects the corresponding ports — connecting an adapter never grants filesystem or terminal permission by itself.
+
+Session snapshots loaded via ACP `session/load` have no turn boundaries; they are handed to the host through `onLoadSnapshot` instead of being replayed as realtime events.
+
+## Options
+
+| Option | Purpose |
+|---|---|
+| `command`, `args`, `cwd`, `env` | Spawn the agent binary and speak nd-JSON over stdio |
+| `connect` | Provide an official `acp.Stream` factory for remote transports or deterministic wire tests |
+| `fs` (`AcpFileSystemPort`) | Host-implemented read/write text-file callbacks |
+| `terminal` (`AcpTerminalPort`) | Host-implemented terminal lifecycle callbacks |
+| `requestTimeoutMs`, `maxFrameBytes` | Bound each request and every line (default 8 MiB; oversized frames fail with `BACKPRESSURE_EXCEEDED`) |
+| `onLoadSnapshot` | Receive `session/load` snapshot updates separately from the realtime event stream |
+
+ACP JSON-RPC error codes map to typed SDK errors (`-32601` → `CAPABILITY_UNSUPPORTED`, `-32602` → `INVALID_PARAMS`, `-32000` → `AUTH_REQUIRED`, `-32002` → `RESOURCE_NOT_FOUND`); a dropped connection surfaces as `ACP_CONNECTION_CLOSED` with `outcomeUnknown`, never as a silent success. Stderr from the agent is drained and discarded — raw provider output and credentials are not retained in diagnostics.
+
+## Development
+
+```sh
+cd packages/acp
+bun run typecheck
+bun test tests
+```
+
+The conformance tests spawn a scripted ACP agent (implementing the standard wire protocol) as a real child process over stdio; `bun run verify:pack` at the workspace root repeats the full text, approval-rejection, and interrupt flows against clean npm installs.
+
+## Documentation
+
+- [Architecture](../../docs/architecture.md) — adapters' role in the SDK (currently in Chinese)
+- [AHP v1 protocol](../../spec/ahp-v1.md)

package/dist/file-changes.d.ts

@@ -0,0 +1,3 @@
+import type { FileChange } from '@anureo/protocol';
+/** Only ACP's typed diff blocks are source material. Text output is execution output. */
+export declare function acpFileChanges(content: unknown): FileChange[];

package/dist/index.d.ts

@@ -0,0 +1,98 @@
+import * as acp from '@agentclientprotocol/sdk';
+import { type HarnessAdapter, type BackendSession, type SessionEventSink, type SessionMethod } from '@anureo/sdk';
+import { type Capabilities, type SessionBinding, type SessionOpenParams, type SessionState, type InitializeParams, type InitializeResult, type AhpRequestMap, type AhpResultMap, type JsonObject } from '@anureo/protocol';
+export interface AcpFileSystemPort {
+    readTextFile?: (params: acp.ReadTextFileRequest) => Promise<acp.ReadTextFileResponse>;
+    writeTextFile?: (params: acp.WriteTextFileRequest) => Promise<acp.WriteTextFileResponse | void>;
+}
+export interface AcpTerminalPort {
+    createTerminal(params: acp.CreateTerminalRequest): Promise<acp.CreateTerminalResponse>;
+    terminalOutput(params: acp.TerminalOutputRequest): Promise<acp.TerminalOutputResponse>;
+    releaseTerminal(params: acp.ReleaseTerminalRequest): Promise<acp.ReleaseTerminalResponse | void>;
+    waitForTerminalExit(params: acp.WaitForTerminalExitRequest): Promise<acp.WaitForTerminalExitResponse>;
+    killTerminal(params: acp.KillTerminalRequest): Promise<acp.KillTerminalResponse | void>;
+}
+export interface AcpAdapterOptions {
+    command?: string;
+    args?: readonly string[];
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    fs?: AcpFileSystemPort;
+    terminal?: AcpTerminalPort;
+    /** Inject an official v1 message stream for remote transports or deterministic wire tests. */
+    connect?: () => Promise<{
+        stream: acp.Stream;
+        dispose(): Promise<void>;
+    }>;
+    requestTimeoutMs?: number;
+    maxFrameBytes?: number;
+    /** session/load snapshots have no turn boundaries; expose them separately from AHP realtime events. */
+    onLoadSnapshot?: (binding: SessionBinding, updates: readonly JsonObject[]) => void;
+}
+type ExtensionKey = 'fork' | 'revert' | 'steer' | 'history' | 'goalSet' | 'goalClear' | 'compact' | 'review';
+interface Extensions {
+    methods: Partial<Record<ExtensionKey, string>>;
+    fork: Array<'before' | 'through'>;
+    revert: Array<'conversation' | 'files' | 'both'>;
+    subagents: boolean;
+    instructions: boolean;
+    userInput: boolean;
+    dynamicTool: boolean;
+}
+export declare class AcpAdapter implements HarnessAdapter {
+    readonly options: AcpAdapterOptions;
+    private connection;
+    private channel;
+    private info;
+    readonly sessions: Map<string, AcpBackendSession>;
+    private nativeSessions;
+    private opening;
+    private openTail;
+    private readonly deliveries;
+    private closing;
+    extension: Extensions;
+    capabilities: Capabilities;
+    constructor(options: AcpAdapterOptions);
+    get nativeCapabilities(): acp.AgentCapabilities;
+    get agent(): acp.ClientContext;
+    private backend;
+    private interaction;
+    initialize(params: InitializeParams): Promise<InitializeResult>;
+    private runtime;
+    call<M extends acp.AgentRequestMethod>(method: M, params: acp.AgentRequestParamsByMethod[M]): Promise<acp.AgentRequestResponsesByMethod[M]>;
+    call(method: string, params: unknown): Promise<unknown>;
+    private extensionInteraction;
+    openSession(params: SessionOpenParams, sink: SessionEventSink): Promise<BackendSession>;
+    dispose(): Promise<void>;
+}
+export declare class AcpBackendSession implements BackendSession {
+    readonly adapter: AcpAdapter;
+    private readonly params;
+    readonly sink: SessionEventSink;
+    nativeId: string;
+    activeTurn: string | undefined;
+    hydrating: boolean;
+    readonly loadedSnapshot: JsonObject[];
+    readonly terminals: Set<string>;
+    readonly capabilities: Capabilities;
+    private config;
+    private configKeys;
+    private configurationData;
+    private capabilityRevision;
+    private sessionTitle?;
+    private closed;
+    private readonly mapper;
+    private snapshotBytes;
+    constructor(adapter: AcpAdapter, params: SessionOpenParams, sink: SessionEventSink);
+    get binding(): SessionBinding;
+    state(): SessionState;
+    configure(data: Record<string, unknown>): void;
+    update(data: Record<string, unknown>): Promise<void>;
+    requireTerminal(id: string): void;
+    setConfiguration(patch: JsonObject): Promise<SessionState>;
+    private extension;
+    execute<M extends SessionMethod>(method: M, params: AhpRequestMap[M]): Promise<AhpResultMap[M]>;
+    dispose(): Promise<void>;
+}
+export declare function createAcpAdapter(options: AcpAdapterOptions): AcpAdapter;
+export {};

package/dist/index.js

@@ -0,0 +1,852 @@
+// packages/acp/src/file-changes.ts
+function acpFileChanges(content) {
+  if (!Array.isArray(content))
+    return [];
+  return content.flatMap((value) => {
+    if (!value || typeof value !== "object")
+      return [];
+    const part = value;
+    if (part.type !== "diff" || typeof part.path !== "string" || !(part.oldText === undefined || part.oldText === null || typeof part.oldText === "string") || typeof part.newText !== "string")
+      return [];
+    const oldText = part.oldText ?? null;
+    return [{ path: part.path, operation: oldText === null ? "add" : "modify", materials: [{ format: "text", scope: "file", oldText, newText: part.newText }], completeness: "complete" }];
+  });
+}
+
+// packages/acp/src/index.ts
+import * as acp from "@agentclientprotocol/sdk";
+import {
+  spawnHarnessProcess,
+  HarnessSdkError as HarnessSdkError2,
+  waitForRequest
+} from "@anureo/sdk";
+import {
+  negotiateVersion,
+  assertResult,
+  assertDefinition
+} from "@anureo/protocol";
+
+// packages/acp/src/mapping.ts
+import { publicValue } from "@anureo/protocol";
+import { HarnessSdkError } from "@anureo/sdk";
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function safe(value) {
+  return publicValue(JSON.parse(JSON.stringify(value ?? null)));
+}
+function text(value) {
+  if (typeof value === "string")
+    return value;
+  if (Array.isArray(value))
+    return value.map(text).join(`
+`);
+  const object = record(value);
+  if (object.type === "text" && typeof object.text === "string")
+    return object.text;
+  if (object.type === "content")
+    return text(object.content);
+  if (object.type === "diff")
+    return `${typeof object.oldText === "string" ? object.oldText : ""}
+${typeof object.newText === "string" ? object.newText : ""}`;
+  if (object.type === "resource")
+    return text(object.resource);
+  return "";
+}
+function input(blocks) {
+  return blocks.map((block) => {
+    if (block.type === "text")
+      return { type: "text", text: block.text };
+    if (block.type === "file")
+      return { type: "resource_link", uri: block.uri, name: block.name ?? block.uri, ...block.mimeType ? { mimeType: block.mimeType } : {} };
+    if (!block.data || !block.mimeType)
+      throw new HarnessSdkError("INVALID_PARAMS", "ACP images require inline data and mimeType");
+    return { type: "image", data: block.data, mimeType: block.mimeType, ...block.url ? { uri: block.url } : {} };
+  });
+}
+function mcp(servers = []) {
+  return servers.map((server) => server.type === "http" ? { type: "http", name: server.name, url: server.url, headers: Object.entries(server.headers ?? {}).map(([name, value]) => ({ name, value })) } : { name: server.name, command: server.command, args: server.args ?? [], env: Object.entries(server.env ?? {}).map(([name, value]) => ({ name, value })) });
+}
+function selectValues(value) {
+  return Array.isArray(value) ? value.flatMap((entry) => {
+    const option = record(entry);
+    return typeof option.value === "string" ? [option.value] : selectValues(option.options);
+  }) : [];
+}
+function configuration(data) {
+  const options = [], values = {}, keys = new Map;
+  for (const item of Array.isArray(data.configOptions) ? data.configOptions : []) {
+    const option = record(item);
+    if (typeof option.id !== "string")
+      continue;
+    const id = option.id;
+    const current = option.currentValue;
+    if (option.type !== "boolean" && option.type !== "select")
+      continue;
+    const schema = option.type === "boolean" ? { type: "boolean" } : { type: "string", enum: selectValues(option.options) };
+    const descriptor = { id, title: typeof option.name === "string" ? option.name : id, scope: "session", schema, ...typeof current === "string" || typeof current === "boolean" ? { value: current } : {} };
+    options.push(descriptor);
+    keys.set(id, option);
+    if (descriptor.value !== undefined)
+      values[id] = descriptor.value;
+    if (option.category === "model" && id !== "model") {
+      options.push({ ...descriptor, id: "model" });
+      keys.set("model", option);
+      if (descriptor.value !== undefined)
+        values.model = descriptor.value;
+    }
+  }
+  const modes = record(data.modes);
+  if (Array.isArray(modes.availableModes)) {
+    const modeIds = modes.availableModes.map((mode) => record(mode).id).filter((id) => typeof id === "string");
+    options.push({ id: "mode", title: "ACP mode", scope: "session", schema: { type: "string", enum: modeIds } });
+    keys.set("mode", { id: "mode", type: "mode", options: modeIds });
+    if (typeof modes.currentModeId === "string")
+      values.mode = modes.currentModeId;
+  }
+  return { options, values, keys };
+}
+
+class AcpUpdateMapper {
+  sink;
+  getTurn;
+  state;
+  setState;
+  subagents;
+  items = new Map;
+  ended = new Set;
+  serial = 0;
+  compaction = new Map;
+  constructor(sink, getTurn, state, setState, subagents) {
+    this.sink = sink;
+    this.getTurn = getTurn;
+    this.state = state;
+    this.setState = setState;
+    this.subagents = subagents;
+  }
+  reset() {
+    this.items.clear();
+    this.ended.clear();
+    this.compaction.clear();
+    this.serial = 0;
+  }
+  async upsert(item, terminal = false) {
+    const turnId = this.getTurn();
+    if (!turnId)
+      return;
+    const old = this.items.get(item.id);
+    this.items.set(item.id, item);
+    if (this.ended.has(item.id))
+      return;
+    if (!old)
+      await this.sink.emit({ type: "item/started", payload: { item } }, { turnId });
+    else if (!terminal)
+      await this.sink.emit({ type: "item/delta", payload: { itemId: item.id, kind: "patch", value: safe(item) } }, { turnId });
+    if (terminal) {
+      this.ended.add(item.id);
+      await this.sink.emit({ type: "item/completed", payload: { item } }, { turnId });
+    }
+  }
+  async complete() {
+    for (const item of this.items.values())
+      if (!this.ended.has(item.id))
+        await this.upsert({ ...item, status: item.status === "running" ? "completed" : item.status }, true);
+  }
+  async update(update) {
+    const kind = update.sessionUpdate;
+    const turnId = this.getTurn();
+    if (kind === "config_option_update" || kind === "current_mode_update") {
+      this.setState(update);
+      await this.sink.emit({ type: "session/state", payload: this.state() });
+      return;
+    }
+    if (kind === "usage_update") {
+      await this.sink.emit({ type: "usage/updated", payload: { provider: "acp", scope: "session", source: "native", ...typeof update.used === "number" ? { contextUsed: update.used } : {}, ...typeof update.size === "number" ? { contextWindow: update.size } : {} } }, { ...turnId ? { turnId } : {} });
+      return;
+    }
+    if (kind === "session_info_update") {
+      if (Object.hasOwn(update, "title") && (typeof update.title === "string" || update.title === null)) {
+        const title = update.title;
+        if (this.state().metadata?.title !== title) {
+          this.setState({ sessionTitle: title });
+          await this.sink.emit({ type: "session/metadata", payload: { title } });
+        }
+      }
+      return;
+    }
+    if (!turnId || kind === "available_commands_update") {
+      await this.sink.emit({ type: "notice", payload: { severity: "info", code: `ACP_${String(kind ?? "UPDATE").toUpperCase()}`, message: "ACP session metadata update", raw: safe(update) } });
+      return;
+    }
+    if (["agent_message_chunk", "agent_thought_chunk", "user_message_chunk"].includes(String(kind))) {
+      const nativeId = typeof update.messageId === "string" ? update.messageId : String(kind);
+      const id = `${String(kind)}:${nativeId}`;
+      const chunk = text(update.content);
+      if (!chunk && record(update.content).type !== "text")
+        await this.sink.emit({ type: "notice", payload: { severity: "info", code: "ACP_NON_TEXT_CONTENT", message: "ACP non-text content retained", raw: safe(update.content) } }, { turnId });
+      let item = this.items.get(id);
+      if (!item) {
+        item = kind === "agent_thought_chunk" ? { id, type: "reasoning", text: "" } : kind === "user_message_chunk" ? { id, type: "userMessage", content: [] } : { id, type: "agentMessage", text: "", phase: "final" };
+        this.items.set(id, item);
+        await this.sink.emit({ type: "item/started", payload: { item } }, { turnId });
+      }
+      if (item.type === "userMessage") {
+        const content = record(update.content);
+        if (content.type === "text")
+          item.content.push({ type: "text", text: chunk });
+        else if (content.type === "image" && typeof content.data === "string")
+          item.content.push({ type: "image", data: content.data, mimeType: typeof content.mimeType === "string" ? content.mimeType : undefined });
+        else if (content.type === "resource_link" && typeof content.uri === "string")
+          item.content.push({ type: "file", uri: content.uri });
+        else
+          await this.sink.emit({ type: "notice", payload: { severity: "info", code: "ACP_UNKNOWN_CONTENT", message: "ACP user content", raw: safe(update.content) } }, { turnId });
+        await this.sink.emit({ type: "item/delta", payload: { itemId: id, kind: "patch", value: safe(item) } }, { turnId });
+      } else if (item.type === "agentMessage" || item.type === "reasoning") {
+        item.text = (item.text ?? "") + chunk;
+        await this.sink.emit({ type: "item/delta", payload: { itemId: id, kind: "text", text: chunk } }, { turnId });
+      }
+      return;
+    }
+    if (kind === "tool_call" || kind === "tool_call_update") {
+      const id = String(update.toolCallId);
+      const old = this.items.get(id);
+      const kindMap = { execute: "command", edit: "fileChange", delete: "fileChange", move: "fileChange", fetch: "web" };
+      const status = update.status === "failed" ? "failed" : update.status === "completed" ? "completed" : update.status === undefined && old?.type === "toolCall" ? old.status ?? "running" : "running";
+      const item = {
+        ...old?.type === "toolCall" ? old : { id, type: "toolCall", kind: "other", title: "ACP tool" },
+        ...typeof update.title === "string" ? { title: update.title } : {},
+        ...typeof update.kind === "string" ? { kind: kindMap[update.kind] ?? "other", nativeType: update.kind } : {},
+        status,
+        ...update.content !== undefined ? { fileChanges: acpFileChanges(update.content) } : {},
+        ...update.rawInput !== undefined ? { input: safe(update.rawInput) } : {},
+        ...update.rawOutput !== undefined ? { output: safe(update.rawOutput) } : update.content !== undefined ? { output: safe(update.content) } : {},
+        ...Array.isArray(update.locations) ? { locations: update.locations.flatMap((location) => {
+          const value = record(location);
+          return typeof value.path === "string" ? [{ path: value.path, ...typeof value.line === "number" ? { line: value.line } : {} }] : [];
+        }) } : {}
+      };
+      await this.upsert(item, status !== "running");
+      return;
+    }
+    if (kind === "plan") {
+      const entries = Array.isArray(update.entries) ? update.entries : [];
+      await this.upsert({ id: "acp-plan", type: "plan", steps: entries.map((entry, index) => {
+        const value = record(entry);
+        return { id: String(index), text: String(value.content ?? ""), status: value.status === "completed" ? "completed" : value.status === "in_progress" ? "inProgress" : "pending" };
+      }) });
+      return;
+    }
+    if (kind === "plan_update" || kind === "plan_removed") {
+      const plan = record(update.plan);
+      const id = `plan:${String(update.planId ?? plan.planId ?? ++this.serial)}`;
+      await this.upsert({ id, type: "plan", steps: kind === "plan_removed" ? [] : [{ id: "content", text: text(plan.content ?? record(plan).markdown ?? plan), status: "pending" }], extensions: { "x-acp/native-plan": safe(update) } }, kind === "plan_removed");
+      return;
+    }
+    if (kind === "compaction_update" || kind === "compaction_summary_chunk") {
+      const id = `compaction:${String(update.compactionId)}`;
+      let summary = this.compaction.get(id) ?? "";
+      if (kind === "compaction_summary_chunk")
+        summary += text(update.content);
+      else if ("summary" in update)
+        summary = text(update.summary);
+      this.compaction.set(id, summary);
+      const terminal = update.status === "completed" || update.status === "failed" || update.status === "cancelled";
+      await this.upsert({ id, type: "compaction", summary, status: update.status === "failed" ? "failed" : update.status === "cancelled" ? "interrupted" : terminal ? "completed" : "running" }, terminal);
+      return;
+    }
+    if ((kind === "subagent_spawned" || kind === "subagent_state_update") && this.subagents) {
+      const id = `subagent:${String(update.subagentSessionId)}`;
+      const old = this.items.get(id);
+      const state = update.state === "completed" ? "completed" : ["cancelled", "disconnected"].includes(String(update.state)) ? "interrupted" : update.state === "failed" ? "failed" : "running";
+      await this.upsert({ ...old?.type === "subagent" ? old : { id, type: "subagent", subagentId: String(update.subagentSessionId) }, state, ...typeof update.name === "string" ? { name: update.name } : {}, ...typeof update.task === "string" ? { task: update.task } : {} }, state !== "running");
+      return;
+    }
+    await this.sink.emit({ type: "notice", payload: { severity: "info", code: "ACP_UNKNOWN_UPDATE", message: "Unmapped ACP update retained", raw: safe(update) } }, { turnId });
+  }
+}
+
+// packages/acp/src/index.ts
+function deferred() {
+  let resolve, reject;
+  const promise = new Promise((yes, no) => {
+    resolve = yes;
+    reject = no;
+  });
+  promise.catch(() => {});
+  return { promise, resolve, reject };
+}
+function errorFromNative(error, fallback = "ACP_REQUEST_FAILED") {
+  if (error instanceof HarnessSdkError2)
+    return error;
+  if (error instanceof acp.RequestError) {
+    const code = error.code === -32601 ? "CAPABILITY_UNSUPPORTED" : error.code === -32602 ? "INVALID_PARAMS" : error.code === -32000 ? "AUTH_REQUIRED" : error.code === -32002 ? "RESOURCE_NOT_FOUND" : fallback;
+    return new HarnessSdkError2(code, code, false, false, { nativeCode: error.code });
+  }
+  return new HarnessSdkError2("ACP_CONNECTION_CLOSED", "ACP connection closed", false, true);
+}
+function extensions(response) {
+  const extension = record(record(record(response)._meta).ahp);
+  const methods = {};
+  const result = { methods, fork: [], revert: [], subagents: false, instructions: false, userInput: false, dynamicTool: false };
+  if (extension.version !== 1)
+    return result;
+  const names = record(extension.methods);
+  for (const key of ["fork", "revert", "steer", "history", "goalSet", "goalClear", "compact", "review"]) {
+    const name = names[key];
+    if (typeof name === "string" && /^_[a-zA-Z0-9/_.-]+$/.test(name))
+      methods[key] = name;
+  }
+  if (methods.fork && Array.isArray(extension.fork))
+    result.fork = extension.fork.filter((value) => value === "before" || value === "through");
+  if (methods.revert && Array.isArray(extension.revert))
+    result.revert = extension.revert.filter((value) => ["conversation", "files", "both"].includes(String(value)));
+  result.subagents = extension.subagents === true;
+  result.instructions = extension.instructions === true;
+  const requests = record(extension.clientRequests);
+  result.userInput = requests.userInput === "_ahp/user_input";
+  result.dynamicTool = requests.dynamicTool === "_ahp/dynamic_tool";
+  return result;
+}
+async function processStream(options) {
+  if (!options.command)
+    throw new HarnessSdkError2("HARNESS_UNAVAILABLE", "An ACP executable or stream factory is required");
+  const child = await spawnHarnessProcess({ command: options.command, args: options.args, cwd: options.cwd, env: options.env });
+  const iterator = child.stdout[Symbol.asyncIterator]();
+  let lineBytes = 0;
+  const incoming = new ReadableStream({
+    async pull(controller) {
+      try {
+        const value = await iterator.next();
+        if (value.done) {
+          controller.close();
+          return;
+        }
+        for (const byte of value.value) {
+          if (byte === 10)
+            lineBytes = 0;
+          else if (++lineBytes > (options.maxFrameBytes ?? 8 * 1024 * 1024))
+            throw new HarnessSdkError2("BACKPRESSURE_EXCEEDED", "ACP frame exceeds its limit");
+        }
+        controller.enqueue(value.value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    async cancel() {
+      await iterator.return?.();
+    }
+  });
+  let outgoingLineBytes = 0;
+  const outgoing = new WritableStream({ write: (chunk) => {
+    for (const byte of chunk) {
+      if (byte === 10)
+        outgoingLineBytes = 0;
+      else if (++outgoingLineBytes > (options.maxFrameBytes ?? 8 * 1024 * 1024))
+        throw new HarnessSdkError2("BACKPRESSURE_EXCEEDED", "ACP outgoing frame exceeds its limit");
+    }
+    return child.write(chunk);
+  }, close: () => child.closeInput() });
+  (async () => {
+    try {
+      for await (const _chunk of child.stderr) {}
+    } catch {}
+  })();
+  return { stream: acp.ndJsonStream(outgoing, incoming), dispose: () => child.dispose() };
+}
+
+class AcpAdapter {
+  options;
+  connection;
+  channel;
+  info;
+  sessions = new Map;
+  nativeSessions = new Map;
+  opening;
+  openTail = Promise.resolve();
+  deliveries = new Map;
+  closing = false;
+  extension = { methods: {}, fork: [], revert: [], subagents: false, instructions: false, userInput: false, dynamicTool: false };
+  capabilities = {};
+  constructor(options) {
+    this.options = options;
+  }
+  get nativeCapabilities() {
+    return this.info?.agentCapabilities ?? {};
+  }
+  get agent() {
+    if (!this.connection)
+      throw new HarnessSdkError2("ACP_CONNECTION_CLOSED");
+    return this.connection.agent;
+  }
+  backend(nativeId, allowOpening = false) {
+    const existing = this.nativeSessions.get(nativeId);
+    if (existing)
+      return existing;
+    if (allowOpening && this.opening && (!this.opening.nativeId || this.opening.nativeId === nativeId)) {
+      this.opening.nativeId = nativeId;
+      this.nativeSessions.set(nativeId, this.opening);
+      return this.opening;
+    }
+    throw new acp.RequestError(-32602, "Unknown ACP session");
+  }
+  async interaction(session, requestId, request, transform) {
+    const delivery = deferred();
+    this.deliveries.set(requestId, delivery);
+    return new Promise((resolve, reject) => {
+      let answered = false;
+      session.sink.requestInteraction(request, async (response) => {
+        answered = true;
+        resolve(transform(response));
+        await delivery.promise;
+      }).catch(() => {
+        if (!answered)
+          reject(new acp.RequestError(-32603, "Interaction could not be completed"));
+      });
+    });
+  }
+  async initialize(params) {
+    negotiateVersion(params.protocolVersions);
+    if (this.info)
+      return { protocolVersion: 1, runtime: this.runtime(), capabilities: structuredClone(this.capabilities) };
+    this.channel = this.options.connect ? await this.options.connect() : await processStream(this.options);
+    const rawReader = this.channel.stream.readable.getReader();
+    const rawWriter = this.channel.stream.writable.getWriter();
+    const wrapped = {
+      writable: new WritableStream({ write: async (frame) => {
+        try {
+          await rawWriter.write(frame);
+          if ("id" in frame && !("method" in frame)) {
+            this.deliveries.get(frame.id)?.resolve();
+            this.deliveries.delete(frame.id);
+          }
+        } catch (error) {
+          for (const delivery of this.deliveries.values())
+            delivery.reject(error);
+          throw error;
+        }
+      }, close: () => rawWriter.close(), abort: (reason) => rawWriter.abort(reason) }),
+      readable: new ReadableStream({ pull: async (controller) => {
+        try {
+          for (;; ) {
+            const next = await rawReader.read();
+            if (next.done) {
+              controller.close();
+              return;
+            }
+            const frame = next.value;
+            if ("method" in frame && !("id" in frame) && frame.method === "session/update") {
+              const value = record(frame.params);
+              const session = this.backend(String(value.sessionId), true);
+              await session.update(record(value.update));
+              continue;
+            }
+            if ("method" in frame && !("id" in frame) && frame.method === "_ahp/event" && Object.keys(this.extension.methods).length) {
+              const value = record(frame.params);
+              const session = this.backend(String(value.sessionId));
+              const event = value.event;
+              assertDefinition("AhpEventPayload", event);
+              if (event.type === "turn/started")
+                session.activeTurn = event.payload.turnId;
+              await session.sink.emit(event, { ...typeof value.turnId === "string" ? { turnId: value.turnId } : {} });
+              if (event.type === "turn/completed" && session.activeTurn === event.payload.turnId)
+                session.activeTurn = undefined;
+              continue;
+            }
+            if ("method" in frame && !("id" in frame) && frame.method !== "elicitation/complete") {
+              const scope = record(frame.params).sessionId;
+              const recipients = typeof scope === "string" ? [this.backend(scope)] : [...this.sessions.values()];
+              for (const session of recipients)
+                await session.sink.emit({ type: "notice", payload: { severity: "info", code: "ACP_UNKNOWN_NOTIFICATION", message: "Unknown ACP notification retained", raw: safe({ method: frame.method, params: frame.params }) } });
+              continue;
+            }
+            controller.enqueue(frame);
+            return;
+          }
+        } catch (error) {
+          controller.error(error);
+        }
+      }, cancel: (reason) => rawReader.cancel(reason) })
+    };
+    const app = acp.client({ name: "anureo-harness-sdk-acp" }).onRequest("session/request_permission", (context) => {
+      const session = this.backend(context.params.sessionId);
+      return this.interaction(session, context.requestId, {
+        kind: "approval",
+        interactionId: `acp-permission:${String(context.requestId)}`,
+        turnId: session.activeTurn,
+        itemId: context.params.toolCall.toolCallId,
+        options: context.params.options.map((option) => ({ id: option.optionId, label: option.name, semantic: option.kind === "allow_once" ? "allowOnce" : option.kind === "allow_always" ? "allowSession" : "deny" })),
+        ...context.params.toolCall.rawInput !== undefined ? { input: safe(context.params.toolCall.rawInput) } : {}
+      }, (response) => response?.kind === "approval" ? { outcome: { outcome: "selected", optionId: response.optionId } } : { outcome: { outcome: "cancelled" } });
+    }).onRequest("elicitation/create", (context) => {
+      const native = record(context.params);
+      if (typeof native.sessionId !== "string" || !["form", "url"].includes(String(native.mode)))
+        return { action: "cancel" };
+      const session = this.backend(native.sessionId);
+      const request = { kind: "elicitation", interactionId: `acp-elicitation:${String(context.requestId)}`, turnId: session.activeTurn, mode: native.mode, message: String(native.message ?? ""), ...native.mode === "form" ? { schema: safe(native.requestedSchema) } : { privatePayload: { url: String(native.url ?? ""), elicitationId: String(native.elicitationId ?? "") } } };
+      return this.interaction(session, context.requestId, request, (response) => response?.kind === "elicitation" ? { action: response.action, ...response.content ? { content: response.content } : {} } : { action: "cancel" });
+    }).onNotification("elicitation/complete", async (context) => {
+      for (const session of this.sessions.values())
+        await session.sink.emit({ type: "notice", payload: { severity: "info", code: "ACP_ELICITATION_COMPLETE", message: "External authorization completed", raw: safe(context.params) } });
+    }).onRequest("_ahp/user_input", (value) => record(value), (context) => this.extensionInteraction("userInput", context.requestId, context.params)).onRequest("_ahp/dynamic_tool", (value) => record(value), (context) => this.extensionInteraction("dynamicTool", context.requestId, context.params));
+    if (this.options.fs?.readTextFile)
+      app.onRequest("fs/read_text_file", (ctx) => {
+        this.backend(ctx.params.sessionId);
+        return this.options.fs.readTextFile(ctx.params);
+      });
+    if (this.options.fs?.writeTextFile)
+      app.onRequest("fs/write_text_file", (ctx) => {
+        this.backend(ctx.params.sessionId);
+        return this.options.fs.writeTextFile(ctx.params);
+      });
+    const terminal = this.options.terminal;
+    if (terminal) {
+      app.onRequest("terminal/create", async (ctx) => {
+        const session = this.backend(ctx.params.sessionId);
+        const result = await terminal.createTerminal(ctx.params);
+        session.terminals.add(result.terminalId);
+        return result;
+      });
+      app.onRequest("terminal/output", (ctx) => {
+        this.backend(ctx.params.sessionId).requireTerminal(ctx.params.terminalId);
+        return terminal.terminalOutput(ctx.params);
+      });
+      app.onRequest("terminal/wait_for_exit", (ctx) => {
+        this.backend(ctx.params.sessionId).requireTerminal(ctx.params.terminalId);
+        return terminal.waitForTerminalExit(ctx.params);
+      });
+      app.onRequest("terminal/kill", (ctx) => {
+        this.backend(ctx.params.sessionId).requireTerminal(ctx.params.terminalId);
+        return terminal.killTerminal(ctx.params);
+      });
+      app.onRequest("terminal/release", async (ctx) => {
+        const session = this.backend(ctx.params.sessionId);
+        session.requireTerminal(ctx.params.terminalId);
+        const result = await terminal.releaseTerminal(ctx.params);
+        session.terminals.delete(ctx.params.terminalId);
+        return result;
+      });
+    }
+    this.connection = app.connect(wrapped);
+    this.connection.closed.then(async () => {
+      const error = new HarnessSdkError2("ACP_CONNECTION_CLOSED", "ACP source connection closed", false, true);
+      for (const delivery of this.deliveries.values())
+        delivery.reject(error);
+      this.deliveries.clear();
+      if (!this.closing)
+        await Promise.all([...this.sessions.values()].map((session) => session.sink.fail(error).catch(() => {})));
+    });
+    this.info = await this.call("initialize", { protocolVersion: acp.PROTOCOL_VERSION, clientInfo: { name: "anureo-harness-sdk", version: "0.1.0" }, clientCapabilities: {
+      fs: { readTextFile: !!this.options.fs?.readTextFile, writeTextFile: !!this.options.fs?.writeTextFile },
+      terminal: !!terminal,
+      session: { configOptions: { boolean: {} }, compaction: {} },
+      plan: {},
+      elicitation: params.clientCapabilities?.interactions?.includes("elicitation") ? { form: {}, url: {} } : undefined,
+      _meta: { ahp: { version: 1, clientRequests: ["_ahp/user_input", "_ahp/dynamic_tool"] } }
+    } });
+    if (this.info.protocolVersion !== acp.PROTOCOL_VERSION) {
+      await this.dispose();
+      throw new HarnessSdkError2("PROTOCOL_VERSION_UNSUPPORTED");
+    }
+    this.extension = extensions(this.info);
+    const native = this.nativeCapabilities;
+    this.capabilities = {
+      session: { resume: native.loadSession === true || native.sessionCapabilities?.resume != null, fork: this.extension.fork, revert: this.extension.revert, history: !!this.extension.methods.history },
+      turn: { interrupt: true, steer: !!this.extension.methods.steer, inputModalities: ["text", ...native.promptCapabilities?.image ? ["image"] : [], ...native.promptCapabilities?.embeddedContext ? ["file"] : []] },
+      interactions: ["approval", "elicitation", ...this.extension.userInput ? ["userInput"] : [], ...this.extension.dynamicTool ? ["dynamicTool"] : []],
+      goal: { actions: [...this.extension.methods.goalSet ? ["set"] : [], ...this.extension.methods.goalClear ? ["clear"] : []] },
+      compact: !!this.extension.methods.compact,
+      review: !!this.extension.methods.review,
+      subagents: { events: this.extension.subagents ? "nested" : "none" },
+      mcp: { stdio: true, http: native.mcpCapabilities?.http === true, elicitation: ["form", "url"] },
+      config: { options: [] },
+      extensions: Object.keys(this.extension.methods).length || this.extension.subagents || this.extension.userInput || this.extension.dynamicTool ? [{ name: "x-acp/ahp", version: "1" }] : []
+    };
+    return { protocolVersion: 1, runtime: this.runtime(), capabilities: structuredClone(this.capabilities) };
+  }
+  runtime() {
+    return { name: this.info?.agentInfo?.name ?? "acp", version: this.info?.agentInfo?.version ?? "unknown", adapter: "acp/0.1.0" };
+  }
+  async call(method, params) {
+    try {
+      return await waitForRequest(() => this.agent.request(method, params), {}, this.options.requestTimeoutMs ?? 30000);
+    } catch (error) {
+      throw errorFromNative(error);
+    }
+  }
+  async extensionInteraction(kind, id, params) {
+    if (!this.extension[kind])
+      throw new acp.RequestError(-32601, "Extension was not negotiated");
+    const session = this.backend(String(params.sessionId));
+    const request = { ...record(params.request), kind, interactionId: `acp-${kind}:${String(id)}`, turnId: session.activeTurn };
+    assertDefinition("InteractionRequested", request);
+    return this.interaction(session, id, request, (response) => response ?? { cancelled: true });
+  }
+  async openSession(params, sink) {
+    const old = this.openTail;
+    let release;
+    this.openTail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await old;
+    const session = new AcpBackendSession(this, params, sink);
+    this.opening = session;
+    try {
+      if (params.instructions && !this.extension.instructions)
+        throw new HarnessSdkError2("CAPABILITY_UNSUPPORTED", "ACP peer did not negotiate instructions");
+      const common = { cwd: params.cwd, mcpServers: mcp(params.mcpServers), ...params.instructions ? { _meta: { ahp: { version: 1, instructions: params.instructions } } } : {} };
+      let response;
+      if (params.mode === "new")
+        response = record(await this.call("session/new", common));
+      else if (params.mode === "resume") {
+        if (!params.binding.nativeRef || params.binding.nativeRef.provider !== "acp")
+          throw new HarnessSdkError2("SESSION_BINDING_MISMATCH");
+        session.nativeId = params.binding.nativeRef.value;
+        this.nativeSessions.set(session.nativeId, session);
+        session.hydrating = true;
+        response = record(await this.call(this.nativeCapabilities.sessionCapabilities?.resume != null ? "session/resume" : "session/load", { ...common, sessionId: session.nativeId }));
+      } else {
+        const nativeRef = params.fork?.nativeRef ?? this.sessions.get(params.fork.sourceSessionId)?.binding.nativeRef;
+        if (!nativeRef || !this.extension.methods.fork)
+          throw new HarnessSdkError2("CAPABILITY_UNSUPPORTED");
+        response = record(await this.call(this.extension.methods.fork, { ...common, sessionId: nativeRef.value, boundary: params.fork.boundary }));
+      }
+      if (typeof response.sessionId === "string") {
+        if (session.nativeId && response.sessionId !== session.nativeId)
+          throw new HarnessSdkError2("ACP_PROTOCOL_ERROR", "ACP session identity changed while opening");
+        session.nativeId = response.sessionId;
+      }
+      if (!session.nativeId)
+        throw new HarnessSdkError2("ACP_PROTOCOL_ERROR", "ACP session response lacked an identity");
+      this.nativeSessions.set(session.nativeId, session);
+      this.sessions.set(params.binding.sessionId, session);
+      session.configure(response);
+      session.hydrating = false;
+      if (session.loadedSnapshot.length)
+        this.options.onLoadSnapshot?.(session.binding, session.loadedSnapshot);
+      const patch = { ...params.config, ...params.model ? { model: params.model } : {}, ...params.permissionMode ? { permissionMode: params.permissionMode } : {} };
+      if (Object.keys(patch).length)
+        await session.setConfiguration(patch);
+      if (session.state().metadata)
+        await sink.emit({ type: "session/metadata", payload: session.state().metadata });
+      return session;
+    } catch (error) {
+      for (const [id, value] of this.nativeSessions)
+        if (value === session)
+          this.nativeSessions.delete(id);
+      this.sessions.delete(params.binding.sessionId);
+      throw error;
+    } finally {
+      this.opening = undefined;
+      release();
+    }
+  }
+  async dispose() {
+    if (this.closing)
+      return;
+    this.closing = true;
+    for (const session of this.sessions.values())
+      await session.dispose().catch(() => {});
+    this.connection?.close();
+    await this.channel?.dispose();
+    this.sessions.clear();
+    this.nativeSessions.clear();
+  }
+}
+
+class AcpBackendSession {
+  adapter;
+  params;
+  sink;
+  nativeId = "";
+  activeTurn;
+  hydrating = false;
+  loadedSnapshot = [];
+  terminals = new Set;
+  capabilities;
+  config = {};
+  configKeys = new Map;
+  configurationData = {};
+  capabilityRevision = 1;
+  sessionTitle;
+  closed = false;
+  mapper;
+  snapshotBytes = 0;
+  constructor(adapter, params, sink) {
+    this.adapter = adapter;
+    this.params = params;
+    this.sink = sink;
+    this.capabilities = structuredClone(adapter.capabilities);
+    this.mapper = new AcpUpdateMapper(sink, () => this.activeTurn, () => this.state(), (data) => this.configure(data), adapter.extension.subagents);
+  }
+  get binding() {
+    return { ...this.params.binding, nativeRef: { provider: "acp", value: this.nativeId } };
+  }
+  state() {
+    return { ...this.sessionTitle !== undefined ? { metadata: { title: this.sessionTitle } } : {}, binding: this.binding, config: this.config, capabilities: this.capabilities, capabilityRevision: this.capabilityRevision, status: this.activeTurn ? "running" : "ready", ...this.activeTurn ? { activeTurnId: this.activeTurn } : {} };
+  }
+  configure(data) {
+    if (Object.hasOwn(data, "sessionTitle")) {
+      this.sessionTitle = data.sessionTitle;
+      return;
+    }
+    this.configurationData = { ...this.configurationData, ...data };
+    if (typeof data.currentModeId === "string")
+      this.configurationData.modes = { ...record(this.configurationData.modes), currentModeId: data.currentModeId };
+    const descriptor = configuration(this.configurationData);
+    this.configKeys = descriptor.keys;
+    this.capabilities.config = { options: descriptor.options };
+    this.config = { ...this.config, ...descriptor.values };
+    if (typeof data.currentModeId === "string")
+      this.config.mode = data.currentModeId;
+    this.capabilityRevision++;
+  }
+  async update(data) {
+    if (this.hydrating && data.sessionUpdate === "session_info_update") {
+      if (typeof data.title === "string" || data.title === null)
+        this.sessionTitle = data.title;
+      return;
+    }
+    if (this.hydrating) {
+      this.snapshotBytes += JSON.stringify(data).length * 3;
+      if (this.loadedSnapshot.length >= 2048 || this.snapshotBytes > 16 * 1024 * 1024)
+        throw new HarnessSdkError2("BACKPRESSURE_EXCEEDED", "ACP load snapshot exceeds its limit");
+      this.loadedSnapshot.push(safe(data));
+      return;
+    }
+    await this.mapper.update(data);
+  }
+  requireTerminal(id) {
+    if (!this.terminals.has(id))
+      throw new acp.RequestError(-32602, "Terminal does not belong to this session");
+  }
+  async setConfiguration(patch) {
+    for (const key of Object.keys(patch))
+      if (!this.configKeys.has(key))
+        throw new HarnessSdkError2("CAPABILITY_UNSUPPORTED");
+    for (const [key, value] of Object.entries(patch)) {
+      const option = this.configKeys.get(key);
+      if (option.type === "mode")
+        await this.adapter.call("session/set_mode", { sessionId: this.nativeId, modeId: String(value) });
+      else {
+        const response = await this.adapter.call("session/set_config_option", { sessionId: this.nativeId, configId: String(option.id), type: option.type === "boolean" ? "boolean" : "select", value });
+        this.configure(record(response));
+      }
+      this.config[key] = value;
+    }
+    return this.state();
+  }
+  async extension(key, method, params) {
+    const nativeMethod = this.adapter.extension.methods[key];
+    if (!nativeMethod)
+      throw new HarnessSdkError2("CAPABILITY_UNSUPPORTED");
+    try {
+      let result = await this.adapter.call(nativeMethod, { ...params, sessionId: this.nativeId });
+      if (key === "history" && result && typeof result === "object" && Array.isArray(record(result).items)) {
+        const page = record(result);
+        result = { ...page, items: page.items.map((entry) => {
+          const row = record(entry), item = record(row.item);
+          return item.type === "toolCall" && item.fileChanges === undefined && Array.isArray(item.output) ? { ...row, item: { ...item, fileChanges: acpFileChanges(item.output) } } : entry;
+        }) };
+      }
+      assertResult(method, result);
+      return result;
+    } catch (error) {
+      if (error instanceof HarnessSdkError2 && error.code === "CAPABILITY_UNSUPPORTED") {
+        delete this.adapter.extension.methods[key];
+        if (key === "steer")
+          this.capabilities.turn.steer = false;
+        if (key === "history")
+          this.capabilities.session.history = false;
+        if (key === "revert")
+          this.capabilities.session.revert = [];
+        if (key === "compact")
+          this.capabilities.compact = false;
+        if (key === "review")
+          this.capabilities.review = false;
+        if (key === "goalSet" || key === "goalClear")
+          this.capabilities.goal.actions = this.capabilities.goal.actions?.filter((action) => action !== (key === "goalSet" ? "set" : "clear"));
+        await this.sink.emit({ type: "session/state", payload: this.state() });
+      }
+      throw error;
+    }
+  }
+  async execute(method, params) {
+    let result;
+    switch (method) {
+      case "turn/start": {
+        const turn = params;
+        const prompt = input(turn.input);
+        this.activeTurn = turn.turnId;
+        this.mapper.reset();
+        await this.sink.emit({ type: "turn/started", payload: { turnId: turn.turnId } });
+        (async () => {
+          try {
+            const completed = await this.adapter.agent.request("session/prompt", { sessionId: this.nativeId, prompt, ...this.capabilities.extensions?.some((extension) => extension.name === "x-acp/ahp") ? { _meta: { ahp: { version: 1, turnId: turn.turnId } } } : {} });
+            await this.mapper.complete();
+            await this.sink.emit({ type: "turn/completed", payload: { turnId: turn.turnId, status: completed.stopReason === "cancelled" ? "interrupted" : "completed" } });
+          } catch (error) {
+            const failure = errorFromNative(error, "ACP_TURN_FAILED");
+            if (failure.outcomeUnknown)
+              await this.sink.fail(failure);
+            else
+              await this.sink.emit({ type: "turn/completed", payload: { turnId: turn.turnId, status: "failed", error: { code: failure.code, message: failure.message, retryable: false, outcomeUnknown: false } } });
+          } finally {
+            if (this.activeTurn === turn.turnId)
+              this.activeTurn = undefined;
+          }
+        })().catch(() => {});
+        result = { turnId: turn.turnId, accepted: true };
+        break;
+      }
+      case "turn/interrupt":
+        await this.adapter.agent.notify("session/cancel", { sessionId: this.nativeId });
+        result = { accepted: true, turnId: params.turnId };
+        break;
+      case "session/config/set":
+        result = await this.setConfiguration(params.patch);
+        break;
+      case "session/close":
+        await this.dispose();
+        result = { closed: true };
+        break;
+      case "turn/steer":
+        return this.extension("steer", method, params);
+      case "session/revert":
+        return this.extension("revert", method, params);
+      case "history/read":
+        return this.extension("history", method, params);
+      case "goal/set":
+        return this.extension("goalSet", method, params);
+      case "goal/clear":
+        return this.extension("goalClear", method, params);
+      case "compact/start":
+        return this.extension("compact", method, params);
+      case "review/start":
+        return this.extension("review", method, params);
+      case "interaction/respond":
+      case "interaction/cancel":
+        throw new HarnessSdkError2("INTERACTION_EXPIRED");
+    }
+    return result;
+  }
+  async dispose() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    if (this.activeTurn)
+      await this.adapter.agent.notify("session/cancel", { sessionId: this.nativeId }).catch(() => {});
+    for (const terminalId of this.terminals)
+      await this.adapter.options.terminal?.releaseTerminal({ sessionId: this.nativeId, terminalId }).catch(() => {});
+    this.terminals.clear();
+    if (this.adapter.nativeCapabilities.sessionCapabilities?.close != null)
+      await this.adapter.call("session/close", { sessionId: this.nativeId }).catch(() => {});
+  }
+}
+function createAcpAdapter(options) {
+  return new AcpAdapter(options);
+}
+export {
+  AcpAdapter,
+  AcpBackendSession,
+  createAcpAdapter
+};

package/dist/mapping.d.ts

@@ -0,0 +1,30 @@
+import type { InputBlock, JsonValue, JsonObject, ConfigOption, SessionState } from '@anureo/protocol';
+import { type SessionEventSink } from '@anureo/sdk';
+import type { ContentBlock, McpServer } from '@agentclientprotocol/sdk';
+export declare function record(value: unknown): Record<string, unknown>;
+export declare function safe(value: unknown): JsonValue;
+export declare function text(value: unknown): string;
+export declare function input(blocks: InputBlock[]): ContentBlock[];
+export declare function mcp(servers?: import('@anureo/protocol').McpServer[]): McpServer[];
+export declare function configuration(data: Record<string, unknown>): {
+    options: ConfigOption[];
+    values: JsonObject;
+    keys: Map<string, Record<string, unknown>>;
+};
+/** Accumulates native updates; only complete snapshots become authoritative item/completed. */
+export declare class AcpUpdateMapper {
+    private readonly sink;
+    private readonly getTurn;
+    private readonly state;
+    private readonly setState;
+    private readonly subagents;
+    private readonly items;
+    private readonly ended;
+    private serial;
+    private compaction;
+    constructor(sink: SessionEventSink, getTurn: () => string | undefined, state: () => SessionState, setState: (data: Record<string, unknown>) => void, subagents: boolean);
+    reset(): void;
+    private upsert;
+    complete(): Promise<void>;
+    update(update: Record<string, unknown>): Promise<void>;
+}

package/package.json

@@ -1,6 +1,50 @@
 {
   "name": "@anureo/adapter-acp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Anureo SDK adapter for standard Agent Client Protocol (ACP) agents",
+  "license": "Apache-2.0",
+  "keywords": [
+    "anureo",
+    "ahp",
+    "harness",
+    "agent",
+    "acp",
+    "agent-client-protocol"
+  ],
+  "homepage": "https://github.com/hi-youichi/anureo-sdk#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hi-youichi/anureo-sdk.git",
+    "directory": "packages/acp"
+  },
+  "bugs": {
+    "url": "https://github.com/hi-youichi/anureo-sdk/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "schema",
+    "protocol",
+    "examples",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@anureo/sdk": "0.2.0",
+    "@anureo/protocol": "0.2.0",
+    "@agentclientprotocol/sdk": "1.4.0"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}