@ai-sdk/harness-claude-code 1.0.137 → 1.0.139

package/dist/index.js

@@ -1,2014 +1,1742 @@
-// src/claude-code-harness.ts
-import { posix } from "path";
-import {
-  commonTool,
-  HARNESS_V1_BUILTIN_TOOLS,
-  harnessV1DiagnosticFromBridgeFrame,
-  HarnessCapabilityUnsupportedError,
-  harnessStateDirectoryPath,
-  harnessSessionDataDirectoryPath
-} from "@ai-sdk/harness";
-import {
-  applyCredentialForwarding,
-  classifyDiskLog,
-  resolveSandboxCredentialEnvironment,
-  createBridgeToken,
-  experimental_createBridgeUserMessageSubmitter,
-  createBridgeErrorHandler,
-  createBridgeStartupError,
-  drainBridgeProcessStream,
-  forwardBridgeProcessStream,
-  getRestrictedSandboxSession,
-  markBridgeStarting,
-  resolveSandboxHomeDir,
-  SandboxChannel,
-  shellQuote,
-  sleep,
-  warnCredentialBrokeringUnavailable,
-  waitForBridgeReady,
-  withBridgeToken,
-  writeSkills
-} from "@ai-sdk/harness/utils";
-import {
-  safeParseJSON as safeParseJSON2,
-  tool
-} from "@ai-sdk/provider-utils";
+import { dirname, join, posix, resolve } from "node:path";
+import { HARNESS_V1_BUILTIN_TOOLS, HarnessCapabilityUnsupportedError, commonTool, harnessSessionDataDirectoryPath, harnessStateDirectoryPath, harnessV1BridgeInboundCommandSchemas, harnessV1BridgeOutboundMessageSchema, harnessV1BridgeStartBaseSchema, harnessV1DiagnosticFromBridgeFrame } from "@ai-sdk/harness";
+import { SandboxChannel, applyCredentialForwarding, classifyDiskLog, createBridgeErrorHandler, createBridgeStartupError, createBridgeToken, createCredentialRequestTransformation, createReadBridgeAsset, drainBridgeProcessStream, experimental_createBridgeUserMessageSubmitter, forwardBridgeProcessStream, getAiGatewayAuthFromEnv, getRestrictedSandboxSession, isAccessTokenExpiringSoon, isHarnessAuthenticationEnvironment, isMacOS, markBridgeStarting, readMacOSKeychainPassword, refreshOAuthAccessToken, resolveSandboxCredentialEnvironment, resolveSandboxHomeDir, shellQuote, shouldResolveNativeSubscription, sleep, waitForBridgeReady, warnCredentialBrokeringUnavailable, withBridgeToken, writeSkills } from "@ai-sdk/harness/utils";
+import { isRecord, safeParseJSON, tool } from "@ai-sdk/provider-utils";
 import { WebSocket } from "ws";
