@@ -3701,7 +3701,13 @@ Identity provenance records who chose a provider-native session identity: the pr
 returned it, or the client allocated it before the provider existed. This provenance is
 retained rather than inferred, because after the fact both are just a string in the
 record. A released record written before the distinction existed reads as
-provider-returned, which is the only compatibility inference.
+provider-returned, which is the only compatibility inference. Backend confirmation
+is separate from allocation: Claude's native route remains client-allocated when
+the retained adapter confirms that same conversation on `_meta.agentSessionId`.
+The adapter reads its owned SDK Query before answering session creation or
+reattachment. Only a successful SessionStart lifecycle response confirms the
+identity; a requested UUID or ACP session name does not. This confirmation stays
+private until explicit first-turn acceptance and the asserting provider save.
 
 #### Proving release
 
@@ -4232,7 +4238,10 @@ asked at all.
 
 The workflow profile selects ACP-only capability explicitly: it advertises
 neither native launch nor client-native attachment. It supplies no machine
-session coordinator, construction-route store or executable observer. A workflow
+session coordinator, construction-route store or executable observer. The host
+selects its installed Claude launcher separately and supplies the path only to
+the retained adapter child's transient environment. This selection grants no
+native-session capability and performs no executable-build admission. A workflow
 session belongs to a run; the machine-wide ownership account describes a
 different boundary. Deleting a run removes its mapping row and provider-session
 directory and reports the categories removed.
 
@@ -26,7 +26,7 @@
 
 import { ensureDir, exists, readTextFile, rm, writeTextFile } from "@effectionx/fs";
 import { readdir, readFile, rename as renamePath, rm as rmPath, writeFile } from "node:fs/promises";
-import { exec, useQuietProcessOutput } from "@executablemd/runtime";
+import { exec, hostClaudeExecutable, useQuietProcessOutput } from "@executablemd/runtime";
 import { createAgentRegistry } from "./acpx-runtime.ts";
 import type { AcpAgentRegistry } from "./acpx-runtime.ts";
 import type { AcpxProviderDependencies } from "./provider.ts";
@@ -243,8 +243,8 @@ function* contentDigest(directory: string): Operation<string> {
  *
  * A `file:` dependency rather than an unpacked tree, so the adapter's own
  * runtime dependencies are resolved the way they are for anybody installing it
- * from the registry. Provider CLIs are among those dependencies and are not
- * carried here: this repository vendors the adapter, never the agent.
+ * from the registry. Claude uses the host CLI; its SDK library remains installed
+ * while platform executable optional dependencies are omitted.
  */
 function* install(
   directory: string,
@@ -273,7 +273,15 @@ function* install(
   const installed = yield* scoped(function* () {
     yield* useQuietProcessOutput();
     return yield* exec({
-      command: ["npm", "install", "--omit=dev", "--no-audit", "--no-fund", "--loglevel=error"],
+      command: [
+        "npm",
+        "install",
+        "--omit=dev",
+        ...(snapshot.provider === "claude" ? ["--omit=optional"] : []),
+        "--no-audit",
+        "--no-fund",
+        "--loglevel=error",
+      ],
       cwd: directory,
     });
   });
@@ -702,9 +710,19 @@ export function carriesEmbeddedAdapter(adapters: EmbeddedAdapters, agentName: st
  */
 export function embeddedAdapterDependencies(
   adapters: EmbeddedAdapters,
-): Pick<AcpxProviderDependencies, "agentRegistry" | "prepareAgent"> {
+): Pick<AcpxProviderDependencies, "agentRegistry" | "prepareAgent" | "agentProcessEnv"> {
   return {
     agentRegistry: overlaidAdapterRegistry(adapters),
+    *agentProcessEnv(agentName, agentCommand) {
+      if (
+        agentName !== "claude" ||
+        !carriesEmbeddedAdapter(adapters, agentName) ||
+        agentCommand !== adapters.command(agentName)
+      ) {
+        return undefined;
+      }
+      return { CLAUDE_CODE_EXECUTABLE: yield* hostClaudeExecutable() };
+    },
     *prepareAgent(agentName: string): Operation<void> {
       if (!carriesEmbeddedAdapter(adapters, agentName)) {
         return;
 
@@ -235,9 +235,6 @@ const ADAPTERS: Readonly<Record<string, NativeAdapter>> = {
     binding: {
       command: "claude",
       version: claudeVersion,
-      // The version #561's gates are proven against. Raising it is a new proof,
-      // not a version bump.
-      adapterCommand: "npx -y @agentclientprotocol/claude-agent-acp@0.70.0",
       // The first thing the Claude ACP adapter consults when deciding which
       // Claude to run. Without it the adapter resolves the build shipped with
       // the Agent SDK it pins, which is not the build that created the session.
 
@@ -268,6 +268,11 @@ export interface AcpxProviderDependencies {
    * asks for one prepares nothing.
    */
   prepareAgent?: (agentName: string) => Operation<void>;
+  /** Child-only host inputs for the selected command; never session configuration. */
+  agentProcessEnv?: (
+    agentName: string,
+    agentCommand: string,
+  ) => Operation<Record<string, string> | undefined>;
   /**
    * The native adapters this host has proven and is therefore willing to hand
    * a session to. Absent means none: knowing an adapter's command shape is not
@@ -1204,7 +1209,7 @@ function* useAcpxProviderState(
     };
   }
 
-  function* runtimeOptions(): Operation<AcpRuntimeOptions> {
+  function* runtimeOptions(agentName?: string): Operation<AcpRuntimeOptions> {
     const dir = yield* agentCwd();
     const options: AcpRuntimeOptions = {
       cwd: dir,
@@ -1213,6 +1218,15 @@ function* useAcpxProviderState(
       permissionMode: providerOptions.permissionMode,
       nonInteractivePermissions: "deny",
     };
+    if (agentName !== undefined && dependencies?.agentProcessEnv !== undefined) {
+      const environment = yield* dependencies.agentProcessEnv(
+        agentName,
+        resolveAgentCommand(registry, agentName),
+      );
+      if (environment !== undefined) {
+        options.agentProcessEnv = { ...environment };
+      }
+    }
     if (mcpServers !== undefined) {
       options.mcpServers = [...mcpServers];
     }
@@ -1253,8 +1267,8 @@ function* useAcpxProviderState(
    * step: an election that suspends part-way through is an election another
    * operation can act between.
    */
-  function* runtimeBlueprint(build?: BoundBuild): Operation<AcpRuntimeOptions> {
-    const base = yield* runtimeOptions();
+  function* runtimeBlueprint(build?: BoundBuild, agentName?: string): Operation<AcpRuntimeOptions> {
+    const base = yield* runtimeOptions(build === undefined ? agentName : undefined);
     const options: AcpRuntimeOptions = {
       ...base,
       // The acpx callback boundary: `scope.run` returns a Promise-compatible
@@ -1284,12 +1298,18 @@ function* useAcpxProviderState(
    * map no longer names and the next operation builds a second child for the
    * same build. Here the entry is published already reserved.
    */
-  function electRuntime(partition: string | undefined, options: AcpRuntimeOptions): RuntimeEntry {
+  function electRuntime(
+    partition: string | undefined,
+    options: AcpRuntimeOptions | undefined,
+  ): RuntimeEntry {
     const held = partition === undefined ? unbound : runtimes.get(partition);
     if (held) {
       held.active++;
       return held;
     }
+    if (options === undefined) {
+      throw new Error("the selected ACP runtime was released during preparation");
+    }
     const entry: RuntimeEntry = {
       runtime: createRuntime(options),
       partition,
@@ -1419,10 +1439,6 @@ function* useAcpxProviderState(
     toSession: (handle: AcpRuntimeHandle, entry: RuntimeEntry) => ManagedSession,
   ): Operation<ManagedSession> {
     return scoped(function* (): Operation<ManagedSession> {
-      const partition = build ? partitionOf(build) : undefined;
-      // Every suspension this needs, taken before anything is decided. What
-      // follows must not yield, so nothing it depends on may.
-      const options = yield* runtimeBlueprint(build);
       let claimed: RuntimeEntry | undefined;
       let pending: Promise<AcpRuntimeHandle> | undefined;
       let settled = false;
@@ -1470,6 +1486,16 @@ function* useAcpxProviderState(
         yield* abandonHandle(late, "cancelled before the session was established");
       });
 
+      const partition = build
+        ? partitionOf(build)
+        : dependencies?.agentProcessEnv === undefined
+          ? undefined
+          : `host\u0000${input.agent}\u0000${resolveAgentCommand(registry, input.agent)}`;
+      const held = partition === undefined ? unbound : runtimes.get(partition);
+      const options =
+        build !== undefined || dependencies?.agentProcessEnv === undefined || held === undefined
+          ? yield* runtimeBlueprint(build, input.agent)
+          : undefined;
       // One synchronous step: the map is read, an entry is published already
       // claimed if this is the first work to want one, and the ensure is
       // started. Nothing yields in here, so no sibling runs between the
@@ -1533,7 +1559,7 @@ function* useAcpxProviderState(
     // client-native session is created by a native process, and where ACP does
     // serve one, the establishment itself reports being unable to.
     if (!validatedAgents.has(selected) && !boundSessions(selected)) {
-      const base = yield* runtimeOptions();
+      const base = yield* runtimeOptions(selected);
       const probe = createRuntime({ ...base, probeAgent: selected });
       const report = yield* until(probe.doctor());
       if (!report.ok) {
 
@@ -831,3 +831,30 @@ describe("Tier AM — embedded adapter materialization", () => {
     expect(yield* exists(adapters.executablePath("codex"))).toBe(true);
   });
 });
+
+describe("HC fresh Claude materialization", () => {
+  it("HC5: the SDK library and required packages survive without platform executables", function* () {
+    const root = yield* useRoot();
+    const adapters = createEmbeddedAdapters(root);
+    yield* adapters.materialize("claude");
+    const names: string[] = [];
+    function* walk(directory: string): Operation<void> {
+      for (const entry of yield* until(readdir(directory, { withFileTypes: true }))) {
+        if (entry.isDirectory()) {
+          yield* walk(join(directory, entry.name));
+        } else if (entry.name === "package.json") {
+          const value = JSON.parse(yield* until(readFile(join(directory, entry.name), "utf8")));
+          if (typeof value.name === "string") {
+            names.push(value.name);
+          }
+        }
+      }
+    }
+    yield* walk(join(root, digestOf("claude"), "node_modules"));
+    expect(names).toContain("@agentclientprotocol/claude-agent-acp");
+    expect(names).toContain("@anthropic-ai/claude-agent-sdk");
+    expect(names).toContain("@agentclientprotocol/sdk");
+    expect(names).toContain("zod");
+    expect(names.filter((name) => name.startsWith("@anthropic-ai/claude-agent-sdk-"))).toEqual([]);
+  });
+});