-import { z as z2 } from "zod/v4";
-
-// src/claude-code-bootstrap.ts
-import { createReadBridgeAsset } from "@ai-sdk/harness/utils";
-var readBridgeAsset = createReadBridgeAsset({
-  "package.json": new URL("./bridge/package.json", import.meta.url),
-  "pnpm-lock.yaml": new URL("./bridge/pnpm-lock.yaml", import.meta.url),
-  "pnpm-workspace.yaml": new URL(
-    "./bridge/pnpm-workspace.yaml",
-    import.meta.url
-  ),
-  "index.mjs": new URL("./bridge/index.mjs", import.meta.url)
+import { z } from "zod/v4";
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+//#region src/claude-code-bootstrap.ts
+const readBridgeAsset = createReadBridgeAsset({
+	"package.json": new URL("./bridge/package.json", import.meta.url),
+	"pnpm-lock.yaml": new URL("./bridge/pnpm-lock.yaml", import.meta.url),
+	"pnpm-workspace.yaml": new URL("./bridge/pnpm-workspace.yaml", import.meta.url),
+	"index.mjs": new URL("./bridge/index.mjs", import.meta.url)
 });
-var CLAUDE_CODE_BOOTSTRAP_DIR = ".harness-bootstrap/claude-code";
-var cachedBootstrap;
+const CLAUDE_CODE_BOOTSTRAP_DIR = ".harness-bootstrap/claude-code";
+let cachedBootstrap;
 async function getClaudeCodeBootstrap() {
-  if (cachedBootstrap != null) return cachedBootstrap;
-  const [pkg, lock, workspace, bridge] = await Promise.all([
-    readBridgeAsset("package.json"),
-    readBridgeAsset("pnpm-lock.yaml"),
-    readBridgeAsset("pnpm-workspace.yaml"),
-    readBridgeAsset("index.mjs")
-  ]);
-  cachedBootstrap = {
-    harnessId: "claude-code",
-    bootstrapDir: CLAUDE_CODE_BOOTSTRAP_DIR,
-    files: [
-      { path: `${CLAUDE_CODE_BOOTSTRAP_DIR}/package.json`, content: pkg },
-      { path: `${CLAUDE_CODE_BOOTSTRAP_DIR}/pnpm-lock.yaml`, content: lock },
-      {
-        path: `${CLAUDE_CODE_BOOTSTRAP_DIR}/pnpm-workspace.yaml`,
-        content: workspace
-      },
-      { path: `${CLAUDE_CODE_BOOTSTRAP_DIR}/bridge.mjs`, content: bridge }
-    ],
-    commands: [
-      {
-        command: "pnpm install --frozen-lockfile --store-dir .pnpm-store"
-      },
-      {
-        command: "./node_modules/.bin/claude --version"
-      }
-    ]
-  };
-  return cachedBootstrap;
+	if (cachedBootstrap != null) return cachedBootstrap;
+	const [pkg, lock, workspace, bridge] = await Promise.all([
+		readBridgeAsset("package.json"),
+		readBridgeAsset("pnpm-lock.yaml"),
+		readBridgeAsset("pnpm-workspace.yaml"),
+		readBridgeAsset("index.mjs")
+	]);
+	cachedBootstrap = {
+		harnessId: "claude-code",
+		bootstrapDir: CLAUDE_CODE_BOOTSTRAP_DIR,
+		files: [
+			{
+				path: `${CLAUDE_CODE_BOOTSTRAP_DIR}/package.json`,
+				content: pkg
+			},
+			{
+				path: `${CLAUDE_CODE_BOOTSTRAP_DIR}/pnpm-lock.yaml`,
+				content: lock
+			},
+			{
+				path: `${CLAUDE_CODE_BOOTSTRAP_DIR}/pnpm-workspace.yaml`,
+				content: workspace
+			},
+			{
+				path: `${CLAUDE_CODE_BOOTSTRAP_DIR}/bridge.mjs`,
+				content: bridge
+			}
+		],
+		commands: [{ command: "pnpm install --frozen-lockfile --store-dir .pnpm-store" }, { command: "./node_modules/.bin/claude --version" }]
+	};
+	return cachedBootstrap;
 }
-
-// src/claude-code-auth.ts
-import { execFileSync } from "child_process";
-import { readFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-import {
-  createCredentialRequestTransformation,
-  getAiGatewayAuthFromEnv,
-  isHarnessAuthenticationEnvironment
-} from "@ai-sdk/harness/utils";
-var CLAUDE_CODE_CREDENTIAL_ENVIRONMENT_VARIABLES = [
-  "AI_GATEWAY_API_KEY",
-  "ANTHROPIC_API_KEY",
-  "ANTHROPIC_AUTH_TOKEN",
-  "CLAUDE_CODE_OAUTH_TOKEN"
+//#endregion
+//#region src/claude-code-auth.ts
+const CLAUDE_CODE_CREDENTIAL_ENVIRONMENT_VARIABLES = [
+	"AI_GATEWAY_API_KEY",
+	"ANTHROPIC_API_KEY",
+	"ANTHROPIC_AUTH_TOKEN",
+	"CLAUDE_CODE_OAUTH_TOKEN"
 ];
-function createClaudeCodeRequestTransformations({
-  env: environment,
-  sandboxEnv: sandboxEnvironment,
-  auth: authenticationMode
-}) {
-  const matchUrl = authenticationMode === "ai-gateway" ? environment.ANTHROPIC_BASE_URL : environment.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com";
-  const transformations = [];
-  if (environment.ANTHROPIC_API_KEY != null && sandboxEnvironment.ANTHROPIC_API_KEY != null) {
-    transformations.push(
-      createCredentialRequestTransformation({
-        matchUrl,
-        matchHeaders: {
-          "x-api-key": sandboxEnvironment.ANTHROPIC_API_KEY
-        },
-        transformHeaders: {
-          "x-api-key": environment.ANTHROPIC_API_KEY
-        }
-      })
-    );
-  }
-  if (environment.ANTHROPIC_AUTH_TOKEN != null && sandboxEnvironment.ANTHROPIC_AUTH_TOKEN != null) {
-    transformations.push(
-      createCredentialRequestTransformation({
-        matchUrl,
-        matchHeaders: {
-          Authorization: `Bearer ${sandboxEnvironment.ANTHROPIC_AUTH_TOKEN}`
-        },
-        transformHeaders: {
-          Authorization: `Bearer ${environment.ANTHROPIC_AUTH_TOKEN}`
-        }
-      })
-    );
-  }
-  return transformations;
+function createClaudeCodeRequestTransformations({ env: environment, sandboxEnv: sandboxEnvironment, auth: authenticationMode }) {
+	const matchUrl = authenticationMode === "ai-gateway" ? environment.ANTHROPIC_BASE_URL : environment.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com";
+	const transformations = [];
+	if (environment.ANTHROPIC_API_KEY != null && sandboxEnvironment.ANTHROPIC_API_KEY != null) transformations.push(createCredentialRequestTransformation({
+		matchUrl,
+		matchHeaders: { "x-api-key": sandboxEnvironment.ANTHROPIC_API_KEY },
+		transformHeaders: { "x-api-key": environment.ANTHROPIC_API_KEY }
+	}));
+	if (environment.ANTHROPIC_AUTH_TOKEN != null && sandboxEnvironment.ANTHROPIC_AUTH_TOKEN != null) transformations.push(createCredentialRequestTransformation({
+		matchUrl,
+		matchHeaders: { Authorization: `Bearer ${sandboxEnvironment.ANTHROPIC_AUTH_TOKEN}` },
+		transformHeaders: { Authorization: `Bearer ${environment.ANTHROPIC_AUTH_TOKEN}` }
+	}));
+	return transformations;
 }
 function resolveClaudeCodeEnv(auth, processEnv = process.env, options = {}) {
-  const suppliedEnvironment = isHarnessAuthenticationEnvironment(auth);
-  const authenticationEnvironment = suppliedEnvironment ? auth : processEnv;
-  const readApiKey = suppliedEnvironment || auth === "direct" ? () => void 0 : options.readApiKeyHelper ?? readApiKeyHelper;
-  if (auth === "direct") {
-    return pickAnthropic({
-      processEnv: authenticationEnvironment,
-      readApiKey
-    });
-  }
-  const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({
-    env: authenticationEnvironment
-  });
-  if (auth === "ai-gateway" || gatewayAuthFromEnv.apiKey) {
-    return pickGateway({ gatewayAuthFromEnv });
-  }
-  return pickAnthropic({
-    processEnv: authenticationEnvironment,
-    readApiKey
-  });
+	const suppliedEnvironment = isHarnessAuthenticationEnvironment(auth);
+	const authenticationEnvironment = suppliedEnvironment ? auth : processEnv;
+	const readApiKey = suppliedEnvironment || auth === "direct" ? () => void 0 : options.readApiKeyHelper ?? readApiKeyHelper;
+	if (auth === "direct") return pickAnthropic({
+		processEnv: authenticationEnvironment,
+		readApiKey
+	});
+	const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({ env: authenticationEnvironment });
+	if (auth === "ai-gateway" || gatewayAuthFromEnv.apiKey) return pickGateway({ gatewayAuthFromEnv });
+	return pickAnthropic({
+		processEnv: authenticationEnvironment,
+		readApiKey
+	});
 }
 function resolveClaudeCodeAuthenticationMode(auth, processEnv = process.env) {
-  if (isHarnessAuthenticationEnvironment(auth)) {
-    return getAiGatewayAuthFromEnv({ env: auth }).apiKey ? "ai-gateway" : "direct";
-  }
-  if (auth === "direct") {
-    return "direct";
-  }
-  if (auth === "ai-gateway") {
-    return "ai-gateway";
-  }
-  return getAiGatewayAuthFromEnv({ env: processEnv }).apiKey ? "ai-gateway" : "direct";
+	if (isHarnessAuthenticationEnvironment(auth)) return getAiGatewayAuthFromEnv({ env: auth }).apiKey ? "ai-gateway" : "direct";
+	if (auth === "direct") return "direct";
+	if (auth === "ai-gateway") return "ai-gateway";
+	return getAiGatewayAuthFromEnv({ env: processEnv }).apiKey ? "ai-gateway" : "direct";
 }
-function pickAnthropic({
-  processEnv,
-  readApiKey
-}) {
-  const env = {};
-  const helperKey = readApiKey();
-  const apiKey = processEnv.ANTHROPIC_API_KEY ?? helperKey;
-  const authToken = processEnv.ANTHROPIC_AUTH_TOKEN ?? helperKey;
-  const oauthToken = processEnv.CLAUDE_CODE_OAUTH_TOKEN;
-  if (apiKey) env.ANTHROPIC_API_KEY = apiKey;
-  if (authToken) env.ANTHROPIC_AUTH_TOKEN = authToken;
-  if (oauthToken) env.CLAUDE_CODE_OAUTH_TOKEN = oauthToken;
-  const baseUrl = processEnv.ANTHROPIC_BASE_URL;
-  if (baseUrl) env.ANTHROPIC_BASE_URL = baseUrl;
-  return env;
+function pickAnthropic({ processEnv, readApiKey }) {
+	const env = {};
+	const helperKey = readApiKey();
+	const apiKey = processEnv.ANTHROPIC_API_KEY ?? helperKey;
+	const authToken = processEnv.ANTHROPIC_AUTH_TOKEN ?? helperKey;
+	const oauthToken = processEnv.CLAUDE_CODE_OAUTH_TOKEN;
+	if (apiKey) env.ANTHROPIC_API_KEY = apiKey;
+	if (authToken) env.ANTHROPIC_AUTH_TOKEN = authToken;
+	if (oauthToken) env.CLAUDE_CODE_OAUTH_TOKEN = oauthToken;
+	const baseUrl = processEnv.ANTHROPIC_BASE_URL;
+	if (baseUrl) env.ANTHROPIC_BASE_URL = baseUrl;
+	return env;
 }
+/**
+* Read the `apiKeyHelper` setting from `~/.claude/settings.json` and run
+* it. The `claude` CLI uses this hook to fetch credentials from password
+* managers and similar tools; mirroring it here lets users with that
+* setup run the harness without having to set `ANTHROPIC_API_KEY`
+* explicitly.
+*/
 function readApiKeyHelper() {
-  const home = homedir();
-  if (!home) return void 0;
-  let raw;
-  try {
-    raw = readFileSync(join(home, ".claude", "settings.json"), "utf8");
-  } catch {
-    return void 0;
-  }
-  let settings;
-  try {
-    settings = JSON.parse(raw);
-  } catch {
-    return void 0;
-  }
-  const command = settings.apiKeyHelper;
-  if (typeof command !== "string" || command.length === 0) return void 0;
-  try {
-    const output = execFileSync("sh", ["-c", command], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    const trimmed = output.trim();
-    return trimmed.length > 0 ? trimmed : void 0;
-  } catch {
-    return void 0;
-  }
+	const home = homedir();
+	if (!home) return void 0;
+	let raw;
+	try {
+		raw = readFileSync(join(home, ".claude", "settings.json"), "utf8");
+	} catch {
+		return;
+	}
+	let settings;
+	try {
+		settings = JSON.parse(raw);
+	} catch {
+		return;
+	}
+	const command = settings.apiKeyHelper;
+	if (typeof command !== "string" || command.length === 0) return void 0;
+	try {
+		const trimmed = execFileSync("sh", ["-c", command], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		return trimmed.length > 0 ? trimmed : void 0;
+	} catch {
+		return;
+	}
 }
-function pickGateway({
-  gatewayAuthFromEnv
-}) {
-  const apiKey = gatewayAuthFromEnv.apiKey;
-  const baseUrl = gatewayAuthFromEnv.baseUrl;
-  const env = {};
-  if (apiKey) {
-    env.AI_GATEWAY_API_KEY = apiKey;
-    env.ANTHROPIC_API_KEY = apiKey;
-  }
-  env.AI_GATEWAY_BASE_URL = baseUrl;
-  env.ANTHROPIC_BASE_URL = baseUrl;
-  return env;
+function pickGateway({ gatewayAuthFromEnv }) {
+	const apiKey = gatewayAuthFromEnv.apiKey;
+	const baseUrl = gatewayAuthFromEnv.baseUrl;
+	const env = {};
+	if (apiKey) {
+		env.AI_GATEWAY_API_KEY = apiKey;
+		env.ANTHROPIC_API_KEY = apiKey;
+	}
+	env.AI_GATEWAY_BASE_URL = baseUrl;
+	env.ANTHROPIC_BASE_URL = baseUrl;
+	return env;
 }
-
-// src/claude-code-subscription.ts
-import { execFileSync as execFileSync2 } from "child_process";
-import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { dirname, join as join2, resolve } from "path";
-import {
-  createCredentialRequestTransformation as createCredentialRequestTransformation2,
-  isAccessTokenExpiringSoon,
-  isHarnessAuthenticationEnvironment as isHarnessAuthenticationEnvironment2,
-  isMacOS,
-  readMacOSKeychainPassword,
-  refreshOAuthAccessToken,
-  shouldResolveNativeSubscription
-} from "@ai-sdk/harness/utils";
-import { isRecord, safeParseJSON } from "@ai-sdk/provider-utils";
-var CLAUDE_TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
-var CLAUDE_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
-function createClaudeCodeSubscriptionRequestTransformations({
-  env: environment,
-  sandboxEnv: sandboxEnvironment,
-  auth: authenticationMode
-}) {
-  if (environment.CLAUDE_CODE_OAUTH_TOKEN == null || sandboxEnvironment.CLAUDE_CODE_OAUTH_TOKEN == null) {
-    return [];
-  }
-  return [
-    createCredentialRequestTransformation2({
-      matchUrl: authenticationMode === "ai-gateway" ? environment.ANTHROPIC_BASE_URL : environment.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com",
-      matchHeaders: {
-        Authorization: `Bearer ${sandboxEnvironment.CLAUDE_CODE_OAUTH_TOKEN}`
-      },
-      transformHeaders: {
-        Authorization: `Bearer ${environment.CLAUDE_CODE_OAUTH_TOKEN}`
-      }
-    })
-  ];
+//#endregion
+//#region src/claude-code-subscription.ts
+const CLAUDE_TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+const CLAUDE_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+function createClaudeCodeSubscriptionRequestTransformations({ env: environment, sandboxEnv: sandboxEnvironment, auth: authenticationMode }) {
+	if (environment.CLAUDE_CODE_OAUTH_TOKEN == null || sandboxEnvironment.CLAUDE_CODE_OAUTH_TOKEN == null) return [];
+	return [createCredentialRequestTransformation({
+		matchUrl: authenticationMode === "ai-gateway" ? environment.ANTHROPIC_BASE_URL : environment.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com",
+		matchHeaders: { Authorization: `Bearer ${sandboxEnvironment.CLAUDE_CODE_OAUTH_TOKEN}` },
+		transformHeaders: { Authorization: `Bearer ${environment.CLAUDE_CODE_OAUTH_TOKEN}` }
+	})];
 }
-async function resolveClaudeCodeAuthentication({
-  auth,
-  processEnv = process.env,
-  options = {},
-  readSubscription = readClaudeCodeSubscription
-}) {
-  const environmentWithoutHelper = resolveClaudeCodeEnv(auth, processEnv, {
-    readApiKeyHelper: () => void 0
-  });
-  if (isHarnessAuthenticationEnvironment2(auth)) {
-    return environmentWithoutHelper;
-  }
-  if (!shouldResolveNativeSubscription({
-    auth,
-    env: environmentWithoutHelper,
-    hasDirectCredential: environmentWithoutHelper.ANTHROPIC_API_KEY != null || environmentWithoutHelper.ANTHROPIC_AUTH_TOKEN != null || environmentWithoutHelper.CLAUDE_CODE_OAUTH_TOKEN != null
-  })) {
-    return environmentWithoutHelper;
-  }
-  return await readSubscription() ?? resolveClaudeCodeEnv(auth, processEnv, options);
+async function resolveClaudeCodeAuthentication({ auth, processEnv = process.env, options = {}, readSubscription = readClaudeCodeSubscription }) {
+	const environmentWithoutHelper = resolveClaudeCodeEnv(auth, processEnv, { readApiKeyHelper: () => void 0 });
+	if (isHarnessAuthenticationEnvironment(auth)) return environmentWithoutHelper;
+	if (!shouldResolveNativeSubscription({
+		auth,
+		env: environmentWithoutHelper,
+		hasDirectCredential: environmentWithoutHelper.ANTHROPIC_API_KEY != null || environmentWithoutHelper.ANTHROPIC_AUTH_TOKEN != null || environmentWithoutHelper.CLAUDE_CODE_OAUTH_TOKEN != null
+	})) return environmentWithoutHelper;
+	return await readSubscription() ?? resolveClaudeCodeEnv(auth, processEnv, options);
 }
-async function readClaudeCodeSubscription({
-  env = process.env,
-  homeDirectory = homedir2(),
-  platform = process.platform,
-  fetch
-} = {}) {
-  const configDirectory = resolve(
-    env.CLAUDE_CONFIG_DIR ?? join2(homeDirectory, ".claude")
-  );
-  const credentialPath = join2(configDirectory, ".credentials.json");
-  const stored = await readClaudeCredentialStore({
-    credentialPath,
-    homeDirectory,
-    configDirectory,
-    platform
-  });
-  if (stored == null) return void 0;
-  const oauth = getClaudeOAuthCredential({ value: stored.value });
-  if (oauth == null) return void 0;
-  const { accessToken, refreshToken, expiresAt } = oauth;
-  let resolvedAccessToken = accessToken;
-  if (isAccessTokenExpiringSoon({ expiresAt })) {
-    const refreshed = await refreshOAuthAccessToken({
-      tokenUrl: CLAUDE_TOKEN_URL,
-      clientId: CLAUDE_CLIENT_ID,
-      refreshToken,
-      requestFormat: "json",
-      ...fetch == null ? {} : { fetch }
-    });
-    resolvedAccessToken = refreshed.accessToken;
-    await stored.write({
-      ...stored.value,
-      claudeAiOauth: {
-        ...oauth,
-        accessToken: refreshed.accessToken,
-        refreshToken: refreshed.refreshToken ?? refreshToken,
-        expiresAt: refreshed.expiresAt
-      }
-    });
-  }
-  return {
-    CLAUDE_CODE_OAUTH_TOKEN: resolvedAccessToken,
-    ANTHROPIC_BASE_URL: "https://api.anthropic.com"
-  };
+async function readClaudeCodeSubscription({ env = process.env, homeDirectory = homedir(), platform = process.platform, fetch } = {}) {
+	const configDirectory = resolve(env.CLAUDE_CONFIG_DIR ?? join(homeDirectory, ".claude"));
+	const stored = await readClaudeCredentialStore({
+		credentialPath: join(configDirectory, ".credentials.json"),
+		homeDirectory,
+		configDirectory,
+		platform
+	});
+	if (stored == null) return void 0;
+	const oauth = getClaudeOAuthCredential({ value: stored.value });
+	if (oauth == null) return void 0;
+	const { accessToken, refreshToken, expiresAt } = oauth;
+	let resolvedAccessToken = accessToken;
+	if (isAccessTokenExpiringSoon({ expiresAt })) {
+		const refreshed = await refreshOAuthAccessToken({
+			tokenUrl: CLAUDE_TOKEN_URL,
+			clientId: CLAUDE_CLIENT_ID,
+			refreshToken,
+			requestFormat: "json",
+			...fetch == null ? {} : { fetch }
+		});
+		resolvedAccessToken = refreshed.accessToken;
+		await stored.write({
+			...stored.value,
+			claudeAiOauth: {
+				...oauth,
+				accessToken: refreshed.accessToken,
+				refreshToken: refreshed.refreshToken ?? refreshToken,
+				expiresAt: refreshed.expiresAt
+			}
+		});
+	}
+	return {
+		CLAUDE_CODE_OAUTH_TOKEN: resolvedAccessToken,
+		ANTHROPIC_BASE_URL: "https://api.anthropic.com"
+	};
 }
-async function readClaudeCredentialStore({
-  credentialPath,
-  homeDirectory,
-  configDirectory,
-  platform
-}) {
-  const text = await readFile(credentialPath, "utf8").catch(() => void 0);
-  if (text != null) {
-    const value2 = await parseClaudeCredentialFile(text);
-    if (value2 != null && getClaudeOAuthCredential({ value: value2 }) != null) {
-      return {
-        value: value2,
-        write: (updated) => writeClaudeCredentialFile({ credentialPath, value: updated })
-      };
-    }
-  }
-  if (!isMacOS(platform)) return void 0;
-  if (configDirectory !== resolve(join2(homeDirectory, ".claude"))) {
-    return void 0;
-  }
-  const service = "Claude Code-credentials";
-  const keychainText = await readMacOSKeychainPassword({
-    service,
-    account: process.env.USER ?? ""
-  });
-  if (keychainText == null) return void 0;
-  const value = await parseClaudeCredentialFile(keychainText);
-  if (value == null) return void 0;
-  return {
-    value,
-    write: async (updated) => {
-      execFileSync2(
-        "/usr/bin/security",
-        [
-          "add-generic-password",
-          "-U",
-          "-s",
-          service,
-          "-a",
-          process.env.USER ?? "",
-          "-w",
-          JSON.stringify(updated)
-        ],
-        { stdio: "ignore" }
-      );
-    }
-  };
+async function readClaudeCredentialStore({ credentialPath, homeDirectory, configDirectory, platform }) {
+	const text = await readFile(credentialPath, "utf8").catch(() => void 0);
+	if (text != null) {
+		const value = await parseClaudeCredentialFile(text);
+		if (value != null && getClaudeOAuthCredential({ value }) != null) return {
+			value,
+			write: (updated) => writeClaudeCredentialFile({
+				credentialPath,
+				value: updated
+			})
+		};
+	}
+	if (!isMacOS(platform)) return void 0;
+	if (configDirectory !== resolve(join(homeDirectory, ".claude"))) return;
+	const service = "Claude Code-credentials";
+	const keychainText = await readMacOSKeychainPassword({
+		service,
+		account: process.env.USER ?? ""
+	});
+	if (keychainText == null) return void 0;
+	const value = await parseClaudeCredentialFile(keychainText);
+	if (value == null) return void 0;
+	return {
+		value,
+		write: async (updated) => {
+			execFileSync("/usr/bin/security", [
+				"add-generic-password",
+				"-U",
+				"-s",
+				service,
+				"-a",
+				process.env.USER ?? "",
+				"-w",
+				JSON.stringify(updated)
+			], { stdio: "ignore" });
+		}
+	};
 }
-function getClaudeOAuthCredential({
-  value
-}) {
-  const oauth = value.claudeAiOauth;
-  if (!isRecord(oauth) || typeof oauth.accessToken !== "string" || typeof oauth.refreshToken !== "string" || typeof oauth.expiresAt !== "number") {
-    return void 0;
-  }
-  return oauth;
+function getClaudeOAuthCredential({ value }) {
+	const oauth = value.claudeAiOauth;
+	if (!isRecord(oauth) || typeof oauth.accessToken !== "string" || typeof oauth.refreshToken !== "string" || typeof oauth.expiresAt !== "number") return;
+	return oauth;
 }
 async function parseClaudeCredentialFile(text) {
-  const parsed = await safeParseJSON({ text });
-  return parsed.success && isRecord(parsed.value) ? parsed.value : void 0;
+	const parsed = await safeParseJSON({ text });
+	return parsed.success && isRecord(parsed.value) ? parsed.value : void 0;
 }
-async function writeClaudeCredentialFile({
-  credentialPath,
-  value
-}) {
-  await mkdir(dirname(credentialPath), { recursive: true });
-  const temporaryPath = `${credentialPath}.${process.pid}.tmp`;
-  await writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}
-`, {
-    mode: 384
-  });
-  await chmod(temporaryPath, 384);
-  await rename(temporaryPath, credentialPath);
+async function writeClaudeCredentialFile({ credentialPath, value }) {
+	await mkdir(dirname(credentialPath), { recursive: true });
+	const temporaryPath = `${credentialPath}.${process.pid}.tmp`;
+	await writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, { mode: 384 });
+	await chmod(temporaryPath, 384);
+	await rename(temporaryPath, credentialPath);
 }
-
-// src/claude-code-bridge-protocol.ts
-import {
-  harnessV1BridgeInboundCommandSchemas,
-  harnessV1BridgeOutboundMessageSchema,
-  harnessV1BridgeReadySchema,
-  harnessV1BridgeStartBaseSchema
-} from "@ai-sdk/harness";
-import { z } from "zod/v4";
-var outboundMessageSchema = harnessV1BridgeOutboundMessageSchema;
-var thinkingDisplaySchema = z.enum(["summarized", "omitted"]).optional();
-var thinkingSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("adaptive"),
-    display: thinkingDisplaySchema
-  }),
-  z.object({
-    type: z.literal("enabled"),
-    display: thinkingDisplaySchema
-  }),
-  z.object({ type: z.literal("disabled") })
+//#endregion
+//#region src/claude-code-bridge-protocol.ts
+const outboundMessageSchema = harnessV1BridgeOutboundMessageSchema;
+const thinkingDisplaySchema = z.enum(["summarized", "omitted"]).optional();
+const thinkingSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("adaptive"),
+		display: thinkingDisplaySchema
+	}),
+	z.object({
+		type: z.literal("enabled"),
+		display: thinkingDisplaySchema
+	}),
+	z.object({ type: z.literal("disabled") })
 ]);
-var startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
-  instructions: z.string().optional(),
-  thinking: thinkingSchema,
-  effort: z.enum(["low", "medium", "high", "xhigh", "max"]).optional(),
-  maxTurns: z.number().optional(),
-  env: z.record(z.string(), z.string()).optional(),
-  skills: z.array(z.string()).optional(),
-  mcpServers: z.record(z.string(), z.unknown()).optional(),
-  // Resume signal. When true, the bridge passes `{ continue: true }` to the
-  // Claude SDK so the in-workdir thread state is rehydrated. The host sets this
-  // on the first prompt after a cross-process resume.
-  continue: z.boolean().optional(),
-  // Exact conversation to resume, as the Claude SDK's `resume` option.
-  //
-  // Preferred over `continue` whenever the host knows which conversation it
-  // means: `continue` resolves to the most recent thread in the workdir, which
-  // is the wrong one as soon as anything else has run there since — including
-  // a resume that itself started a new thread. Mutually exclusive with
-  // `continue` in the SDK, so the bridge sends one or the other.
-  resumeSessionId: z.string().optional()
+const startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
+	instructions: z.string().optional(),
+	thinking: thinkingSchema,
+	effort: z.enum([
+		"low",
+		"medium",
+		"high",
+		"xhigh",
+		"max"
+	]).optional(),
+	maxTurns: z.number().optional(),
+	agentProgressSummaries: z.boolean().optional(),
+	forwardSubagentText: z.boolean().optional(),
+	env: z.record(z.string(), z.string()).optional(),
+	skills: z.array(z.string()).optional(),
+	mcpServers: z.record(z.string(), z.unknown()).optional(),
+	continue: z.boolean().optional(),
+	resumeSessionId: z.string().optional()
 });
-var inboundMessageSchema = z.discriminatedUnion("type", [
-  startMessageSchema,
-  ...harnessV1BridgeInboundCommandSchemas
-]);
-
-// src/version.ts
-var VERSION = true ? "1.0.137" : "0.0.0-test";
-
-// src/claude-code-harness.ts
-var CLAUDE_CODE_CLIENT_APP = `ai-sdk-harness-claude-code/${VERSION}`;
-var listMcpResourcesInputSchema = z2.object({
-  server: z2.string().optional()
+z.discriminatedUnion("type", [startMessageSchema, ...harnessV1BridgeInboundCommandSchemas]);
+//#endregion
+//#region src/version.ts
+const VERSION = "1.0.139";
+//#endregion
+//#region src/claude-code-harness.ts
+/**
+* Value to use in User-Agent and `x-client-app` headers.
+*/
+const CLAUDE_CODE_CLIENT_APP = `ai-sdk-harness-claude-code/${VERSION}`;
+const listMcpResourcesInputSchema = z.object({ server: z.string().optional() });
+const readMcpResourceInputSchema = z.object({
+	server: z.string(),
+	uri: z.string()
 });
-var readMcpResourceInputSchema = z2.object({
-  server: z2.string(),
-  uri: z2.string()
-});
-var structuredTeamMessageSchema = z2.discriminatedUnion("type", [
-  z2.object({
-    type: z2.literal("shutdown_request"),
-    reason: z2.string().optional()
-  }),
-  z2.object({
-    type: z2.literal("shutdown_response"),
-    request_id: z2.string(),
-    approve: z2.boolean(),
-    reason: z2.string().optional()
-  }),
-  z2.object({
-    type: z2.literal("plan_approval_response"),
-    request_id: z2.string(),
-    approve: z2.boolean(),
-    feedback: z2.string().optional()
-  })
+const structuredTeamMessageSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("shutdown_request"),
+		reason: z.string().optional()
+	}),
+	z.object({
+		type: z.literal("shutdown_response"),
+		request_id: z.string(),
+		approve: z.boolean(),
+		reason: z.string().optional()
+	}),
+	z.object({
+		type: z.literal("plan_approval_response"),
+		request_id: z.string(),
+		approve: z.boolean(),
+		feedback: z.string().optional()
+	})
 ]);
-var CLAUDE_CODE_BUILTIN_TOOLS = {
-  read: commonTool("read", {
-    nativeName: "Read",
-    toolUseKind: "readonly",
-    description: "Read file contents (text, image, PDF, notebook)",
-    inputSchema: z2.object({
-      file_path: z2.string(),
-      offset: z2.number().optional(),
-      limit: z2.number().optional(),
-      pages: z2.string().optional()
-    })
-  }),
-  write: commonTool("write", {
-    nativeName: "Write",
-    toolUseKind: "edit",
-    description: "Overwrite or create a file at an absolute path",
-    inputSchema: z2.object({
-      file_path: z2.string(),
-      content: z2.string()
-    })
-  }),
-  edit: commonTool("edit", {
-    nativeName: "Edit",
-    toolUseKind: "edit",
-    description: "Edit a file by exact string replacement",
-    inputSchema: z2.object({
-      file_path: z2.string(),
-      old_string: z2.string(),
-      new_string: z2.string(),
-      replace_all: z2.boolean().optional()
-    })
-  }),
-  bash: commonTool("bash", {
-    nativeName: "Bash",
-    toolUseKind: "bash",
-    description: "Execute a shell command, optionally in background",
-    inputSchema: z2.object({
-      command: z2.string(),
-      timeout: z2.number().optional(),
-      description: z2.string().optional(),
-      run_in_background: z2.boolean().optional(),
-      dangerouslyDisableSandbox: z2.boolean().optional()
-    })
-  }),
-  glob: commonTool("glob", {
-    nativeName: "Glob",
-    toolUseKind: "readonly",
-    description: "Fast file-pattern search using glob syntax",
-    inputSchema: z2.object({
-      pattern: z2.string(),
-      path: z2.string().optional()
-    })
-  }),
-  grep: commonTool("grep", {
-    nativeName: "Grep",
-    toolUseKind: "readonly",
-    description: "Regex search over file contents via ripgrep",
-    inputSchema: z2.object({
-      pattern: z2.string(),
-      path: z2.string().optional(),
-      glob: z2.string().optional(),
-      output_mode: z2.enum(["content", "files_with_matches", "count"]).optional(),
-      "-B": z2.number().optional(),
-      "-A": z2.number().optional(),
-      "-C": z2.number().optional(),
-      context: z2.number().optional(),
-      "-n": z2.boolean().optional(),
-      "-i": z2.boolean().optional(),
-      "-o": z2.boolean().optional(),
-      type: z2.string().optional(),
-      head_limit: z2.number().optional(),
-      offset: z2.number().optional(),
-      multiline: z2.boolean().optional()
-    })
-  }),
-  webSearch: commonTool("webSearch", {
-    nativeName: "WebSearch",
-    toolUseKind: "readonly",
-    description: "Issue web search queries with optional domain filters",
-    inputSchema: z2.object({
-      query: z2.string(),
-      allowed_domains: z2.array(z2.string()).optional(),
-      blocked_domains: z2.array(z2.string()).optional()
-    })
-  }),
-  WebFetch: tool({
-    description: "Fetch a URL and run a prompt against its content",
-    inputSchema: z2.object({
-      url: z2.string(),
-      prompt: z2.string()
-    })
-  }),
-  NotebookEdit: tool({
-    description: "Edit, insert, or delete a Jupyter notebook cell",
-    inputSchema: z2.object({
-      notebook_path: z2.string(),
-      new_source: z2.string(),
-      cell_id: z2.string().optional(),
-      cell_type: z2.enum(["code", "markdown"]).optional(),
-      edit_mode: z2.enum(["replace", "insert", "delete"]).optional()
-    })
-  }),
-  TodoWrite: tool({
-    description: "Replace the session todo list",
-    inputSchema: z2.object({
-      todos: z2.array(
-        z2.object({
-          content: z2.string(),
-          status: z2.enum(["pending", "in_progress", "completed"]),
-          activeForm: z2.string()
-        })
-      )
-    })
-  }),
-  Agent: tool({
-    description: "Spawn a subagent with a task",
-    inputSchema: z2.object({
-      description: z2.string(),
-      prompt: z2.string(),
-      subagent_type: z2.string().optional(),
-      model: z2.enum(["sonnet", "opus", "haiku"]).optional(),
-      run_in_background: z2.boolean().optional(),
-      name: z2.string().optional(),
-      team_name: z2.string().optional(),
-      mode: z2.enum([
-        "acceptEdits",
-        "auto",
-        "bypassPermissions",
-        "default",
-        "dontAsk",
-        "plan"
-      ]).optional(),
-      isolation: z2.literal("worktree").optional()
-    })
-  }),
-  TaskCreate: tool({
-    description: "Create a task in the session-local task list",
-    inputSchema: z2.object({
-      subject: z2.string(),
-      description: z2.string(),
-      activeForm: z2.string().optional(),
-      metadata: z2.record(z2.string(), z2.unknown()).optional()
-    })
-  }),
-  TaskGet: tool({
-    description: "Retrieve a task by id",
-    inputSchema: z2.object({ taskId: z2.string() })
-  }),
-  TaskUpdate: tool({
-    description: "Update fields of an existing task",
-    inputSchema: z2.object({
-      taskId: z2.string(),
-      subject: z2.string().optional(),
-      description: z2.string().optional(),
-      activeForm: z2.string().optional(),
-      status: z2.union([
-        z2.enum(["pending", "in_progress", "completed"]),
-        z2.literal("deleted")
-      ]).optional(),
-      addBlocks: z2.array(z2.string()).optional(),
-      addBlockedBy: z2.array(z2.string()).optional(),
-      owner: z2.string().optional(),
-      metadata: z2.record(z2.string(), z2.unknown()).optional()
-    })
-  }),
-  TaskList: tool({
-    description: "Return all tasks in the session-local task list",
-    inputSchema: z2.object({})
-  }),
-  TaskStop: tool({
-    description: "Stop a running background task by id",
-    inputSchema: z2.object({
-      task_id: z2.string().optional(),
-      shell_id: z2.string().optional()
-    })
-  }),
-  TaskOutput: tool({
-    description: "Poll for output from a background task",
-    inputSchema: z2.object({
-      task_id: z2.string(),
-      block: z2.boolean(),
-      timeout: z2.number()
-    })
-  }),
-  Monitor: {
-    ...tool({
-      description: "Run and monitor a shell command or WebSocket",
-      inputSchema: z2.object({
-        description: z2.string().optional(),
-        timeout_ms: z2.number().optional(),
-        persistent: z2.boolean().optional(),
-        command: z2.string().optional(),
-        ws: z2.object({
-          url: z2.string(),
-          protocols: z2.array(z2.string()).optional()
-        }).optional()
-      })
-    }),
-    toolUseKind: "bash"
-  },
-  ListMcpResources: {
-    ...tool({
-      description: "List resources available from MCP servers",
-      inputSchema: listMcpResourcesInputSchema
-    }),
-    toolUseKind: "readonly"
-  },
-  ListMcpResourcesTool: {
-    ...tool({
-      description: "List resources available from MCP servers",
-      inputSchema: listMcpResourcesInputSchema
-    }),
-    toolUseKind: "readonly"
-  },
-  ReadMcpResource: {
-    ...tool({
-      description: "Read a specific MCP resource by URI",
-      inputSchema: readMcpResourceInputSchema
-    }),
-    toolUseKind: "readonly"
-  },
-  ReadMcpResourceTool: {
-    ...tool({
-      description: "Read a specific MCP resource by URI",
-      inputSchema: readMcpResourceInputSchema
-    }),
-    toolUseKind: "readonly"
-  },
-  ReadMcpResourceDirTool: {
-    ...tool({
-      description: "List direct children of an MCP directory resource",
-      inputSchema: readMcpResourceInputSchema
-    }),
-    toolUseKind: "readonly"
-  },
-  RefreshMcpTools: {
-    ...tool({
-      description: "Refresh tools from one or all connected MCP servers",
-      inputSchema: z2.object({ server: z2.string().optional() })
-    }),
-    toolUseKind: "readonly"
-  },
-  ExitPlanMode: tool({
-    description: "Exit plan mode with optional permission approvals",
-    inputSchema: z2.looseObject({
-      allowedPrompts: z2.array(
-        z2.object({
-          tool: z2.literal("Bash"),
-          prompt: z2.string()
-        })
-      ).optional()
-    })
-  }),
-  EnterPlanMode: {
-    ...tool({
-      description: "Enter plan mode",
-      inputSchema: z2.object({})
-    }),
-    toolUseKind: "readonly"
-  },
-  EnterWorktree: tool({
-    description: "Create or enter an isolated git worktree",
-    inputSchema: z2.object({
-      name: z2.string().optional(),
-      path: z2.string().optional()
-    })
-  }),
-  ExitWorktree: tool({
-    description: "Exit the current worktree session",
-    inputSchema: z2.object({
-      action: z2.enum(["keep", "remove"]),
-      discard_changes: z2.boolean().optional()
-    })
-  }),
-  askUserQuestions: {
-    ...HARNESS_V1_BUILTIN_TOOLS.askUserQuestions,
-    nativeName: "AskUserQuestion",
-    toolUseKind: "readonly"
-  },
-  Skill: {
-    ...tool({
-      description: "Activate a skill by name",
-      inputSchema: z2.object({
-        skill: z2.string(),
-        args: z2.string().optional()
-      })
-    }),
-    toolUseKind: "readonly"
-  },
-  ToolSearch: tool({
-    description: "Search deferred MCP / catalog tools so the model can load them on demand",
-    inputSchema: z2.object({
-      query: z2.string(),
-      max_results: z2.number().optional()
-    })
-  }),
-  Artifact: {
-    ...tool({
-      description: "Publish or list claude.ai artifacts",
-      inputSchema: z2.object({
-        action: z2.enum(["publish", "list"]).optional(),
-        file_path: z2.string().optional(),
-        favicon: z2.string().optional(),
-        limit: z2.number().optional(),
-        scope: z2.enum(["mine", "shared", "all"]).optional(),
-        title: z2.string().optional(),
-        description: z2.string().optional(),
-        label: z2.string().optional(),
-        url: z2.string().optional(),
-        force: z2.boolean().optional()
-      })
-    }),
-    toolUseKind: "edit"
-  },
-  CronCreate: {
-    ...tool({
-      description: "Schedule a recurring or one-shot prompt",
-      inputSchema: z2.object({
-        cron: z2.string(),
-        prompt: z2.string(),
-        recurring: z2.boolean().optional(),
-        durable: z2.boolean().optional()
-      })
-    }),
-    toolUseKind: "edit"
-  },
-  CronDelete: {
-    ...tool({
-      description: "Delete a scheduled prompt by id",
-      inputSchema: z2.object({ id: z2.string() })
-    }),
-    toolUseKind: "edit"
-  },
-  CronList: {
-    ...tool({
-      description: "List scheduled prompts for the current session",
-      inputSchema: z2.object({})
-    }),
-    toolUseKind: "readonly"
-  },
-  DesignSync: {
-    ...tool({
-      description: "Read or update claude.ai Design projects",
-      inputSchema: z2.object({
-        method: z2.enum([
-          "list_projects",
-          "get_project",
-          "list_files",
-          "get_file",
-          "finalize_plan",
-          "write_files",
-          "delete_files",
-          "register_assets",
-          "unregister_assets",
-          "create_project",
-          "report_validate"
-        ]),
-        projectId: z2.string().optional(),
-        path: z2.string().optional(),
-        writes: z2.array(z2.string()).max(256).optional(),
-        deletes: z2.array(z2.string()).max(256).optional(),
-        planId: z2.string().optional(),
-        files: z2.array(
-          z2.object({
-            path: z2.string(),
-            localPath: z2.string().optional(),
-            data: z2.string().optional(),
-            encoding: z2.literal("base64").optional(),
-            mimeType: z2.string().optional()
-          })
-        ).max(256).optional(),
-        paths: z2.array(z2.string()).max(256).optional(),
-        name: z2.string().optional(),
-        assets: z2.array(
-          z2.object({
-            name: z2.string(),
-            path: z2.string(),
-            subtitle: z2.string().optional(),
-            viewport: z2.object({
-              width: z2.number(),
-              height: z2.number().optional()
-            }).optional(),
-            group: z2.string().optional()
-          })
-        ).max(256).optional(),
-        localDir: z2.string().optional(),
-        counts: z2.object({
-          total: z2.number(),
-          bad: z2.number(),
-          thin: z2.number(),
-          variantsIdentical: z2.number(),
-          iterations: z2.number()
-        }).optional()
-      })
-    }),
-    toolUseKind: "edit"
-  },
-  LSP: {
-    ...tool({
-      description: "Query a language server for code intelligence",
-      inputSchema: z2.object({
-        operation: z2.enum([
-          "goToDefinition",
-          "findReferences",
-          "hover",
-          "documentSymbol",
-          "workspaceSymbol",
-          "goToImplementation",
-          "prepareCallHierarchy",
-          "incomingCalls",
-          "outgoingCalls"
-        ]),
-        filePath: z2.string(),
-        line: z2.number().int().positive(),
-        character: z2.number().int().positive(),
-        query: z2.string().optional()
-      })
-    }),
-    toolUseKind: "readonly"
-  },
-  PowerShell: {
-    ...tool({
-      description: "Execute a PowerShell command, optionally in background",
-      inputSchema: z2.object({
-        command: z2.string(),
-        timeout: z2.number().optional(),
-        description: z2.string().optional(),
-        run_in_background: z2.boolean().optional(),
-        dangerouslyDisableSandbox: z2.boolean().optional()
-      })
-    }),
-    toolUseKind: "bash"
-  },
-  PushNotification: {
-    ...tool({
-      description: "Send a notification for proactive or scheduled work",
-      inputSchema: z2.object({
-        message: z2.string(),
-        status: z2.literal("proactive")
-      })
-    }),
-    toolUseKind: "edit"
-  },
-  RemoteTrigger: {
-    ...tool({
-      description: "List, manage, or run a claude.ai Routine trigger",
-      inputSchema: z2.object({
-        action: z2.enum(["list", "get", "create", "update", "run"]),
-        trigger_id: z2.string().optional(),
-        body: z2.record(z2.string(), z2.unknown()).optional()
-      })
-    }),
-    toolUseKind: "edit"
-  },
-  ReportFindings: {
-    ...tool({
-      description: "Return verified code-review findings",
-      inputSchema: z2.object({
-        level: z2.enum(["low", "medium", "high", "xhigh", "max"]).optional(),
-        findings: z2.array(
-          z2.object({
-            file: z2.string(),
-            line: z2.number().optional(),
-            summary: z2.string(),
-            short_summary: z2.string().optional(),
-            failure_scenario: z2.string(),
-            category: z2.string().optional(),
-            verdict: z2.enum(["CONFIRMED", "PLAUSIBLE"]).optional(),
-            outcome: z2.enum(["fixed", "skipped", "no_change_needed"]).optional()
-          })
-        ).max(32)
-      })
-    }),
-    toolUseKind: "readonly"
-  },
-  ScheduleWakeup: {
-    ...tool({
-      description: "Schedule or stop the next iteration of a dynamic loop",
-      inputSchema: z2.object({
-        delaySeconds: z2.number().optional(),
-        reason: z2.string().optional(),
-        prompt: z2.string().optional(),
-        stop: z2.boolean().optional()
-      })
-    }),
-    toolUseKind: "edit"
-  },
-  SendMessage: {
-    ...tool({
-      description: "Send a plain-text or protocol message to another agent",
-      inputSchema: z2.object({
-        to: z2.string(),
-        summary: z2.string().max(200).optional(),
-        message: z2.union([z2.string(), structuredTeamMessageSchema])
-      })
-    }),
-    toolUseKind: "edit"
-  },
-  SendUserFile: {
-    ...tool({
-      description: "Send one or more files to the user",
-      inputSchema: z2.object({
-        files: z2.union([z2.string(), z2.array(z2.string()).min(1)]),
-        caption: z2.string().optional(),
-        status: z2.enum(["normal", "proactive"]),
-        display: z2.enum(["render", "attach"]).optional()
-      })
-    }),
-    toolUseKind: "readonly"
-  },
-  ShareOnboardingGuide: {
-    ...tool({
-      description: "Create, update, inspect, or delete an onboarding guide",
-      inputSchema: z2.object({
-        mode: z2.enum(["check", "update", "create", "delete"]).optional(),
-        short_code: z2.string().regex(/^[A-Za-z0-9_-]{1,64}$/).optional()
-      })
-    }),
-    toolUseKind: "edit"
-  },
-  WaitForMcpServers: {
-    ...tool({
-      description: "Wait for MCP servers that are still connecting",
-      inputSchema: z2.object({
-        servers: z2.array(z2.string()).optional()
-      })
-    }),
-    toolUseKind: "readonly"
-  },
-  Workflow: {
-    ...tool({
-      description: "Run or resume a dynamic multi-agent workflow",
-      inputSchema: z2.object({
-        script: z2.string().optional(),
-        name: z2.string().optional(),
-        description: z2.string().optional(),
-        title: z2.string().optional(),
-        args: z2.record(z2.string(), z2.unknown()).optional(),
-        scriptPath: z2.string().optional(),
-        resumeFromRunId: z2.string().optional()
-      })
-    }),
-    toolUseKind: "edit"
-  }
+const CLAUDE_CODE_BUILTIN_TOOLS = {
+	read: commonTool("read", {
+		nativeName: "Read",
+		toolUseKind: "readonly",
+		description: "Read file contents (text, image, PDF, notebook)",
+		inputSchema: z.object({
+			file_path: z.string(),
+			offset: z.number().optional(),
+			limit: z.number().optional(),
+			pages: z.string().optional()
+		})
+	}),
+	write: commonTool("write", {
+		nativeName: "Write",
+		toolUseKind: "edit",
+		description: "Overwrite or create a file at an absolute path",
+		inputSchema: z.object({
+			file_path: z.string(),
+			content: z.string()
+		})
+	}),
+	edit: commonTool("edit", {
+		nativeName: "Edit",
+		toolUseKind: "edit",
+		description: "Edit a file by exact string replacement",
+		inputSchema: z.object({
+			file_path: z.string(),
+			old_string: z.string(),
+			new_string: z.string(),
+			replace_all: z.boolean().optional()
+		})
+	}),
+	bash: commonTool("bash", {
+		nativeName: "Bash",
+		toolUseKind: "bash",
+		description: "Execute a shell command, optionally in background",
+		inputSchema: z.object({
+			command: z.string(),
+			timeout: z.number().optional(),
+			description: z.string().optional(),
+			run_in_background: z.boolean().optional(),
+			dangerouslyDisableSandbox: z.boolean().optional()
+		})
+	}),
+	glob: commonTool("glob", {
+		nativeName: "Glob",
+		toolUseKind: "readonly",
+		description: "Fast file-pattern search using glob syntax",
+		inputSchema: z.object({
+			pattern: z.string(),
+			path: z.string().optional()
+		})
+	}),
+	grep: commonTool("grep", {
+		nativeName: "Grep",
+		toolUseKind: "readonly",
+		description: "Regex search over file contents via ripgrep",
+		inputSchema: z.object({
+			pattern: z.string(),
+			path: z.string().optional(),
+			glob: z.string().optional(),
+			output_mode: z.enum([
+				"content",
+				"files_with_matches",
+				"count"
+			]).optional(),
+			"-B": z.number().optional(),
+			"-A": z.number().optional(),
+			"-C": z.number().optional(),
+			context: z.number().optional(),
+			"-n": z.boolean().optional(),
+			"-i": z.boolean().optional(),
+			"-o": z.boolean().optional(),
+			type: z.string().optional(),
+			head_limit: z.number().optional(),
+			offset: z.number().optional(),
+			multiline: z.boolean().optional()
+		})
+	}),
+	webSearch: commonTool("webSearch", {
+		nativeName: "WebSearch",
+		toolUseKind: "readonly",
+		description: "Issue web search queries with optional domain filters",
+		inputSchema: z.object({
+			query: z.string(),
+			allowed_domains: z.array(z.string()).optional(),
+			blocked_domains: z.array(z.string()).optional()
+		})
+	}),
+	WebFetch: tool({
+		description: "Fetch a URL and run a prompt against its content",
+		inputSchema: z.object({
+			url: z.string(),
+			prompt: z.string()
+		})
+	}),
+	NotebookEdit: tool({
+		description: "Edit, insert, or delete a Jupyter notebook cell",
+		inputSchema: z.object({
+			notebook_path: z.string(),
+			new_source: z.string(),
+			cell_id: z.string().optional(),
+			cell_type: z.enum(["code", "markdown"]).optional(),
+			edit_mode: z.enum([
+				"replace",
+				"insert",
+				"delete"
+			]).optional()
+		})
+	}),
+	TodoWrite: tool({
+		description: "Replace the session todo list",
+		inputSchema: z.object({ todos: z.array(z.object({
+			content: z.string(),
+			status: z.enum([
+				"pending",
+				"in_progress",
+				"completed"
+			]),
+			activeForm: z.string()
+		})) })
+	}),
+	Agent: tool({
+		description: "Spawn a subagent with a task",
+		inputSchema: z.object({
+			description: z.string(),
+			prompt: z.string(),
+			subagent_type: z.string().optional(),
+			model: z.enum([
+				"sonnet",
+				"opus",
+				"haiku"
+			]).optional(),
+			run_in_background: z.boolean().optional(),
+			name: z.string().optional(),
+			team_name: z.string().optional(),
+			mode: z.enum([
+				"acceptEdits",
+				"auto",
+				"bypassPermissions",
+				"default",
+				"dontAsk",
+				"plan"
+			]).optional(),
+			isolation: z.literal("worktree").optional()
+		})
+	}),
+	TaskCreate: tool({
+		description: "Create a task in the session-local task list",
+		inputSchema: z.object({
+			subject: z.string(),
+			description: z.string(),
+			activeForm: z.string().optional(),
+			metadata: z.record(z.string(), z.unknown()).optional()
+		})
+	}),
+	TaskGet: tool({
+		description: "Retrieve a task by id",
+		inputSchema: z.object({ taskId: z.string() })
+	}),
+	TaskUpdate: tool({
+		description: "Update fields of an existing task",
+		inputSchema: z.object({
+			taskId: z.string(),
+			subject: z.string().optional(),
+			description: z.string().optional(),
+			activeForm: z.string().optional(),
+			status: z.union([z.enum([
+				"pending",
+				"in_progress",
+				"completed"
+			]), z.literal("deleted")]).optional(),
+			addBlocks: z.array(z.string()).optional(),
+			addBlockedBy: z.array(z.string()).optional(),
+			owner: z.string().optional(),
+			metadata: z.record(z.string(), z.unknown()).optional()
+		})
+	}),
+	TaskList: tool({
+		description: "Return all tasks in the session-local task list",
+		inputSchema: z.object({})
+	}),
+	TaskStop: tool({
+		description: "Stop a running background task by id",
+		inputSchema: z.object({
+			task_id: z.string().optional(),
+			shell_id: z.string().optional()
+		})
+	}),
+	TaskOutput: tool({
+		description: "Poll for output from a background task",
+		inputSchema: z.object({
+			task_id: z.string(),
+			block: z.boolean(),
+			timeout: z.number()
+		})
+	}),
+	Monitor: {
+		...tool({
+			description: "Run and monitor a shell command or WebSocket",
+			inputSchema: z.object({
+				description: z.string().optional(),
+				timeout_ms: z.number().optional(),
+				persistent: z.boolean().optional(),
+				command: z.string().optional(),
+				ws: z.object({
+					url: z.string(),
+					protocols: z.array(z.string()).optional()
+				}).optional()
+			})
+		}),
+		toolUseKind: "bash"
+	},
+	ListMcpResources: {
+		...tool({
+			description: "List resources available from MCP servers",
+			inputSchema: listMcpResourcesInputSchema
+		}),
+		toolUseKind: "readonly"
+	},
+	ListMcpResourcesTool: {
+		...tool({
+			description: "List resources available from MCP servers",
+			inputSchema: listMcpResourcesInputSchema
+		}),
+		toolUseKind: "readonly"
+	},
+	ReadMcpResource: {
+		...tool({
+			description: "Read a specific MCP resource by URI",
+			inputSchema: readMcpResourceInputSchema
+		}),
+		toolUseKind: "readonly"
+	},
+	ReadMcpResourceTool: {
+		...tool({
+			description: "Read a specific MCP resource by URI",
+			inputSchema: readMcpResourceInputSchema
+		}),
+		toolUseKind: "readonly"
+	},
+	ReadMcpResourceDirTool: {
+		...tool({
+			description: "List direct children of an MCP directory resource",
+			inputSchema: readMcpResourceInputSchema
+		}),
+		toolUseKind: "readonly"
+	},
+	RefreshMcpTools: {
+		...tool({
+			description: "Refresh tools from one or all connected MCP servers",
+			inputSchema: z.object({ server: z.string().optional() })
+		}),
+		toolUseKind: "readonly"
+	},
+	ExitPlanMode: tool({
+		description: "Exit plan mode with optional permission approvals",
+		inputSchema: z.looseObject({ allowedPrompts: z.array(z.object({
+			tool: z.literal("Bash"),
+			prompt: z.string()
+		})).optional() })
+	}),
+	EnterPlanMode: {
+		...tool({
+			description: "Enter plan mode",
+			inputSchema: z.object({})
+		}),
+		toolUseKind: "readonly"
+	},
+	EnterWorktree: tool({
+		description: "Create or enter an isolated git worktree",
+		inputSchema: z.object({
+			name: z.string().optional(),
+			path: z.string().optional()
+		})
+	}),
+	ExitWorktree: tool({
+		description: "Exit the current worktree session",
+		inputSchema: z.object({
+			action: z.enum(["keep", "remove"]),
+			discard_changes: z.boolean().optional()
+		})
+	}),
+	askUserQuestions: {
+		...HARNESS_V1_BUILTIN_TOOLS.askUserQuestions,
+		nativeName: "AskUserQuestion",
+		toolUseKind: "readonly"
+	},
+	Skill: {
+		...tool({
+			description: "Activate a skill by name",
+			inputSchema: z.object({
+				skill: z.string(),
+				args: z.string().optional()
+			})
+		}),
+		toolUseKind: "readonly"
+	},
+	ToolSearch: tool({
+		description: "Search deferred MCP / catalog tools so the model can load them on demand",
+		inputSchema: z.object({
+			query: z.string(),
+			max_results: z.number().optional()
+		})
+	}),
+	Artifact: {
+		...tool({
+			description: "Publish or list claude.ai artifacts",
+			inputSchema: z.object({
+				action: z.enum(["publish", "list"]).optional(),
+				file_path: z.string().optional(),
+				favicon: z.string().optional(),
+				limit: z.number().optional(),
+				scope: z.enum([
+					"mine",
+					"shared",
+					"all"
+				]).optional(),
+				title: z.string().optional(),
+				description: z.string().optional(),
+				label: z.string().optional(),
+				url: z.string().optional(),
+				force: z.boolean().optional()
+			})
+		}),
+		toolUseKind: "edit"
+	},
+	CronCreate: {
+		...tool({
+			description: "Schedule a recurring or one-shot prompt",
+			inputSchema: z.object({
+				cron: z.string(),
+				prompt: z.string(),
+				recurring: z.boolean().optional(),
+				durable: z.boolean().optional()
+			})
+		}),
+		toolUseKind: "edit"
+	},
+	CronDelete: {
+		...tool({
+			description: "Delete a scheduled prompt by id",
+			inputSchema: z.object({ id: z.string() })
+		}),
+		toolUseKind: "edit"
+	},
+	CronList: {
+		...tool({
+			description: "List scheduled prompts for the current session",
+			inputSchema: z.object({})
+		}),
+		toolUseKind: "readonly"
+	},
+	DesignSync: {
+		...tool({
+			description: "Read or update claude.ai Design projects",
+			inputSchema: z.object({
+				method: z.enum([
+					"list_projects",
+					"get_project",
+					"list_files",
+					"get_file",
+					"finalize_plan",
+					"write_files",
+					"delete_files",
+					"register_assets",
+					"unregister_assets",
+					"create_project",
+					"report_validate"
+				]),
+				projectId: z.string().optional(),
+				path: z.string().optional(),
+				writes: z.array(z.string()).max(256).optional(),
+				deletes: z.array(z.string()).max(256).optional(),
+				planId: z.string().optional(),
+				files: z.array(z.object({
+					path: z.string(),
+					localPath: z.string().optional(),
+					data: z.string().optional(),
+					encoding: z.literal("base64").optional(),
+					mimeType: z.string().optional()
+				})).max(256).optional(),
+				paths: z.array(z.string()).max(256).optional(),
+				name: z.string().optional(),
+				assets: z.array(z.object({
+					name: z.string(),
+					path: z.string(),
+					subtitle: z.string().optional(),
+					viewport: z.object({
+						width: z.number(),
+						height: z.number().optional()
+					}).optional(),
+					group: z.string().optional()
+				})).max(256).optional(),
+				localDir: z.string().optional(),
+				counts: z.object({
+					total: z.number(),
+					bad: z.number(),
+					thin: z.number(),
+					variantsIdentical: z.number(),
+					iterations: z.number()
+				}).optional()
+			})
+		}),
+		toolUseKind: "edit"
+	},
+	LSP: {
+		...tool({
+			description: "Query a language server for code intelligence",
+			inputSchema: z.object({
+				operation: z.enum([
+					"goToDefinition",
+					"findReferences",
+					"hover",
+					"documentSymbol",
+					"workspaceSymbol",
+					"goToImplementation",
+					"prepareCallHierarchy",
+					"incomingCalls",
+					"outgoingCalls"
+				]),
+				filePath: z.string(),
+				line: z.number().int().positive(),
+				character: z.number().int().positive(),
+				query: z.string().optional()
+			})
+		}),
+		toolUseKind: "readonly"
+	},
+	PowerShell: {
+		...tool({
+			description: "Execute a PowerShell command, optionally in background",
+			inputSchema: z.object({
+				command: z.string(),
+				timeout: z.number().optional(),
+				description: z.string().optional(),
+				run_in_background: z.boolean().optional(),
+				dangerouslyDisableSandbox: z.boolean().optional()
+			})
+		}),
+		toolUseKind: "bash"
+	},
+	PushNotification: {
+		...tool({
+			description: "Send a notification for proactive or scheduled work",
+			inputSchema: z.object({
+				message: z.string(),
+				status: z.literal("proactive")
+			})
+		}),
+		toolUseKind: "edit"
+	},
+	RemoteTrigger: {
+		...tool({
+			description: "List, manage, or run a claude.ai Routine trigger",
+			inputSchema: z.object({
+				action: z.enum([
+					"list",
+					"get",
+					"create",
+					"update",
+					"run"
+				]),
+				trigger_id: z.string().optional(),
+				body: z.record(z.string(), z.unknown()).optional()
+			})
+		}),
+		toolUseKind: "edit"
+	},
+	ReportFindings: {
+		...tool({
+			description: "Return verified code-review findings",
+			inputSchema: z.object({
+				level: z.enum([
+					"low",
+					"medium",
+					"high",
+					"xhigh",
+					"max"
+				]).optional(),
+				findings: z.array(z.object({
+					file: z.string(),
+					line: z.number().optional(),
+					summary: z.string(),
+					short_summary: z.string().optional(),
+					failure_scenario: z.string(),
+					category: z.string().optional(),
+					verdict: z.enum(["CONFIRMED", "PLAUSIBLE"]).optional(),
+					outcome: z.enum([
+						"fixed",
+						"skipped",
+						"no_change_needed"
+					]).optional()
+				})).max(32)
+			})
+		}),
+		toolUseKind: "readonly"
+	},
+	ScheduleWakeup: {
+		...tool({
+			description: "Schedule or stop the next iteration of a dynamic loop",
+			inputSchema: z.object({
+				delaySeconds: z.number().optional(),
+				reason: z.string().optional(),
+				prompt: z.string().optional(),
+				stop: z.boolean().optional()
+			})
+		}),
+		toolUseKind: "edit"
+	},
+	SendMessage: {
+		...tool({
+			description: "Send a plain-text or protocol message to another agent",
+			inputSchema: z.object({
+				to: z.string(),
+				summary: z.string().max(200).optional(),
+				message: z.union([z.string(), structuredTeamMessageSchema])
+			})
+		}),
+		toolUseKind: "edit"
+	},
+	SendUserFile: {
+		...tool({
+			description: "Send one or more files to the user",
+			inputSchema: z.object({
+				files: z.union([z.string(), z.array(z.string()).min(1)]),
+				caption: z.string().optional(),
+				status: z.enum(["normal", "proactive"]),
+				display: z.enum(["render", "attach"]).optional()
+			})
+		}),
+		toolUseKind: "readonly"
+	},
+	ShareOnboardingGuide: {
+		...tool({
+			description: "Create, update, inspect, or delete an onboarding guide",
+			inputSchema: z.object({
+				mode: z.enum([
+					"check",
+					"update",
+					"create",
+					"delete"
+				]).optional(),
+				short_code: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/).optional()
+			})
+		}),
+		toolUseKind: "edit"
+	},
+	WaitForMcpServers: {
+		...tool({
+			description: "Wait for MCP servers that are still connecting",
+			inputSchema: z.object({ servers: z.array(z.string()).optional() })
+		}),
+		toolUseKind: "readonly"
+	},
+	Workflow: {
+		...tool({
+			description: "Run or resume a dynamic multi-agent workflow",
+			inputSchema: z.object({
+				script: z.string().optional(),
+				name: z.string().optional(),
+				description: z.string().optional(),
+				title: z.string().optional(),
+				args: z.record(z.string(), z.unknown()).optional(),
+				scriptPath: z.string().optional(),
+				resumeFromRunId: z.string().optional()
+			})
+		}),
+		toolUseKind: "edit"
+	}
 };
-var claudeCodeBridgeCoordsSchema = z2.object({
-  port: z2.number(),
-  token: z2.string(),
-  lastSeenEventId: z2.number(),
-  sandboxId: z2.string().optional()
+/**
+* Live bridge coordinates returned by `doDetach()` and `doSuspendTurn()`. A
+* future process uses them to reopen a socket to the still-running bridge
+* (`attach`) instead of re-spawning it. Absent on a `doStop()` payload.
+*/
+const claudeCodeBridgeCoordsSchema = z.object({
+	port: z.number(),
+	token: z.string(),
+	lastSeenEventId: z.number(),
+	sandboxId: z.string().optional()
 });
-var claudeCodeResumeStateSchema = z2.looseObject({
-  bridge: claudeCodeBridgeCoordsSchema.optional(),
-  sandboxCredentialEnvironment: z2.record(z2.string(), z2.string()).optional(),
-  /**
-   * The exact Claude conversation to rehydrate on resume. Written by the
-   * adapter on `doStop()`/`doDetach()`/`doSuspendTurn()` from the session id
-   * the bridge observed, so a resume names the conversation instead of
-   * relying on the SDK's `continue` flag — "most recent thread in this
-   * workdir" — which silently picks the wrong one once a second thread
-   * exists there. Hosts that captured the id themselves (it is surfaced as
-   * `harnessMetadata['claude-code'].sessionId` on `finish` parts) may also
-   * set it explicitly.
-   */
-  claudeSessionId: z2.string().optional()
+/**
+* Schema for the adapter-specific portion of lifecycle state `data`.
+*
+* A `doStop()` payload is structurally empty (`{}`): the framework derives the
+* sandbox via `provider.resumeSession({ sessionId })`, and the Claude SDK's
+* `{ continue: true }` flag rehydrates the thread from the workdir. A
+* `doDetach()` payload additionally carries `bridge` coordinates for
+* cross-process `attach`. A loose object keeps both shapes valid.
+*/
+const claudeCodeResumeStateSchema = z.looseObject({
+	bridge: claudeCodeBridgeCoordsSchema.optional(),
+	sandboxCredentialEnvironment: z.record(z.string(), z.string()).optional(),
+	/**
+	* The exact Claude conversation to rehydrate on resume. Written by the
+	* adapter on `doStop()`/`doDetach()`/`doSuspendTurn()` from the session id
+	* the bridge observed, so a resume names the conversation instead of
+	* relying on the SDK's `continue` flag — "most recent thread in this
+	* workdir" — which silently picks the wrong one once a second thread
+	* exists there. Hosts that captured the id themselves (it is surfaced as
+	* `harnessMetadata['claude-code'].sessionId` on `finish` parts) may also
+	* set it explicitly.
+	*/
+	claudeSessionId: z.string().optional()
 });
 function createClaudeCode(settings = {}) {
-  if (settings.mcpServers != null && Object.prototype.hasOwnProperty.call(settings.mcpServers, "harness-tools")) {
-    throw new Error(
-      'Claude Code MCP server name "harness-tools" is reserved for HarnessAgent tools.'
-    );
-  }
-  const thinking = settings.thinking ?? {
-    type: "adaptive",
-    display: "summarized"
-  };
-  return {
-    specificationVersion: "harness-v1",
-    harnessId: "claude-code",
-    builtinTools: CLAUDE_CODE_BUILTIN_TOOLS,
-    supportsBuiltinToolApprovals: true,
-    supportsBuiltinToolFiltering: true,
-    lifecycleStateSchema: claudeCodeResumeStateSchema,
-    getBootstrap: getClaudeCodeBootstrap,
-    doStart: async (startOpts) => {
-      const sandboxSession = startOpts.sandboxSession;
-      const toolSafeSandboxSession = getRestrictedSandboxSession(sandboxSession);
-      const sandboxId = "id" in sandboxSession ? sandboxSession.id : void 0;
-      validateBasicSandboxSettings({
-        sandboxSession,
-        port: settings.port,
-        portEndpoint: settings.portEndpoint
-      });
-      if (settings.mintBridgeToken != null && sandboxId == null) {
-        throw new HarnessCapabilityUnsupportedError({
-          harnessId: "claude-code",
-          message: "The Claude Code harness cannot use `mintBridgeToken` with a sandbox session that does not expose an id."
-        });
-      }
-      const lifecycleState = startOpts.continueFrom ?? startOpts.resumeFrom;
-      const isResume = lifecycleState != null;
-      const isContinue = startOpts.continueFrom != null;
-      const resumeData = isResume ? lifecycleState?.data : void 0;
-      const coords = resumeData?.bridge;
-      const authenticationMode = resolveClaudeCodeAuthenticationMode(
-        settings.auth
-      );
-      const resolvedAuthEnvironment = await resolveClaudeCodeAuthentication({
-        auth: settings.auth
-      });
-      const claudeEnvironment = {
-        ...resolvedAuthEnvironment,
-        /*
-         * The Claude Agent SDK does not expose arbitrary model-request
-         * headers. It reads this environment variable and sends the value as
-         * `x-client-app`, while also appending `client-app/<value>` to
-         * `User-Agent`, so this is the attribution path for AI Gateway.
-         */
-        ...resolvedAuthEnvironment.AI_GATEWAY_BASE_URL ? { CLAUDE_AGENT_SDK_CLIENT_APP: CLAUDE_CODE_CLIENT_APP } : {},
-        ...settings.env,
-        ...startOpts.headers != null ? {
-          ANTHROPIC_CUSTOM_HEADERS: Object.entries(startOpts.headers).map(([name, value]) => `${name}: ${value}`).join("\n")
-        } : {}
-      };
-      let sandboxClaudeEnvironment = claudeEnvironment;
-      let sandboxCredentialEnvironment;
-      if ("addRequestTransformations" in sandboxSession && sandboxSession.addRequestTransformations != null) {
-        sandboxCredentialEnvironment = await resolveSandboxCredentialEnvironment({
-          environment: claudeEnvironment,
-          credentialEnvironmentVariables: CLAUDE_CODE_CREDENTIAL_ENVIRONMENT_VARIABLES,
-          credentialForwarding: settings.credentialForwarding,
-          previousSandboxCredentialEnvironment: resumeData?.sandboxCredentialEnvironment
-        });
-        sandboxClaudeEnvironment = {
-          ...claudeEnvironment,
-          ...sandboxCredentialEnvironment
-        };
-        const transformationSources = {
-          env: claudeEnvironment,
-          sandboxEnv: sandboxClaudeEnvironment,
-          auth: authenticationMode
-        };
-        const requestTransformations = [
-          ...createClaudeCodeRequestTransformations(transformationSources),
-          ...createClaudeCodeSubscriptionRequestTransformations(
-            transformationSources
-          )
-        ];
-        if (requestTransformations.length > 0) {
-          await sandboxSession.addRequestTransformations(
-            requestTransformations
-          );
-        }
-      } else {
-        sandboxClaudeEnvironment = await applyCredentialForwarding({
-          environment: sandboxClaudeEnvironment,
-          credentialEnvironmentVariables: CLAUDE_CODE_CREDENTIAL_ENVIRONMENT_VARIABLES,
-          credentialForwarding: settings.credentialForwarding
-        });
-        warnCredentialBrokeringUnavailable({
-          environment: claudeEnvironment,
-          forwardedEnvironment: sandboxClaudeEnvironment,
-          credentialEnvironmentVariables: CLAUDE_CODE_CREDENTIAL_ENVIRONMENT_VARIABLES
-        });
-      }
-      const sandboxHomeDir = await resolveSandboxHomeDir({
-        sandbox: toolSafeSandboxSession,
-        abortSignal: startOpts.abortSignal
-      });
-      const stateDir = harnessStateDirectoryPath({ sandboxHomeDir });
-      const bootstrapDir = posix.resolve(stateDir, CLAUDE_CODE_BOOTSTRAP_DIR);
-      const resumeSessionId = resumeData?.claudeSessionId;
-      const workDir = startOpts.sessionWorkDir;
-      const sessionDataDir = harnessSessionDataDirectoryPath({
-        stateDirectory: stateDir,
-        sessionId: startOpts.sessionId
-      });
-      const bridgeStateDir = `${sessionDataDir}/bridge`;
-      const timeoutMs = settings.startupTimeoutMs ?? 12e4;
-      const report = startOpts.observability?.report;
-      const onDiagnostic = report ? (frame) => report(
-        harnessV1DiagnosticFromBridgeFrame(frame, {
-          sessionId: startOpts.sessionId,
-          timestamp: Date.now()
-        })
-      ) : void 0;
-      const onBridgeError = createBridgeErrorHandler({
-        harnessId: "claude-code",
-        sessionId: startOpts.sessionId
-      });
-      let supportsUserMessageResponses = false;
-      const buildConnect = (endpoint2) => async ({
-        abortSignal
-      }) => {
-        return openBridgeWebSocket({
-          endpoint: endpoint2,
-          timeoutMs,
-          abortSignal,
-          onHello: (supportsResponses) => {
-            supportsUserMessageResponses = supportsResponses;
-          }
-        });
-      };
-      if (coords) {
-        try {
-          const endpoint2 = await resolveBridgeEndpoint({
-            sandboxSession,
-            override: settings.portEndpoint,
-            port: coords.port
-          });
-          const attachEndpoint = withBridgeToken({
-            endpoint: endpoint2,
-            token: coords.token
-          });
-          const attachChannel = new SandboxChannel({
-            connect: buildConnect(attachEndpoint),
-            outboundSchema: outboundMessageSchema,
-            initialLastSeenEventId: coords.lastSeenEventId,
-            onDiagnostic,
-            onBridgeError,
-            reconnect: settings.reconnect
-          });
-          const finishListenerAttachment2 = isContinue ? attachChannel.beginListenerAttachment() : void 0;
-          try {
-            await attachChannel.open(isContinue ? { resume: true } : void 0);
-          } catch (error) {
-            finishListenerAttachment2?.();
-            throw error;
-          }
-          return createSession({
-            sessionId: startOpts.sessionId,
-            channel: attachChannel,
-            finishListenerAttachment: finishListenerAttachment2,
-            ...resumeSessionId ? { resumeSessionId } : {},
-            // The live bridge was spawned by another process; this one owns no
-            // process handle. The session lifecycle method decides whether the
-            // sandbox is left running, stopped, or destroyed.
-            proc: void 0,
-            maxTurns: settings.maxTurns,
-            env: sandboxClaudeEnvironment,
-            thinking,
-            effort: settings.effort,
-            isResume: true,
-            continueOnFirstPrompt: false,
-            rerunContinue: false,
-            bridgePort: coords.port,
-            bridgeToken: coords.token,
-            sandboxId,
-            sandboxCredentialEnvironment,
-            debug: startOpts.observability?.debug,
-            permissionMode: startOpts.permissionMode,
-            builtinToolFiltering: startOpts.builtinToolFiltering,
-            sandbox: toolSafeSandboxSession,
-            sandboxHomeDir,
-            mcpServers: settings.mcpServers,
-            supportsUserMessageResponses: () => supportsUserMessageResponses
-          });
-        } catch {
-        }
-      }
-      let respawnStrategy = isResume ? "rerun" : void 0;
-      if (coords && isContinue) {
-        const logRaw = await Promise.resolve(
-          toolSafeSandboxSession.readTextFile({
-            path: `${bridgeStateDir}/event-log.ndjson`,
-            abortSignal: startOpts.abortSignal
-          })
-        ).catch(() => null);
-        if (await classifyDiskLog(logRaw) === "replay") {
-          respawnStrategy = "replay";
-        }
-      }
-      const port = resolveBridgePort({
-        sandboxSession,
-        override: settings.port
-      });
-      const token = settings.mintBridgeToken == null ? createBridgeToken() : settings.mintBridgeToken(sandboxId);
-      const env = {
-        BRIDGE_CHANNEL_TOKEN: token,
-        BRIDGE_WS_PORT: String(port),
-        ...respawnStrategy === "replay" ? { BRIDGE_REPLAY_FROM_DISK: "1" } : {}
-      };
-      if (respawnStrategy === void 0) {
-        await toolSafeSandboxSession.run({
-          command: `mkdir -p ${shellQuote(workDir)} ${shellQuote(bridgeStateDir)}`,
-          abortSignal: startOpts.abortSignal
-        });
-      }
-      await markBridgeStarting({
-        sandbox: toolSafeSandboxSession,
-        bridgeStateDir,
-        bridgeType: "claude-code",
-        abortSignal: startOpts.abortSignal
-      });
-      const proc = await toolSafeSandboxSession.spawn({
-        command: `node ${shellQuote(`${bootstrapDir}/bridge.mjs`)} --workdir ${shellQuote(workDir)} --bridge-state-dir ${shellQuote(bridgeStateDir)}`,
-        env,
-        abortSignal: startOpts.abortSignal
-      });
-      const bridgeStartupStderr = [];
-      const bridgeStartupStderrDone = forwardBridgeProcessStream({
-        stream: proc.stderr,
-        streamName: "stderr",
-        source: "claude-code",
-        collectTail: bridgeStartupStderr
-      });
-      void bridgeStartupStderrDone;
-      const { port: boundPort } = await waitForBridgeReady({
-        proc,
-        sandbox: toolSafeSandboxSession,
-        bridgeStateDir,
-        bridgeType: "claude-code",
-        timeoutMs,
-        abortSignal: startOpts.abortSignal,
-        createTimeoutError: ({ proc: proc2, stdoutTail }) => createBridgeStartupError({
-          message: "claude-code bridge did not become ready in time.",
-          proc: proc2,
-          stdoutTail,
-          stderrTail: bridgeStartupStderr,
-          stderrDone: bridgeStartupStderrDone
-        }),
-        createExitError: ({ proc: proc2, stdoutTail }) => createBridgeStartupError({
-          message: "claude-code bridge exited before becoming ready.",
-          proc: proc2,
-          stdoutTail,
-          stderrTail: bridgeStartupStderr,
-          stderrDone: bridgeStartupStderrDone
-        })
-      });
-      void drainBridgeProcessStream(proc.stdout);
-      const endpoint = await resolveBridgeEndpoint({
-        sandboxSession,
-        override: settings.portEndpoint,
-        port: boundPort
-      });
-      const bridgeEndpoint = withBridgeToken({ endpoint, token });
-      const channel = new SandboxChannel({
-        connect: buildConnect(bridgeEndpoint),
-        outboundSchema: outboundMessageSchema,
-        onDiagnostic,
-        onBridgeError,
-        reconnect: settings.reconnect,
-        // In replay mode the respawned bridge reloaded the finished turn from
-        // disk; seed the cursor and resume so it streams the tail (incl.
-        // `finish`) rather than starting empty.
-        ...respawnStrategy === "replay" ? { initialLastSeenEventId: coords?.lastSeenEventId ?? 0 } : {}
-      });
-      const finishListenerAttachment = respawnStrategy === "replay" ? channel.beginListenerAttachment() : void 0;
-      try {
-        await channel.open(
-          respawnStrategy === "replay" ? { resume: true } : void 0
-        );
-      } catch (error) {
-        finishListenerAttachment?.();
-        throw error;
-      }
-      return createSession({
-        sessionId: startOpts.sessionId,
-        channel,
-        finishListenerAttachment,
-        proc,
-        maxTurns: settings.maxTurns,
-        env: sandboxClaudeEnvironment,
-        thinking,
-        effort: settings.effort,
-        isResume: respawnStrategy !== void 0,
-        continueOnFirstPrompt: respawnStrategy !== void 0,
-        ...resumeSessionId ? { resumeSessionId } : {},
-        rerunContinue: respawnStrategy === "rerun",
-        bridgePort: boundPort,
-        bridgeToken: token,
-        sandboxId,
-        sandboxCredentialEnvironment,
-        debug: startOpts.observability?.debug,
-        permissionMode: startOpts.permissionMode,
-        builtinToolFiltering: startOpts.builtinToolFiltering,
-        sandbox: toolSafeSandboxSession,
-        sandboxHomeDir,
-        mcpServers: settings.mcpServers,
-        supportsUserMessageResponses: () => supportsUserMessageResponses
-      });
-    }
-  };
+	if (settings.mcpServers != null && Object.prototype.hasOwnProperty.call(settings.mcpServers, "harness-tools")) throw new Error("Claude Code MCP server name \"harness-tools\" is reserved for HarnessAgent tools.");
+	const thinking = settings.thinking ?? {
+		type: "adaptive",
+		display: "summarized"
+	};
+	return {
+		specificationVersion: "harness-v1",
+		harnessId: "claude-code",
+		builtinTools: CLAUDE_CODE_BUILTIN_TOOLS,
+		supportsBuiltinToolApprovals: true,
+		supportsBuiltinToolFiltering: true,
+		lifecycleStateSchema: claudeCodeResumeStateSchema,
+		getBootstrap: getClaudeCodeBootstrap,
+		doStart: async (startOpts) => {
+			const sandboxSession = startOpts.sandboxSession;
+			const toolSafeSandboxSession = getRestrictedSandboxSession(sandboxSession);
+			const sandboxId = "id" in sandboxSession ? sandboxSession.id : void 0;
+			validateBasicSandboxSettings({
+				sandboxSession,
+				port: settings.port,
+				portEndpoint: settings.portEndpoint
+			});
+			if (settings.mintBridgeToken != null && sandboxId == null) throw new HarnessCapabilityUnsupportedError({
+				harnessId: "claude-code",
+				message: "The Claude Code harness cannot use `mintBridgeToken` with a sandbox session that does not expose an id."
+			});
+			const lifecycleState = startOpts.continueFrom ?? startOpts.resumeFrom;
+			const isResume = lifecycleState != null;
+			const isContinue = startOpts.continueFrom != null;
+			const resumeData = isResume ? lifecycleState?.data : void 0;
+			const coords = resumeData?.bridge;
+			const authenticationMode = resolveClaudeCodeAuthenticationMode(settings.auth);
+			const resolvedAuthEnvironment = await resolveClaudeCodeAuthentication({ auth: settings.auth });
+			const claudeEnvironment = {
+				...resolvedAuthEnvironment,
+				...resolvedAuthEnvironment.AI_GATEWAY_BASE_URL ? { CLAUDE_AGENT_SDK_CLIENT_APP: CLAUDE_CODE_CLIENT_APP } : {},
+				...settings.env,
+				...startOpts.headers != null ? { ANTHROPIC_CUSTOM_HEADERS: Object.entries(startOpts.headers).map(([name, value]) => `${name}: ${value}`).join("\n") } : {}
+			};
+			let sandboxClaudeEnvironment = claudeEnvironment;
+			let sandboxCredentialEnvironment;
+			if ("addRequestTransformations" in sandboxSession && sandboxSession.addRequestTransformations != null) {
+				sandboxCredentialEnvironment = await resolveSandboxCredentialEnvironment({
+					environment: claudeEnvironment,
+					credentialEnvironmentVariables: CLAUDE_CODE_CREDENTIAL_ENVIRONMENT_VARIABLES,
+					credentialForwarding: settings.credentialForwarding,
+					previousSandboxCredentialEnvironment: resumeData?.sandboxCredentialEnvironment
+				});
+				sandboxClaudeEnvironment = {
+					...claudeEnvironment,
+					...sandboxCredentialEnvironment
+				};
+				const transformationSources = {
+					env: claudeEnvironment,
+					sandboxEnv: sandboxClaudeEnvironment,
+					auth: authenticationMode
+				};
+				const requestTransformations = [...createClaudeCodeRequestTransformations(transformationSources), ...createClaudeCodeSubscriptionRequestTransformations(transformationSources)];
+				if (requestTransformations.length > 0) await sandboxSession.addRequestTransformations(requestTransformations);
+			} else {
+				sandboxClaudeEnvironment = await applyCredentialForwarding({
+					environment: sandboxClaudeEnvironment,
+					credentialEnvironmentVariables: CLAUDE_CODE_CREDENTIAL_ENVIRONMENT_VARIABLES,
+					credentialForwarding: settings.credentialForwarding
+				});
+				warnCredentialBrokeringUnavailable({
+					environment: claudeEnvironment,
+					forwardedEnvironment: sandboxClaudeEnvironment,
+					credentialEnvironmentVariables: CLAUDE_CODE_CREDENTIAL_ENVIRONMENT_VARIABLES
+				});
+			}
+			const sandboxHomeDir = await resolveSandboxHomeDir({
+				sandbox: toolSafeSandboxSession,
+				abortSignal: startOpts.abortSignal
+			});
+			const stateDir = harnessStateDirectoryPath({ sandboxHomeDir });
+			const bootstrapDir = posix.resolve(stateDir, CLAUDE_CODE_BOOTSTRAP_DIR);
+			const resumeSessionId = resumeData?.claudeSessionId;
+			const workDir = startOpts.sessionWorkDir;
+			const bridgeStateDir = `${harnessSessionDataDirectoryPath({
+				stateDirectory: stateDir,
+				sessionId: startOpts.sessionId
+			})}/bridge`;
+			const timeoutMs = settings.startupTimeoutMs ?? 12e4;
+			const report = startOpts.observability?.report;
+			const onDiagnostic = report ? (frame) => report(harnessV1DiagnosticFromBridgeFrame(frame, {
+				sessionId: startOpts.sessionId,
+				timestamp: Date.now()
+			})) : void 0;
+			const onBridgeError = createBridgeErrorHandler({
+				harnessId: "claude-code",
+				sessionId: startOpts.sessionId
+			});
+			let supportsUserMessageResponses = false;
+			const buildConnect = (endpoint) => async ({ abortSignal }) => {
+				return openBridgeWebSocket({
+					endpoint,
+					timeoutMs,
+					abortSignal,
+					onHello: (supportsResponses) => {
+						supportsUserMessageResponses = supportsResponses;
+					}
+				});
+			};
+			if (coords) try {
+				const endpoint = await resolveBridgeEndpoint({
+					sandboxSession,
+					override: settings.portEndpoint,
+					port: coords.port
+				});
+				const attachEndpoint = withBridgeToken({
+					endpoint,
+					token: coords.token
+				});
+				const attachChannel = new SandboxChannel({
+					connect: buildConnect(attachEndpoint),
+					outboundSchema: outboundMessageSchema,
+					initialLastSeenEventId: coords.lastSeenEventId,
+					onDiagnostic,
+					onBridgeError,
+					reconnect: settings.reconnect
+				});
+				const finishListenerAttachment = isContinue ? attachChannel.beginListenerAttachment() : void 0;
+				try {
+					await attachChannel.open(isContinue ? { resume: true } : void 0);
+				} catch (error) {
+					finishListenerAttachment?.();
+					throw error;
+				}
+				return createSession({
+					sessionId: startOpts.sessionId,
+					channel: attachChannel,
+					finishListenerAttachment,
+					...resumeSessionId ? { resumeSessionId } : {},
+					proc: void 0,
+					maxTurns: settings.maxTurns,
+					agentProgressSummaries: settings.agentProgressSummaries,
+					forwardSubagentText: settings.forwardSubagentText,
+					env: sandboxClaudeEnvironment,
+					thinking,
+					effort: settings.effort,
+					isResume: true,
+					continueOnFirstPrompt: false,
+					rerunContinue: false,
+					bridgePort: coords.port,
+					bridgeToken: coords.token,
+					sandboxId,
+					sandboxCredentialEnvironment,
+					debug: startOpts.observability?.debug,
+					permissionMode: startOpts.permissionMode,
+					builtinToolFiltering: startOpts.builtinToolFiltering,
+					sandbox: toolSafeSandboxSession,
+					sandboxHomeDir,
+					mcpServers: settings.mcpServers,
+					supportsUserMessageResponses: () => supportsUserMessageResponses
+				});
+			} catch {}
+			let respawnStrategy = isResume ? "rerun" : void 0;
+			if (coords && isContinue) {
+				const logRaw = await Promise.resolve(toolSafeSandboxSession.readTextFile({
+					path: `${bridgeStateDir}/event-log.ndjson`,
+					abortSignal: startOpts.abortSignal
+				})).catch(() => null);
+				if (await classifyDiskLog(logRaw) === "replay") respawnStrategy = "replay";
+			}
+			const port = resolveBridgePort({
+				sandboxSession,
+				override: settings.port
+			});
+			const token = settings.mintBridgeToken == null ? createBridgeToken() : settings.mintBridgeToken(sandboxId);
+			const env = {
+				BRIDGE_CHANNEL_TOKEN: token,
+				BRIDGE_WS_PORT: String(port),
+				...respawnStrategy === "replay" ? { BRIDGE_REPLAY_FROM_DISK: "1" } : {}
+			};
+			if (respawnStrategy === void 0) await toolSafeSandboxSession.run({
+				command: `mkdir -p ${shellQuote(workDir)} ${shellQuote(bridgeStateDir)}`,
+				abortSignal: startOpts.abortSignal
+			});
+			await markBridgeStarting({
+				sandbox: toolSafeSandboxSession,
+				bridgeStateDir,
+				bridgeType: "claude-code",
+				abortSignal: startOpts.abortSignal
+			});
+			const proc = await toolSafeSandboxSession.spawn({
+				command: `node ${shellQuote(`${bootstrapDir}/bridge.mjs`)} --workdir ${shellQuote(workDir)} --bridge-state-dir ${shellQuote(bridgeStateDir)}`,
+				env,
+				abortSignal: startOpts.abortSignal
+			});
+			const bridgeStartupStderr = [];
+			const bridgeStartupStderrDone = forwardBridgeProcessStream({
+				stream: proc.stderr,
+				streamName: "stderr",
+				source: "claude-code",
+				collectTail: bridgeStartupStderr
+			});
+			const { port: boundPort } = await waitForBridgeReady({
+				proc,
+				sandbox: toolSafeSandboxSession,
+				bridgeStateDir,
+				bridgeType: "claude-code",
+				timeoutMs,
+				abortSignal: startOpts.abortSignal,
+				createTimeoutError: ({ proc, stdoutTail }) => createBridgeStartupError({
+					message: "claude-code bridge did not become ready in time.",
+					proc,
+					stdoutTail,
+					stderrTail: bridgeStartupStderr,
+					stderrDone: bridgeStartupStderrDone
+				}),
+				createExitError: ({ proc, stdoutTail }) => createBridgeStartupError({
+					message: "claude-code bridge exited before becoming ready.",
+					proc,
+					stdoutTail,
+					stderrTail: bridgeStartupStderr,
+					stderrDone: bridgeStartupStderrDone
+				})
+			});
+			drainBridgeProcessStream(proc.stdout);
+			const endpoint = await resolveBridgeEndpoint({
+				sandboxSession,
+				override: settings.portEndpoint,
+				port: boundPort
+			});
+			const bridgeEndpoint = withBridgeToken({
+				endpoint,
+				token
+			});
+			const channel = new SandboxChannel({
+				connect: buildConnect(bridgeEndpoint),
+				outboundSchema: outboundMessageSchema,
+				onDiagnostic,
+				onBridgeError,
+				reconnect: settings.reconnect,
+				...respawnStrategy === "replay" ? { initialLastSeenEventId: coords?.lastSeenEventId ?? 0 } : {}
+			});
+			const finishListenerAttachment = respawnStrategy === "replay" ? channel.beginListenerAttachment() : void 0;
+			try {
+				await channel.open(respawnStrategy === "replay" ? { resume: true } : void 0);
+			} catch (error) {
+				finishListenerAttachment?.();
+				throw error;
+			}
+			return createSession({
+				sessionId: startOpts.sessionId,
+				channel,
+				finishListenerAttachment,
+				proc,
+				maxTurns: settings.maxTurns,
+				agentProgressSummaries: settings.agentProgressSummaries,
+				forwardSubagentText: settings.forwardSubagentText,
+				env: sandboxClaudeEnvironment,
+				thinking,
+				effort: settings.effort,
+				isResume: respawnStrategy !== void 0,
+				continueOnFirstPrompt: respawnStrategy !== void 0,
+				...resumeSessionId ? { resumeSessionId } : {},
+				rerunContinue: respawnStrategy === "rerun",
+				bridgePort: boundPort,
+				bridgeToken: token,
+				sandboxId,
+				sandboxCredentialEnvironment,
+				debug: startOpts.observability?.debug,
+				permissionMode: startOpts.permissionMode,
+				builtinToolFiltering: startOpts.builtinToolFiltering,
+				sandbox: toolSafeSandboxSession,
+				sandboxHomeDir,
+				mcpServers: settings.mcpServers,
+				supportsUserMessageResponses: () => supportsUserMessageResponses
+			});
+		}
+	};
 }
-function resolveBridgePort({
-  sandboxSession,
-  override
-}) {
-  if (override !== void 0) return override;
-  if ("ports" in sandboxSession && sandboxSession.ports.length > 0) {
-    return sandboxSession.ports[0];
-  }
-  throw new HarnessCapabilityUnsupportedError({
-    harnessId: "claude-code",
-    message: "The claude-code harness needs a TCP port exposed by the sandbox. Create the sandbox with `ports: [<port>]` or pass `createClaudeCode({ port })`."
-  });
+function resolveBridgePort({ sandboxSession, override }) {
+	if (override !== void 0) return override;
+	if ("ports" in sandboxSession && sandboxSession.ports.length > 0) return sandboxSession.ports[0];
+	throw new HarnessCapabilityUnsupportedError({
+		harnessId: "claude-code",
+		message: "The claude-code harness needs a TCP port exposed by the sandbox. Create the sandbox with `ports: [<port>]` or pass `createClaudeCode({ port })`."
+	});
 }
-function validateBasicSandboxSettings({
-  sandboxSession,
-  port,
-  portEndpoint
-}) {
-  if ("getPortEndpoint" in sandboxSession) return;
-  if (port == null) {
-    throw new HarnessCapabilityUnsupportedError({
-      harnessId: "claude-code",
-      message: "The Claude Code harness requires an explicit `port` when using a basic sandbox session."
-    });
-  }
-  if (portEndpoint == null) {
-    throw new HarnessCapabilityUnsupportedError({
-      harnessId: "claude-code",
-      message: "The Claude Code harness requires an explicit `portEndpoint` when using a basic sandbox session."
-    });
-  }
+function validateBasicSandboxSettings({ sandboxSession, port, portEndpoint }) {
+	if ("getPortEndpoint" in sandboxSession) return;
+	if (port == null) throw new HarnessCapabilityUnsupportedError({
+		harnessId: "claude-code",
+		message: "The Claude Code harness requires an explicit `port` when using a basic sandbox session."
+	});
+	if (portEndpoint == null) throw new HarnessCapabilityUnsupportedError({
+		harnessId: "claude-code",
+		message: "The Claude Code harness requires an explicit `portEndpoint` when using a basic sandbox session."
+	});
 }
-async function resolveBridgeEndpoint({
-  sandboxSession,
-  override,
-  port
-}) {
-  if (override != null) return override;
-  if ("getPortEndpoint" in sandboxSession) {
-    return sandboxSession.getPortEndpoint({ port, protocol: "ws" });
-  }
-  throw new HarnessCapabilityUnsupportedError({
-    harnessId: "claude-code",
-    message: "The Claude Code harness requires an explicit `portEndpoint` when using a basic sandbox session."
-  });
+async function resolveBridgeEndpoint({ sandboxSession, override, port }) {
+	if (override != null) return override;
+	if ("getPortEndpoint" in sandboxSession) return sandboxSession.getPortEndpoint({
+		port,
+		protocol: "ws"
+	});
+	throw new HarnessCapabilityUnsupportedError({
+		harnessId: "claude-code",
+		message: "The Claude Code harness requires an explicit `portEndpoint` when using a basic sandbox session."
+	});
 }
-function openWebSocketAndWaitForBridgeHello({
-  endpoint,
-  openTimeoutMs,
-  getHelloTimeoutMs,
-  abortSignal,
-  onHello
-}) {
-  return new Promise((resolve2, reject) => {
-    const abortReason = () => abortSignal.reason ?? new Error("WebSocket connection aborted");
-    if (abortSignal.aborted) {
-      reject(abortReason());
-      return;
-    }
-    const ws = new WebSocket(endpoint.url, {
-      headers: endpoint.headers == null ? void 0 : { ...endpoint.headers }
-    });
-    let opened = false;
-    let sawBridgeHello = false;
-    let settled = false;
-    let openTimer;
-    let helloTimer;
-    let onAbort;
-    const cleanup = ({
-      keepTerminationListeners = false
-    } = {}) => {
-      if (openTimer) clearTimeout(openTimer);
-      if (helloTimer) clearTimeout(helloTimer);
-      ws.off("open", onOpen);
-      ws.off("message", onMessage);
-      if (onAbort != null) {
-        abortSignal.removeEventListener("abort", onAbort);
-      }
-      if (!keepTerminationListeners) {
-        ws.off("close", onClose);
-        ws.off("error", onError);
-      }
-    };
-    const settle = (err) => {
-      if (settled) return;
-      settled = true;
-      if (err) {
-        cleanup({ keepTerminationListeners: true });
-        try {
-          ws.terminate();
-        } catch {
-          cleanup();
-        }
-        reject(err);
-      } else {
-        cleanup();
-        resolve2(ws);
-      }
-    };
-    const tryResolve = () => {
-      if (opened && sawBridgeHello) settle();
-    };
-    const startHelloTimer = () => {
-      if (helloTimer) return;
-      const helloTimeoutMs = getHelloTimeoutMs();
-      helloTimer = setTimeout(
-        () => settle(
-          new Error(
-            `claude-code bridge did not send bridge-hello within ${helloTimeoutMs}ms`
-          )
-        ),
-        helloTimeoutMs
-      );
-      helloTimer.unref?.();
-    };
-    const onOpen = () => {
-      opened = true;
-      if (openTimer) {
-        clearTimeout(openTimer);
-        openTimer = void 0;
-      }
-      startHelloTimer();
-      tryResolve();
-    };
-    const onMessage = (raw) => {
-      void (async () => {
-        const parsed = await safeParseJSON2({
-          text: webSocketMessageToString(raw)
-        });
-        if (!parsed.success || settled) return;
-        const value = parsed.value;
-        if (typeof value === "object" && value !== null && !Array.isArray(value) && value.type === "bridge-hello") {
-          const capabilities = value.capabilities;
-          onHello(capabilities?.experimental_userMessageResponses === true);
-          sawBridgeHello = true;
-          tryResolve();
-        }
-      })();
-    };
-    const onClose = () => {
-      settle(
-        new Error("claude-code bridge closed before sending bridge-hello")
-      );
-      cleanup();
-    };
-    const onError = (err) => settle(err);
-    onAbort = () => settle(abortReason());
-    openTimer = setTimeout(
-      () => settle(new Error(`WebSocket open timed out after ${openTimeoutMs}ms`)),
-      openTimeoutMs
-    );
-    openTimer.unref?.();
-    ws.on("open", onOpen);
-    ws.on("message", onMessage);
-    ws.on("close", onClose);
-    ws.on("error", onError);
-    abortSignal.addEventListener("abort", onAbort, { once: true });
-  });
+/**
+* Materialise skill files into
+* `$HOME/.claude/skills/<name>/SKILL.md`. The `claude` CLI
+* auto-discovers skills from that directory on startup, so the files have to
+* be in place before the bridge is spawned without mutating the session
+* workdir. Each file uses the YAML-frontmatter shape the CLI expects.
+*/
+/**
+* Wait for the bridge's `bridge-hello` message to arrive on the freshly
+* opened WebSocket before any other host-side code touches it.
+*
+* Some sandbox runtimes (Vercel in particular) complete the WS upgrade
+* with the host long before the connection is actually forwarded to the
+* sandbox-side bridge. Anything sent in that gap is silently dropped —
+* including the `start` message we send next. The bridge emits
+* `bridge-hello` the instant it accepts the connection, so receiving it
+* is the only reliable evidence that the end-to-end link is live.
+*/
+function openWebSocketAndWaitForBridgeHello({ endpoint, openTimeoutMs, getHelloTimeoutMs, abortSignal, onHello }) {
+	return new Promise((resolve, reject) => {
+		const abortReason = () => abortSignal.reason ?? /* @__PURE__ */ new Error("WebSocket connection aborted");
+		if (abortSignal.aborted) {
+			reject(abortReason());
+			return;
+		}
+		const ws = new WebSocket(endpoint.url, { headers: endpoint.headers == null ? void 0 : { ...endpoint.headers } });
+		let opened = false;
+		let sawBridgeHello = false;
+		let settled = false;
+		let openTimer;
+		let helloTimer;
+		let onAbort;
+		const cleanup = ({ keepTerminationListeners = false } = {}) => {
+			if (openTimer) clearTimeout(openTimer);
+			if (helloTimer) clearTimeout(helloTimer);
+			ws.off("open", onOpen);
+			ws.off("message", onMessage);
+			if (onAbort != null) abortSignal.removeEventListener("abort", onAbort);
+			if (!keepTerminationListeners) {
+				ws.off("close", onClose);
+				ws.off("error", onError);
+			}
+		};
+		const settle = (err) => {
+			if (settled) return;
+			settled = true;
+			if (err) {
+				cleanup({ keepTerminationListeners: true });
+				try {
+					ws.terminate();
+				} catch {
+					cleanup();
+				}
+				reject(err);
+			} else {
+				cleanup();
+				resolve(ws);
+			}
+		};
+		const tryResolve = () => {
+			if (opened && sawBridgeHello) settle();
+		};
+		const startHelloTimer = () => {
+			if (helloTimer) return;
+			const helloTimeoutMs = getHelloTimeoutMs();
+			helloTimer = setTimeout(() => settle(/* @__PURE__ */ new Error(`claude-code bridge did not send bridge-hello within ${helloTimeoutMs}ms`)), helloTimeoutMs);
+			helloTimer.unref?.();
+		};
+		const onOpen = () => {
+			opened = true;
+			if (openTimer) {
+				clearTimeout(openTimer);
+				openTimer = void 0;
+			}
+			startHelloTimer();
+			tryResolve();
+		};
+		const onMessage = (raw) => {
+			(async () => {
+				const parsed = await safeParseJSON({ text: webSocketMessageToString(raw) });
+				if (!parsed.success || settled) return;
+				const value = parsed.value;
+				if (typeof value === "object" && value !== null && !Array.isArray(value) && value.type === "bridge-hello") {
+					const capabilities = value.capabilities;
+					onHello(capabilities?.experimental_userMessageResponses === true);
+					sawBridgeHello = true;
+					tryResolve();
+				}
+			})();
+		};
+		const onClose = () => {
+			settle(/* @__PURE__ */ new Error("claude-code bridge closed before sending bridge-hello"));
+			cleanup();
+		};
+		const onError = (err) => settle(err);
+		onAbort = () => settle(abortReason());
+		openTimer = setTimeout(() => settle(/* @__PURE__ */ new Error(`WebSocket open timed out after ${openTimeoutMs}ms`)), openTimeoutMs);
+		openTimer.unref?.();
+		ws.on("open", onOpen);
+		ws.on("message", onMessage);
+		ws.on("close", onClose);
+		ws.on("error", onError);
+		abortSignal.addEventListener("abort", onAbort, { once: true });
+	});
 }
-async function openBridgeWebSocket({
-  endpoint,
-  timeoutMs,
-  abortSignal,
-  onHello
-}) {
-  const deadline = Date.now() + timeoutMs;
-  let attempt = 0;
-  let lastError;
-  while (!abortSignal.aborted && Date.now() < deadline) {
-    attempt++;
-    try {
-      const remaining = Math.max(1, deadline - Date.now());
-      return await openWebSocketAndWaitForBridgeHello({
-        endpoint,
-        openTimeoutMs: Math.min(1e4, remaining),
-        getHelloTimeoutMs: () => Math.min(5e3, Math.max(1, deadline - Date.now())),
-        abortSignal,
-        onHello
-      });
-    } catch (err) {
-      if (abortSignal.aborted) {
-        throw abortSignal.reason ?? new Error("WebSocket connection aborted");
-      }
-      lastError = err;
-      const remaining = deadline - Date.now();
-      if (remaining <= 0) break;
-      await sleep({
-        ms: Math.min(250 * attempt, 1e3, remaining),
-        abortSignal
-      });
-    }
-  }
-  if (abortSignal.aborted) {
-    throw abortSignal.reason ?? new Error("WebSocket connection aborted");
-  }
-  throw new Error(
-    `claude-code bridge did not complete WebSocket handshake within ${timeoutMs}ms after ${attempt} attempt(s). Last error: ${formatUnknownError(lastError)}`
-  );
+async function openBridgeWebSocket({ endpoint, timeoutMs, abortSignal, onHello }) {
+	const deadline = Date.now() + timeoutMs;
+	let attempt = 0;
+	let lastError;
+	while (!abortSignal.aborted && Date.now() < deadline) {
+		attempt++;
+		try {
+			const remaining = Math.max(1, deadline - Date.now());
+			return await openWebSocketAndWaitForBridgeHello({
+				endpoint,
+				openTimeoutMs: Math.min(1e4, remaining),
+				getHelloTimeoutMs: () => Math.min(5e3, Math.max(1, deadline - Date.now())),
+				abortSignal,
+				onHello
+			});
+		} catch (err) {
+			if (abortSignal.aborted) throw abortSignal.reason ?? /* @__PURE__ */ new Error("WebSocket connection aborted");
+			lastError = err;
+			const remaining = deadline - Date.now();
+			if (remaining <= 0) break;
+			await sleep({
+				ms: Math.min(250 * attempt, 1e3, remaining),
+				abortSignal
+			});
+		}
+	}
+	if (abortSignal.aborted) throw abortSignal.reason ?? /* @__PURE__ */ new Error("WebSocket connection aborted");
+	throw new Error(`claude-code bridge did not complete WebSocket handshake within ${timeoutMs}ms after ${attempt} attempt(s). Last error: ${formatUnknownError(lastError)}`);
 }
 function webSocketMessageToString(raw) {
-  if (typeof raw === "string") return raw;
-  if (Buffer.isBuffer(raw)) return raw.toString("utf8");
-  if (Array.isArray(raw)) return Buffer.concat(raw).toString("utf8");
-  if (raw instanceof ArrayBuffer) return Buffer.from(raw).toString("utf8");
-  if (ArrayBuffer.isView(raw)) {
-    return Buffer.from(raw.buffer, raw.byteOffset, raw.byteLength).toString(
-      "utf8"
-    );
-  }
-  return String(raw);
+	if (typeof raw === "string") return raw;
+	if (Buffer.isBuffer(raw)) return raw.toString("utf8");
+	if (Array.isArray(raw)) return Buffer.concat(raw).toString("utf8");
+	if (raw instanceof ArrayBuffer) return Buffer.from(raw).toString("utf8");
+	if (ArrayBuffer.isView(raw)) return Buffer.from(raw.buffer, raw.byteOffset, raw.byteLength).toString("utf8");
+	return String(raw);
 }
 function formatUnknownError(error) {
-  if (error instanceof Error) return error.message;
-  return String(error);
+	if (error instanceof Error) return error.message;
+	return String(error);
 }
-function createSession({
-  sessionId,
-  channel,
-  finishListenerAttachment,
-  proc,
-  maxTurns,
-  env,
-  thinking,
-  effort,
-  isResume,
-  continueOnFirstPrompt,
-  resumeSessionId,
-  rerunContinue,
-  bridgePort,
-  bridgeToken,
-  sandboxId,
-  sandboxCredentialEnvironment,
-  debug,
-  permissionMode,
-  builtinToolFiltering,
-  sandbox,
-  sandboxHomeDir,
-  mcpServers,
-  supportsUserMessageResponses
-}) {
-  let stopped = false;
-  let stopPromise;
-  let pendingResumeFlag = continueOnFirstPrompt;
-  let lastClaudeSessionId = resumeSessionId;
-  const wireTurn = (turnOpts) => {
-    let pendingResolve;
-    let pendingReject;
-    const done = new Promise((resolve2, reject) => {
-      pendingResolve = resolve2;
-      pendingReject = reject;
-    });
-    const userMessageSubmitter = supportsUserMessageResponses() ? experimental_createBridgeUserMessageSubmitter({
-      send: (message) => channel.send(message),
-      onResponse: (listener) => channel.on("user-message-response", listener),
-      onReconnect: (listener) => channel.onReconnect(listener)
-    }) : void 0;
-    const unsubs = [];
-    const forward = (event) => {
-      try {
-        turnOpts.emit(event);
-      } catch {
-      }
-    };
-    let isSettled = false;
-    const settleSuccess = () => {
-      if (isSettled) return;
-      isSettled = true;
-      userMessageSubmitter?.close();
-      for (const u of unsubs) u();
-      pendingResolve();
-    };
-    const settleError = (err) => {
-      if (isSettled) return;
-      isSettled = true;
-      userMessageSubmitter?.close(err);
-      for (const u of unsubs) u();
-      pendingReject(err);
-    };
-    const eventTypes = [
-      "stream-start",
-      "text-start",
-      "text-delta",
-      "text-end",
-      "reasoning-start",
-      "reasoning-delta",
-      "reasoning-end",
-      "tool-input-start",
-      "tool-input-delta",
-      "tool-input-end",
-      "tool-call",
-      "tool-approval-request",
-      "tool-result",
-      "finish-step",
-      "compaction",
-      "raw"
-    ];
-    for (const type of eventTypes) {
-      unsubs.push(
-        channel.on(type, (msg) => {
-          forward(msg);
-        })
-      );
-    }
-    unsubs.push(
-      channel.on("finish", (msg) => {
-        const metadata = msg.harnessMetadata?.["claude-code"]?.sessionId;
-        if (typeof metadata === "string" && metadata.length > 0) {
-          lastClaudeSessionId = metadata;
-        }
-        forward(msg);
-        settleSuccess();
-      })
-    );
-    unsubs.push(
-      channel.on("error", (msg) => {
-        forward(msg);
-        settleError(msg.error);
-      })
-    );
-    finishListenerAttachment?.();
-    finishListenerAttachment = void 0;
-    const onClose = (_code, reason) => {
-      if (isSettled) return;
-      if (reason === "suspended") {
-        settleSuccess();
-        return;
-      }
-      settleError(
-        new Error("claude-code bridge closed before the turn finished.")
-      );
-    };
-    channel.onClose(onClose);
-    const onAbort = () => {
-      if (isSettled) return;
-      try {
-        channel.send({ type: "abort" });
-      } catch {
-      }
-      settleError(
-        turnOpts.abortSignal?.reason ?? new DOMException("Aborted", "AbortError")
-      );
-    };
-    if (turnOpts.abortSignal) {
-      if (turnOpts.abortSignal.aborted) {
-        onAbort();
-      } else {
-        turnOpts.abortSignal.addEventListener("abort", onAbort, {
-          once: true
-        });
-      }
-    }
-    return {
-      submitToolResult: async (input) => {
-        channel.send({
-          type: "tool-result",
-          toolCallId: input.toolCallId,
-          output: input.output,
-          isError: input.isError,
-          ...input.toolResult !== void 0 ? { toolResult: input.toolResult } : {}
-        });
-      },
-      submitToolApproval: async (input) => {
-        channel.send({
-          type: "tool-approval-response",
-          approvalId: input.approvalId,
-          approved: input.approved,
-          reason: input.reason
-        });
-      },
-      ...userMessageSubmitter == null ? {} : {
-        submitUserMessage: async (text) => {
-          await userMessageSubmitter.submit(text);
-        }
-      },
-      done
-    };
-  };
-  const prepareTurn = async (turnOpts) => {
-    if (turnOpts.responseFormat?.type === "json" && turnOpts.responseFormat.schema == null) {
-      throw new HarnessCapabilityUnsupportedError({
-        message: "Harness 'claude-code' requires a JSON schema for structured output.",
-        harnessId: "claude-code"
-      });
-    }
-    await writeSkills({
-      sandbox,
-      homePath: sandboxHomeDir,
-      skillsDir: ".claude/skills",
-      skills: turnOpts.skills,
-      abortSignal: turnOpts.abortSignal,
-      invalidSkillNameMessage: ({ name }) => `Invalid Claude Code skill name: ${name}`,
-      invalidSkillFilePathMessage: ({ skillName, filePath }) => `Invalid Claude Code skill file path for ${skillName}: ${filePath}`,
-      trailingNewline: true
-    });
-    return wireTurn({
-      emit: turnOpts.emit,
-      abortSignal: turnOpts.abortSignal
-    });
-  };
-  return {
-    sessionId,
-    isResume,
-    doPromptTurn: async (promptOpts) => {
-      const control = await prepareTurn(promptOpts);
-      if (promptOpts.abortSignal?.aborted) {
-        return control;
-      }
-      const startMessage = {
-        type: "start",
-        prompt: extractUserText(promptOpts.prompt),
-        tools: (promptOpts.tools ?? []).map((t) => ({
-          name: t.name,
-          description: t.description,
-          inputSchema: t.inputSchema
-        })),
-        ...promptOpts.responseFormat == null ? {} : { responseFormat: promptOpts.responseFormat },
-        ...promptOpts.instructions ? { instructions: promptOpts.instructions } : {},
-        model: promptOpts.model,
-        maxTurns,
-        ...env !== void 0 ? { env } : {},
-        thinking,
-        ...effort !== void 0 ? { effort } : {},
-        ...promptOpts.skills.length > 0 ? { skills: promptOpts.skills.map((skill) => skill.name) } : {},
-        ...mcpServers == null ? {} : { mcpServers },
-        ...permissionMode ? { permissionMode } : {},
-        ...builtinToolFiltering ? { builtinToolFiltering } : {},
-        ...debug ? { debug } : {},
-        ...lastClaudeSessionId ? { resumeSessionId: lastClaudeSessionId } : pendingResumeFlag ? { continue: true } : {}
-      };
-      pendingResumeFlag = false;
-      channel.send(startMessage);
-      return control;
-    },
-    doContinueTurn: async (continueOpts) => {
-      const control = await prepareTurn(continueOpts);
-      if (rerunContinue && !continueOpts.abortSignal?.aborted) {
-        pendingResumeFlag = false;
-        channel.send({
-          type: "start",
-          /*
-           * A continuation nudge rather than an empty prompt: `continue: true`
-           * rehydrates the prior thread, and this is the new user turn that
-           * drives it forward. It must be non-empty — an empty text block is
-           * rejected by the Anthropic API once the SDK stamps it with
-           * `cache_control`.
-           */
-          prompt: "Continue.",
-          tools: (continueOpts.tools ?? []).map((t) => ({
-            name: t.name,
-            description: t.description,
-            inputSchema: t.inputSchema
-          })),
-          ...continueOpts.responseFormat == null ? {} : { responseFormat: continueOpts.responseFormat },
-          ...continueOpts.instructions ? { instructions: continueOpts.instructions } : {},
-          model: continueOpts.model,
-          maxTurns,
-          ...env !== void 0 ? { env } : {},
-          thinking,
-          ...effort !== void 0 ? { effort } : {},
-          ...continueOpts.skills.length > 0 ? { skills: continueOpts.skills.map((skill) => skill.name) } : {},
-          ...mcpServers == null ? {} : { mcpServers },
-          ...permissionMode ? { permissionMode } : {},
-          ...builtinToolFiltering ? { builtinToolFiltering } : {},
-          ...debug ? { debug } : {},
-          ...lastClaudeSessionId ? { resumeSessionId: lastClaudeSessionId } : { continue: true }
-        });
-      }
-      return control;
-    },
-    doCompact: async (customInstructions) => {
-      const text = customInstructions && customInstructions.trim() ? `/compact ${customInstructions.trim()}` : "/compact";
-      channel.send({ type: "user-message", text });
-    },
-    doDetach: async () => {
-      if (stopped) {
-        throw new Error(
-          `claude-code session ${sessionId} is already stopped; cannot detach.`
-        );
-      }
-      stopped = true;
-      const lastSeenEventId = await channel.suspend();
-      const payload = {
-        type: "resume-session",
-        harnessId: "claude-code",
-        specificationVersion: "harness-v1",
-        data: {
-          ...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment },
-          bridge: {
-            port: bridgePort,
-            token: bridgeToken,
-            lastSeenEventId,
-            ...sandboxId == null ? {} : { sandboxId }
-          },
-          ...lastClaudeSessionId ? { claudeSessionId: lastClaudeSessionId } : {}
-        }
-      };
-      return payload;
-    },
-    doDestroy: async () => {
-      if (stopped) return stopPromise;
-      stopped = true;
-      stopPromise = (async () => {
-        channel.beginClose();
-        try {
-          if (!channel.isClosed()) {
-            channel.send({ type: "destroy" });
-          }
-        } catch {
-        }
-        let stopTimer;
-        try {
-          if (proc) {
-            await Promise.race([
-              proc.wait(),
-              new Promise((resolve2) => {
-                stopTimer = setTimeout(resolve2, 5e3);
-                stopTimer.unref?.();
-              })
-            ]);
-          }
-        } finally {
-          if (stopTimer) clearTimeout(stopTimer);
-          try {
-            await proc?.kill();
-          } catch {
-          }
-          channel.close();
-        }
-      })();
-      return stopPromise;
-    },
-    doStop: async () => {
-      if (stopped) {
-        throw new Error(
-          `claude-code session ${sessionId} is already stopped; cannot stop.`
-        );
-      }
-      stopped = true;
-      channel.beginClose();
-      const data = channel.isClosed() ? {} : await new Promise((resolve2, reject) => {
-        const timer = setTimeout(() => {
-          unsub();
-          reject(
-            new Error(
-              `claude-code session ${sessionId} did not reply to stop within 5s.`
-            )
-          );
-        }, 5e3);
-        timer.unref?.();
-        const unsub = channel.on("bridge-stop", (msg) => {
-          clearTimeout(timer);
-          unsub();
-          resolve2(msg.data);
-        });
-        try {
-          channel.send({ type: "stop" });
-        } catch (err) {
-          clearTimeout(timer);
-          unsub();
-          reject(err);
-        }
-      });
-      let stopTimer;
-      try {
-        if (proc) {
-          await Promise.race([
-            proc.wait(),
-            new Promise((resolve2) => {
-              stopTimer = setTimeout(resolve2, 5e3);
-              stopTimer.unref?.();
-            })
-          ]);
-        }
-      } finally {
-        if (stopTimer) clearTimeout(stopTimer);
-        try {
-          await proc?.kill();
-        } catch {
-        }
-        channel.close();
-      }
-      const lifecycleData = data != null && typeof data === "object" && !Array.isArray(data) ? { ...data } : {};
-      const payload = {
-        type: "resume-session",
-        harnessId: "claude-code",
-        specificationVersion: "harness-v1",
-        // The bridge's stop reply carries the session id it observed; the
-        // adapter's own record backfills it when the reply predates the
-        // field or the channel was already closed.
-        data: {
-          ...lastClaudeSessionId ? { claudeSessionId: lastClaudeSessionId } : {},
-          ...lifecycleData,
-          ...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment }
-        }
-      };
-      return payload;
-    },
-    doSuspendTurn: async () => {
-      if (stopped) {
-        throw new Error(
-          `claude-code session ${sessionId} is stopped; cannot suspend.`
-        );
-      }
-      stopped = true;
-      const lastSeenEventId = await channel.suspend();
-      const payload = {
-        type: "continue-turn",
-        harnessId: "claude-code",
-        specificationVersion: "harness-v1",
-        data: {
-          ...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment },
-          bridge: {
-            port: bridgePort,
-            token: bridgeToken,
-            lastSeenEventId,
-            ...sandboxId == null ? {} : { sandboxId }
-          },
-          ...lastClaudeSessionId ? { claudeSessionId: lastClaudeSessionId } : {}
-        }
-      };
-      return payload;
-    }
-  };
+function createSession({ sessionId, channel, finishListenerAttachment, proc, maxTurns, agentProgressSummaries, forwardSubagentText, env, thinking, effort, isResume, continueOnFirstPrompt, resumeSessionId, rerunContinue, bridgePort, bridgeToken, sandboxId, sandboxCredentialEnvironment, debug, permissionMode, builtinToolFiltering, sandbox, sandboxHomeDir, mcpServers, supportsUserMessageResponses }) {
+	let stopped = false;
+	let stopPromise;
+	let pendingResumeFlag = continueOnFirstPrompt;
+	let lastClaudeSessionId = resumeSessionId;
+	const wireTurn = (turnOpts) => {
+		let pendingResolve;
+		let pendingReject;
+		const done = new Promise((resolve, reject) => {
+			pendingResolve = resolve;
+			pendingReject = reject;
+		});
+		const userMessageSubmitter = supportsUserMessageResponses() ? experimental_createBridgeUserMessageSubmitter({
+			send: (message) => channel.send(message),
+			onResponse: (listener) => channel.on("user-message-response", listener),
+			onReconnect: (listener) => channel.onReconnect(listener)
+		}) : void 0;
+		const unsubs = [];
+		const forward = (event) => {
+			try {
+				turnOpts.emit(event);
+			} catch {}
+		};
+		let isSettled = false;
+		const settleSuccess = () => {
+			if (isSettled) return;
+			isSettled = true;
+			userMessageSubmitter?.close();
+			for (const u of unsubs) u();
+			pendingResolve();
+		};
+		const settleError = (err) => {
+			if (isSettled) return;
+			isSettled = true;
+			userMessageSubmitter?.close(err);
+			for (const u of unsubs) u();
+			pendingReject(err);
+		};
+		for (const type of [
+			"stream-start",
+			"text-start",
+			"text-delta",
+			"text-end",
+			"reasoning-start",
+			"reasoning-delta",
+			"reasoning-end",
+			"tool-input-start",
+			"tool-input-delta",
+			"tool-input-end",
+			"tool-call",
+			"tool-approval-request",
+			"tool-result",
+			"finish-step",
+			"compaction",
+			"raw"
+		]) unsubs.push(channel.on(type, (msg) => {
+			forward(msg);
+		}));
+		unsubs.push(channel.on("finish", (msg) => {
+			const metadata = msg.harnessMetadata?.["claude-code"]?.sessionId;
+			if (typeof metadata === "string" && metadata.length > 0) lastClaudeSessionId = metadata;
+			forward(msg);
+			settleSuccess();
+		}));
+		unsubs.push(channel.on("error", (msg) => {
+			forward(msg);
+			settleError(msg.error);
+		}));
+		finishListenerAttachment?.();
+		finishListenerAttachment = void 0;
+		const onClose = (_code, reason) => {
+			if (isSettled) return;
+			if (reason === "suspended") {
+				settleSuccess();
+				return;
+			}
+			settleError(/* @__PURE__ */ new Error("claude-code bridge closed before the turn finished."));
+		};
+		channel.onClose(onClose);
+		const onAbort = () => {
+			if (isSettled) return;
+			try {
+				channel.send({ type: "abort" });
+			} catch {}
+			settleError(turnOpts.abortSignal?.reason ?? new DOMException("Aborted", "AbortError"));
+		};
+		if (turnOpts.abortSignal) {
+			if (turnOpts.abortSignal.aborted) onAbort();
+			else turnOpts.abortSignal.addEventListener("abort", onAbort, { once: true });
+		}
+		return {
+			submitToolResult: async (input) => {
+				channel.send({
+					type: "tool-result",
+					toolCallId: input.toolCallId,
+					output: input.output,
+					isError: input.isError,
+					...input.toolResult !== void 0 ? { toolResult: input.toolResult } : {}
+				});
+			},
+			submitToolApproval: async (input) => {
+				channel.send({
+					type: "tool-approval-response",
+					approvalId: input.approvalId,
+					approved: input.approved,
+					reason: input.reason
+				});
+			},
+			...userMessageSubmitter == null ? {} : { submitUserMessage: async (text) => {
+				await userMessageSubmitter.submit(text);
+			} },
+			done
+		};
+	};
+	const prepareTurn = async (turnOpts) => {
+		if (turnOpts.responseFormat?.type === "json" && turnOpts.responseFormat.schema == null) throw new HarnessCapabilityUnsupportedError({
+			message: "Harness 'claude-code' requires a JSON schema for structured output.",
+			harnessId: "claude-code"
+		});
+		await writeSkills({
+			sandbox,
+			homePath: sandboxHomeDir,
+			skillsDir: ".claude/skills",
+			skills: turnOpts.skills,
+			abortSignal: turnOpts.abortSignal,
+			invalidSkillNameMessage: ({ name }) => `Invalid Claude Code skill name: ${name}`,
+			invalidSkillFilePathMessage: ({ skillName, filePath }) => `Invalid Claude Code skill file path for ${skillName}: ${filePath}`,
+			trailingNewline: true
+		});
+		return wireTurn({
+			emit: turnOpts.emit,
+			abortSignal: turnOpts.abortSignal
+		});
+	};
+	return {
+		sessionId,
+		isResume,
+		doPromptTurn: async (promptOpts) => {
+			const control = await prepareTurn(promptOpts);
+			if (promptOpts.abortSignal?.aborted) return control;
+			const startMessage = {
+				type: "start",
+				prompt: extractUserText(promptOpts.prompt),
+				tools: (promptOpts.tools ?? []).map((t) => ({
+					name: t.name,
+					description: t.description,
+					inputSchema: t.inputSchema
+				})),
+				...promptOpts.responseFormat == null ? {} : { responseFormat: promptOpts.responseFormat },
+				...promptOpts.instructions ? { instructions: promptOpts.instructions } : {},
+				model: promptOpts.model,
+				maxTurns,
+				...agentProgressSummaries !== void 0 ? { agentProgressSummaries } : {},
+				...forwardSubagentText !== void 0 ? { forwardSubagentText } : {},
+				...env !== void 0 ? { env } : {},
+				thinking,
+				...effort !== void 0 ? { effort } : {},
+				...promptOpts.skills.length > 0 ? { skills: promptOpts.skills.map((skill) => skill.name) } : {},
+				...mcpServers == null ? {} : { mcpServers },
+				...permissionMode ? { permissionMode } : {},
+				...builtinToolFiltering ? { builtinToolFiltering } : {},
+				...debug ? { debug } : {},
+				...lastClaudeSessionId ? { resumeSessionId: lastClaudeSessionId } : pendingResumeFlag ? { continue: true } : {}
+			};
+			pendingResumeFlag = false;
+			channel.send(startMessage);
+			return control;
+		},
+		doContinueTurn: async (continueOpts) => {
+			const control = await prepareTurn(continueOpts);
+			if (rerunContinue && !continueOpts.abortSignal?.aborted) {
+				pendingResumeFlag = false;
+				channel.send({
+					type: "start",
+					prompt: "Continue.",
+					tools: (continueOpts.tools ?? []).map((t) => ({
+						name: t.name,
+						description: t.description,
+						inputSchema: t.inputSchema
+					})),
+					...continueOpts.responseFormat == null ? {} : { responseFormat: continueOpts.responseFormat },
+					...continueOpts.instructions ? { instructions: continueOpts.instructions } : {},
+					model: continueOpts.model,
+					maxTurns,
+					...agentProgressSummaries !== void 0 ? { agentProgressSummaries } : {},
+					...forwardSubagentText !== void 0 ? { forwardSubagentText } : {},
+					...env !== void 0 ? { env } : {},
+					thinking,
+					...effort !== void 0 ? { effort } : {},
+					...continueOpts.skills.length > 0 ? { skills: continueOpts.skills.map((skill) => skill.name) } : {},
+					...mcpServers == null ? {} : { mcpServers },
+					...permissionMode ? { permissionMode } : {},
+					...builtinToolFiltering ? { builtinToolFiltering } : {},
+					...debug ? { debug } : {},
+					...lastClaudeSessionId ? { resumeSessionId: lastClaudeSessionId } : { continue: true }
+				});
+			}
+			return control;
+		},
+		doCompact: async (customInstructions) => {
+			const text = customInstructions && customInstructions.trim() ? `/compact ${customInstructions.trim()}` : "/compact";
+			channel.send({
+				type: "user-message",
+				text
+			});
+		},
+		doDetach: async () => {
+			if (stopped) throw new Error(`claude-code session ${sessionId} is already stopped; cannot detach.`);
+			stopped = true;
+			const lastSeenEventId = await channel.suspend();
+			return {
+				type: "resume-session",
+				harnessId: "claude-code",
+				specificationVersion: "harness-v1",
+				data: {
+					...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment },
+					bridge: {
+						port: bridgePort,
+						token: bridgeToken,
+						lastSeenEventId,
+						...sandboxId == null ? {} : { sandboxId }
+					},
+					...lastClaudeSessionId ? { claudeSessionId: lastClaudeSessionId } : {}
+				}
+			};
+		},
+		doDestroy: async () => {
+			if (stopped) return stopPromise;
+			stopped = true;
+			stopPromise = (async () => {
+				channel.beginClose();
+				try {
+					if (!channel.isClosed()) channel.send({ type: "destroy" });
+				} catch {}
+				let stopTimer;
+				try {
+					if (proc) await Promise.race([proc.wait(), new Promise((resolve) => {
+						stopTimer = setTimeout(resolve, 5e3);
+						stopTimer.unref?.();
+					})]);
+				} finally {
+					if (stopTimer) clearTimeout(stopTimer);
+					try {
+						await proc?.kill();
+					} catch {}
+					channel.close();
+				}
+			})();
+			return stopPromise;
+		},
+		doStop: async () => {
+			if (stopped) throw new Error(`claude-code session ${sessionId} is already stopped; cannot stop.`);
+			stopped = true;
+			channel.beginClose();
+			const data = channel.isClosed() ? {} : await new Promise((resolve, reject) => {
+				const timer = setTimeout(() => {
+					unsub();
+					reject(/* @__PURE__ */ new Error(`claude-code session ${sessionId} did not reply to stop within 5s.`));
+				}, 5e3);
+				timer.unref?.();
+				const unsub = channel.on("bridge-stop", (msg) => {
+					clearTimeout(timer);
+					unsub();
+					resolve(msg.data);
+				});
+				try {
+					channel.send({ type: "stop" });
+				} catch (err) {
+					clearTimeout(timer);
+					unsub();
+					reject(err);
+				}
+			});
+			let stopTimer;
+			try {
+				if (proc) await Promise.race([proc.wait(), new Promise((resolve) => {
+					stopTimer = setTimeout(resolve, 5e3);
+					stopTimer.unref?.();
+				})]);
+			} finally {
+				if (stopTimer) clearTimeout(stopTimer);
+				try {
+					await proc?.kill();
+				} catch {}
+				channel.close();
+			}
+			const lifecycleData = data != null && typeof data === "object" && !Array.isArray(data) ? { ...data } : {};
+			return {
+				type: "resume-session",
+				harnessId: "claude-code",
+				specificationVersion: "harness-v1",
+				data: {
+					...lastClaudeSessionId ? { claudeSessionId: lastClaudeSessionId } : {},
+					...lifecycleData,
+					...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment }
+				}
+			};
+		},
+		doSuspendTurn: async () => {
+			if (stopped) throw new Error(`claude-code session ${sessionId} is stopped; cannot suspend.`);
+			stopped = true;
+			const lastSeenEventId = await channel.suspend();
+			return {
+				type: "continue-turn",
+				harnessId: "claude-code",
+				specificationVersion: "harness-v1",
+				data: {
+					...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment },
+					bridge: {
+						port: bridgePort,
+						token: bridgeToken,
+						lastSeenEventId,
+						...sandboxId == null ? {} : { sandboxId }
+					},
+					...lastClaudeSessionId ? { claudeSessionId: lastClaudeSessionId } : {}
+				}
+			};
+		}
+	};
 }
 function extractUserText(prompt) {
-  if (typeof prompt === "string") return prompt;
-  const { content } = prompt;
-  if (typeof content === "string") return content;
-  const parts = [];
-  for (const part of content) {
-    if (part.type !== "text") {
-      throw new HarnessCapabilityUnsupportedError({
-        harnessId: "claude-code",
-        message: `The claude-code harness does not yet support user message parts of type '${part.type}'. Pass a string or a user message whose content contains only text parts.`
-      });
-    }
-    parts.push(part.text);
-  }
-  return parts.join("\n\n");
+	if (typeof prompt === "string") return prompt;
+	const { content } = prompt;
+	if (typeof content === "string") return content;
+	const parts = [];
+	for (const part of content) {
+		if (part.type !== "text") throw new HarnessCapabilityUnsupportedError({
+			harnessId: "claude-code",
+			message: `The claude-code harness does not yet support user message parts of type '${part.type}'. Pass a string or a user message whose content contains only text parts.`
+		});
+		parts.push(part.text);
+	}
+	return parts.join("\n\n");
 }
+//#endregion
+//#region src/index.ts
+/**
+* Default `claude-code` harness instance with no overrides — suitable for the
+* common case where the underlying `claude` CLI's defaults are fine.
+* Equivalent to `createClaudeCode()`.
+*/
+const claudeCode = createClaudeCode();
+//#endregion
+export { VERSION, claudeCode, createClaudeCode };
 
-// src/index.ts
-var claudeCode = createClaudeCode();
-export {
-  VERSION,
-  claudeCode,
-  createClaudeCode
-};
 //# sourceMappingURL=index.js.map