@gajae-code/coding-agent 0.10.2 → 0.11.0

package/dist/types/tools/browser/benchmark/run-suite.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Offline stealth benchmark harness (plan Phase 1).
+ *
+ * Drives a puppeteer Page (already stealth-patched by the browser tool) against
+ * self-contained offline detector fixtures and collects normalized results. The
+ * navigation/evaluation is injected so this stays unit-testable without a real
+ * browser; the integration test wires a live puppeteer Page.
+ */
+import type { Page } from "puppeteer-core";
+import type { DetectorResult } from "./detector-report";
+/** Minimal surface of a puppeteer Page that the harness needs. */
+export type SuitePage = Pick<Page, "goto" | "evaluate">;
+export interface SuiteFixture {
+    /** file:// (or http://) URL of the offline detector fixture. */
+    url: string;
+}
+/** Navigate to each fixture and collect a normalized DetectorResult per fixture. */
+export declare function runOfflineSuite(page: SuitePage, fixtures: readonly SuiteFixture[]): Promise<DetectorResult[]>;

package/dist/types/tools/browser/launch.d.ts

@@ -20,6 +20,25 @@ export interface LaunchHeadlessOptions {
         height: number;
         deviceScaleFactor?: number;
     };
+    /**
+     * Optional isolated warm-up profile directory (see profile-reuse.ts). When
+     * set, the headless browser launches against this isolated copy of the user's
+     * real Chrome profile so sessions inherit real cookies/storage/cache for
+     * stronger stealth. Callers resolve this via resolveProfileReuse and MUST
+     * pass an isolated copy, never a live profile dir.
+     */
+    profileWarmupDir?: string;
+    /**
+     * Optional opt-in geo alignment (see settings browser.geo.*). When set, the
+     * browser is launched with a matching timezone (TZ env) and/or UI language
+     * (--lang) at the source. Default unset = strict no-op: the real environment
+     * timezone/locale are preserved (never half-spoof). Only align these to a
+     * coherent value (e.g. one matching a configured proxy egress).
+     */
+    geo?: {
+        timezone?: string;
+        locale?: string;
+    };
 }
 export declare function launchHeadlessBrowser(opts: LaunchHeadlessOptions): Promise<Browser>;
 export declare function applyViewport(page: Page, viewport?: {
@@ -54,6 +73,9 @@ export declare function buildStealthInjectionScriptForTest(scripts?: readonly st
 export declare function applyStealthPatches(browser: Browser, page: Page, state: {
     browserSession: CDPSession | null;
     override: UserAgentOverride | null;
+}, geo?: {
+    readonly timezone?: string;
+    readonly locale?: string;
 }): Promise<void>;
 export declare function targetSupportsUserAgentOverrideForTest(target: Target): boolean;
 export declare function configureUserAgentTargetsForTest(browser: Browser, state: {

package/dist/types/tools/browser/profile-discovery.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Default Chrome profile discovery (plan Phase 2 wiring).
+ *
+ * Locates the user's real Chrome "Default" profile directory per OS so the
+ * default headless launch path can warm up synthetic sessions from an isolated
+ * copy of it (see profile-warmup.ts + profile-posture.ts). Pure path logic with
+ * an injectable existence check, so it is unit-testable without touching the
+ * real filesystem.
+ */
+export interface DiscoveryEnv {
+    platform: NodeJS.Platform;
+    home: string;
+    /** Injectable for tests; defaults to fs.existsSync at call sites. */
+    exists: (p: string) => boolean;
+    /** Windows LOCALAPPDATA override (tests / non-default installs). */
+    localAppData?: string;
+}
+/** Candidate Chrome user-data roots for the platform (most common first). */
+export declare function chromeUserDataRoots(env: DiscoveryEnv): string[];
+export interface DiscoveredProfile {
+    userDataDir: string;
+    profileDirectory: string;
+    profileDir: string;
+}
+/**
+ * Discover the default Chrome profile, or null when none is present.
+ * Only returns a profile whose directory actually exists.
+ */
+export declare function discoverDefaultChromeProfile(env: DiscoveryEnv, profileDirectory?: string): DiscoveredProfile | null;
+/** Convenience wrapper using the live OS environment + fs. */
+export declare function defaultDiscoveryEnv(exists: (p: string) => boolean): DiscoveryEnv;

package/dist/types/tools/browser/profile-posture.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Auto-default profile-reuse posture decision (plan Phase 2, Intent Reconciliation).
+ *
+ * User-confirmed policy: when a usable real Chrome profile is available, the
+ * browser tool uses it automatically (AUTO), emits a warning, and falls back to
+ * synthetic stealth when unavailable. The posture is overridable via a setting.
+ * This is pure decision logic (no browser, no filesystem side effects) so the
+ * launch/attach layer can call it and it can be unit-tested deterministically.
+ */
+/** Configured posture: `auto` (default) prefers the real profile; `opt-in` stays synthetic unless explicitly asked. */
+export type ProfileReusePosture = "auto" | "opt-in";
+export declare const DEFAULT_PROFILE_REUSE_POSTURE: ProfileReusePosture;
+export interface PostureInputs {
+    /** Configured posture; defaults to `auto` when unset. */
+    posture?: ProfileReusePosture;
+    /** A usable real Chrome profile was detected and is attachable/safe to copy. */
+    realProfileAvailable: boolean;
+    /** Caller explicitly requested real-profile reuse for this run (e.g. app.browser === "chrome"). */
+    explicitlyRequested?: boolean;
+}
+export interface PostureDecision {
+    /** `real` = use the (isolated copy of the) real profile; `synthetic` = synthetic stealth session. */
+    mode: "real" | "synthetic";
+    /** User-facing warning to emit when real credentials/state are about to be used. */
+    warning: string | null;
+    /** Machine-readable reason for logs/audit. */
+    reason: "auto-real" | "explicit-real" | "synthetic-fallback" | "synthetic-opt-in";
+}
+/**
+ * Decide whether to reuse the real profile or run synthetic.
+ *
+ * - `auto` + available            -> real (with warning)
+ * - `opt-in` + explicitly asked   -> real (with warning)
+ * - `opt-in` (no explicit ask)    -> synthetic
+ * - not available                 -> synthetic (fallback), even under `auto`
+ */
+export declare function decideProfilePosture(inputs: PostureInputs): PostureDecision;

package/dist/types/tools/browser/profile-reuse.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Profile-reuse orchestration (plan Phase 2 wiring).
+ *
+ * Single entry point the launch path calls to decide, for a default headless
+ * session, whether to warm up from an isolated copy of the user's real Chrome
+ * profile. Ties together discovery + posture + isolated warm-up. Filesystem
+ * effects (the copy) are performed only when the posture resolves to `real`.
+ * The heavy pieces are injectable so this is unit-testable without a browser.
+ */
+import { type DiscoveredProfile, type DiscoveryEnv } from "./profile-discovery";
+import { type ProfileReusePosture } from "./profile-posture";
+import { type WarmupManifest } from "./profile-warmup";
+export interface ResolveProfileReuseInputs {
+    posture?: ProfileReusePosture;
+    /** Caller explicitly requested real-profile reuse (e.g. app.browser === "chrome"). */
+    explicitlyRequested?: boolean;
+    discoveryEnv: DiscoveryEnv;
+    /** Destination for the isolated warm-up copy; defaults to an ephemeral temp dir. */
+    destDir?: string;
+    /** Injectable copier (defaults to collectWarmupArtifacts). */
+    copy?: (sourceProfileDir: string, destDir: string) => WarmupManifest;
+    /** Injectable temp-dir factory (defaults to fs.mkdtemp under os.tmpdir()). */
+    makeTempDir?: () => string;
+}
+export interface ProfileReuseResult {
+    mode: "real" | "synthetic";
+    reason: string;
+    warning: string | null;
+    discovered: DiscoveredProfile | null;
+    /** Isolated copy directory when mode === "real", else null. */
+    warmupDir: string | null;
+    manifest: WarmupManifest | null;
+}
+/**
+ * Resolve profile reuse for a default session. When the posture resolves to
+ * `real`, copies an allowlisted, lock-free subset of the discovered profile
+ * into an isolated dir and returns that dir for the launcher to use.
+ */
+export declare function resolveProfileReuse(inputs: ResolveProfileReuseInputs): ProfileReuseResult;

package/dist/types/tools/browser/profile-warmup.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Isolated profile warm-up (plan Phase 2, R-C3).
+ *
+ * Aggressive real-profile reuse seeds a session with the user's cookies /
+ * localStorage / cache. To stay safe (never lock or corrupt the live browser
+ * session) we NEVER bind the source profile directly: we copy an allowlisted
+ * subset of artifacts into an ephemeral, isolated directory and drive Chromium
+ * against that copy. Chromium single-instance lock files (SingletonLock/Socket/
+ * Cookie) are explicitly excluded so the isolated copy can never contend with a
+ * running browser.
+ *
+ * This module is pure filesystem logic (no browser, no network) so it is
+ * deterministically unit-testable.
+ */
+/** Chromium single-instance lock artifacts — must never be copied. */
+export declare const CHROME_LOCK_ARTIFACTS: readonly ["SingletonLock", "SingletonSocket", "SingletonCookie"];
+/**
+ * Profile-relative artifacts worth seeding for warm-up. Kept intentionally
+ * small: session state (cookies, storage) plus a light cache. Anything not
+ * listed is skipped, which also keeps the isolated copy cheap.
+ */
+export declare const WARMUP_ARTIFACTS: readonly ["Cookies", "Cookies-journal", "Local Storage", "Session Storage", "IndexedDB", "Network", "Preferences"];
+export interface WarmupManifest {
+    sourceProfileDir: string;
+    destDir: string;
+    copied: string[];
+    skippedMissing: string[];
+    /** Always empty unless a lock artifact was seen (never copied). */
+    excludedLocks: string[];
+}
+/**
+ * Copy warm-up artifacts from `sourceProfileDir` into an isolated `destDir`.
+ *
+ * Guarantees:
+ * - The source profile is only ever read, never written or locked.
+ * - Chromium lock artifacts are never copied (recorded in `excludedLocks`).
+ * - Missing artifacts are skipped, not fatal (recorded in `skippedMissing`).
+ */
+export declare function collectWarmupArtifacts(sourceProfileDir: string, destDir: string): WarmupManifest;

package/dist/types/tools/browser/registry.d.ts

@@ -1,6 +1,7 @@
 import type { Subprocess } from "bun";
 import type { Browser, CDPSession } from "puppeteer-core";
 import { type UserAgentOverride } from "./launch";
+import type { ProfileReusePosture } from "./profile-posture";
 export type BrowserKind = {
     kind: "headless";
     headless: boolean;
@@ -20,9 +21,14 @@ export type BrowserKind = {
     cdpUrl: string;
 };
 export type BrowserKindTag = BrowserKind["kind"];
+export interface BrowserGeo {
+    readonly timezone?: string;
+    readonly locale?: string;
+}
 export interface BrowserHandle {
     key: string;
     kind: BrowserKind;
+    readonly geo?: BrowserGeo;
     browser: Browser;
     cdpUrl?: string;
     pid?: number;
@@ -45,7 +51,20 @@ export interface AcquireBrowserOptions {
     };
     appArgs?: string[];
     signal?: AbortSignal;
+    /**
+     * Profile-reuse posture for the default headless path (from settings
+     * `browser.profileReuse`, resolved by the settings-aware caller). When set,
+     * the headless browser may warm up from an isolated copy of the user's real
+     * Chrome profile (see profile-reuse.ts). Omitted = synthetic session.
+     */
+    profileReuse?: ProfileReusePosture;
+    /**
+     * Opt-in geo alignment for the default headless path (from settings
+     * `browser.geo.*`). Default unset = no-op (real timezone/locale preserved).
+     */
+    geo?: BrowserGeo;
 }
+export declare function browserKeyForTest(kind: BrowserKind, opts: Pick<AcquireBrowserOptions, "geo" | "profileReuse">): string;
 export declare function acquireBrowser(kind: BrowserKind, opts: AcquireBrowserOptions): Promise<BrowserHandle>;
 export declare function buildChromeProfileLaunchArgs(kind: SpawnedChromeProfileKind, appArgs: readonly string[] | undefined, port: number): string[];
 export declare function buildChromeProfileLaunchArgsForTest(kind: SpawnedChromeProfileKind, appArgs: readonly string[] | undefined, port: number): string[];

package/dist/types/tools/browser/tab-protocol.d.ts

@@ -47,6 +47,10 @@ export type WorkerInitPayload = {
         height: number;
         deviceScaleFactor?: number;
     };
+    geo?: {
+        readonly timezone?: string;
+        readonly locale?: string;
+    };
     dialogs?: "accept" | "dismiss";
     url?: string;
     waitUntil?: "load" | "domcontentloaded" | "networkidle0" | "networkidle2";

package/dist/types/tools/index.d.ts

@@ -5,7 +5,7 @@ import type { Settings } from "../config/settings";
 import type { Skill } from "../extensibility/skills";
 import type { GoalModeState, GoalRuntime } from "../goals";
 import type { HindsightSessionState } from "../hindsight/state";
-import type { WorkflowGateEmitter } from "../modes/shared/agent-wire/unattended-session";
+import type { WorkflowGateEmitter } from "../modes/shared/agent-wire/workflow-gate-broker";
 import type { PlanModeState } from "../plan-mode/state";
 import type { AgentRegistry } from "../registry/agent-registry";
 import type { ForkContextSeed, ForkContextSeedOptions, PurgeQueuedCustomMessagesResult } from "../session/agent-session";
@@ -125,9 +125,10 @@ export interface AskRemoteReceipt {
 }
 export type AskAnswerSourceResult = AskRemoteReceipt | string | undefined;
 /**
- * Source of remote answers. `awaitAnswer` remains the legacy wire for existing
- * integrations; typed sources opt into `awaitAnswerRequest`. This keeps an old
- * string-only source from accidentally acquiring acknowledgement authority.
+ * Source of remote answers for interactive asks. `awaitAnswer` remains the legacy
+ * wire for existing integrations; typed sources opt into `awaitAnswerRequest`.
+ * This keeps a string-only source from accidentally acquiring acknowledgement
+ * authority while allowing SDK-routed interactions to settle durably.
  */
 export interface AskAnswerSource {
     awaitAnswer(question: string, options: string[], signal?: AbortSignal): Promise<string | undefined>;
@@ -232,12 +233,11 @@ export interface ToolSession {
     getPlanModeState?: () => PlanModeState | undefined;
     /** Goal mode state (if active or paused) */
     getGoalModeState?: () => GoalModeState | undefined;
-    /** Unattended workflow-gate emitter (present only when unattended mode is negotiated). */
+    /** SDK workflow-gate emitter, when a remote gate responder is connected. */
     getWorkflowGateEmitter?: () => WorkflowGateEmitter | undefined;
     /**
-     * Optional remote answer source for interactive asks. When present, the ask
-     * tool races the local UI selection against a remote answer (e.g. a Telegram
-     * reply via the notifications SDK) so asks can be answered without RPC mode.
+     * Optional SDK-routed answer source for interactive asks. When present, the
+     * tool races the local UI selection against the remote SDK answer.
      * No-op when undefined: the ask path behaves exactly as before.
      */
     getAskAnswerSource?: () => AskAnswerSource | undefined;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.10.2",
+	"version": "0.11.0",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -29,7 +29,7 @@
 	},
 	"scripts": {
 		"build": "bun scripts/build-binary.ts",
-		"check": "biome check . && bun run check:types",
+		"check": "biome check . && bun run verify:sdk-canonicalization && bun run check:types",
 		"check:types": "tsc -p tsconfig.json --noEmit",
 		"lint": "biome lint .",
 		"test": "bun test",
@@ -43,18 +43,21 @@
 		"prepack": "bun scripts/generate-docs-index.ts",
 		"generate-template": "bun scripts/generate-template.ts",
 		"install:defaults": "bun src/cli.ts setup defaults",
-		"verify:insane-vendor": "bun scripts/verify-insane-vendor.ts"
+		"verify:insane-vendor": "bun scripts/verify-insane-vendor.ts",
+		"verify:sdk-canonicalization": "bun scripts/verify-gjc-sdk-canonicalization.ts",
+		"check:sdk-closure": "bun scripts/generate-sdk-operation-inventory.ts --check && bun scripts/generate-sdk-adapter-parity-manifest.ts --check && bun scripts/run-test-manifest.ts test/manifests/sdk-adapter-parity-v1.json && bun scripts/generate-telegram-baseline-manifest.ts --check && bun scripts/run-test-manifest.ts test/manifests/telegram-baseline-v1.json && bun test test/sdk-downgrade-rollback.test.ts test/sdk-downgrade-unknown-version.test.ts && bun scripts/verify-gjc-sdk-canonicalization.ts --self-test && bun scripts/verify-gjc-sdk-canonicalization.ts && bun scripts/verify-gjc-sdk-rename.ts"
 	},
 	"dependencies": {
 		"@agentclientprotocol/sdk": "1.2.1",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.10.2",
-		"@gajae-code/agent-core": "0.10.2",
-		"@gajae-code/ai": "0.10.2",
-		"@gajae-code/natives": "0.10.2",
-		"@gajae-code/tui": "0.10.2",
-		"@gajae-code/utils": "0.10.2",
+		"@gajae-code/stats": "0.11.0",
+		"@gajae-code/agent-core": "0.11.0",
+		"@gajae-code/ai": "0.11.0",
+		"@gajae-code/bridge-client": "0.11.0",
+		"@gajae-code/natives": "0.11.0",
+		"@gajae-code/tui": "0.11.0",
+		"@gajae-code/utils": "0.11.0",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",
@@ -71,6 +74,9 @@
 		"zod": "4.4.3"
 	},
 	"devDependencies": {
+		"@babel/traverse": "^7.29.0",
+		"@babel/types": "^7.29.0",
+		"@types/babel__traverse": "^7.28.0",
 		"@types/bun": "^1.3.14",
 		"@types/ws": "^8.5.13"
 	},
@@ -115,6 +121,24 @@
 		"./modes/components/runtime-mcp-add-wizard": null,
 		"./modes/controllers/runtime-mcp-command-controller": null,
 		"./slash-commands/helpers/mcp": null,
+		"./sdk": {
+			"types": "./dist/types/sdk/index.d.ts",
+			"import": "./src/sdk/index.ts"
+		},
+		"./sdk/models": null,
+		"./sdk/models.js": null,
+		"./sdk/lifecycle-session": null,
+		"./sdk/lifecycle-session.js": null,
+		"./sdk/startup-capability": null,
+		"./sdk/startup-capability.js": null,
+		"./sdk/bus": {
+			"types": "./dist/types/sdk/bus/index.d.ts",
+			"import": "./src/sdk/bus/index.ts"
+		},
+		"./sdk/bus/*": {
+			"types": "./dist/types/sdk/bus/*.d.ts",
+			"import": "./src/sdk/bus/*.ts"
+		},
 		"./*": {
 			"types": "./dist/types/*.d.ts",
 			"import": "./src/*.ts"
@@ -395,6 +419,7 @@
 			"types": "./dist/types/hindsight/*.d.ts",
 			"import": "./src/hindsight/*.ts"
 		},
+		"./modes/shared/agent-wire/*": null,
 		"./modes": {
 			"types": "./dist/types/modes/index.d.ts",
 			"import": "./src/modes/index.ts"
@@ -439,10 +464,6 @@
 			"types": "./dist/types/modes/controllers/*.d.ts",
 			"import": "./src/modes/controllers/*.ts"
 		},
-		"./modes/rpc/*": {
-			"types": "./dist/types/modes/rpc/*.d.ts",
-			"import": "./src/modes/rpc/*.ts"
-		},
 		"./modes/theme/*": {
 			"types": "./dist/types/modes/theme/*.d.ts",
 			"import": "./src/modes/theme/*.ts"

package/scripts/build-sdk-package-smoke.ts

@@ -0,0 +1,94 @@
+#!/usr/bin/env bun
+
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+const packageDir = path.resolve(import.meta.dir, "..");
+const packageName = "@gajae-code/coding-agent";
+const aiPackageDir = path.resolve(packageDir, "../ai");
+const bridgeClientPackageDir = path.resolve(packageDir, "../bridge-client");
+const manifestsDir = path.join(packageDir, "test/manifests");
+const baselinePath = path.join(manifestsDir, "sdk-public-surface-v1.json");
+const generatedPath = path.join(manifestsDir, "sdk-public-surface.generated.json");
+
+type Surface = { root: string[]; sdk: string[] };
+
+function run(command: string[], cwd: string): string {
+	const result = Bun.spawnSync(command, { cwd, stdout: "pipe", stderr: "pipe" });
+	if (result.exitCode !== 0) {
+		throw new Error(`${command.join(" ")} failed:\n${new TextDecoder().decode(result.stderr)}`);
+	}
+	return new TextDecoder().decode(result.stdout).trim();
+}
+
+function assertExport(module: Record<string, unknown>, name: string, subpath: string): void {
+	if (!(name in module)) throw new Error(`${subpath} does not export ${name}`);
+}
+
+async function runSmoke(): Promise<Surface> {
+	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "gjc-sdk-package-smoke-"));
+	try {
+		const aiTarball = run(["bun", "pm", "pack", "--destination", tempDir, "--quiet"], aiPackageDir);
+		const bridgeClientTarball = run(
+			["bun", "pm", "pack", "--destination", tempDir, "--quiet"],
+			bridgeClientPackageDir,
+		);
+		const codingAgentTarball = run(["bun", "pm", "pack", "--destination", tempDir, "--quiet"], packageDir);
+		const aiTarballPath = path.isAbsolute(aiTarball) ? aiTarball : path.join(aiPackageDir, aiTarball);
+		const bridgeClientTarballPath = path.isAbsolute(bridgeClientTarball)
+			? bridgeClientTarball
+			: path.join(bridgeClientPackageDir, bridgeClientTarball);
+		const codingAgentTarballPath = path.isAbsolute(codingAgentTarball)
+			? codingAgentTarball
+			: path.join(packageDir, codingAgentTarball);
+		await fs.writeFile(
+			path.join(tempDir, "package.json"),
+			JSON.stringify(
+				{
+					name: "sdk-smoke",
+					private: true,
+					dependencies: {
+						"@gajae-code/ai": `file:${aiTarballPath}`,
+						"@gajae-code/bridge-client": `file:${bridgeClientTarballPath}`,
+						[packageName]: `file:${codingAgentTarballPath}`,
+					},
+					overrides: {
+						"@gajae-code/ai": `file:${aiTarballPath}`,
+						"@gajae-code/bridge-client": `file:${bridgeClientTarballPath}`,
+					},
+				},
+				null,
+				2,
+			),
+		);
+		// Install the matching packed workspace artifacts so the smoke test exercises the
+		// release dependency boundary without falling back to an older registry package.
+		run(["bun", "install", "--ignore-scripts"], tempDir);
+		const probePath = path.join(tempDir, "probe.ts");
+		await fs.writeFile(
+			probePath,
+			`import * as root from ${JSON.stringify(packageName)};\nimport * as sdk from ${JSON.stringify(`${packageName}/sdk`)};\nimport * as bus from ${JSON.stringify(`${packageName}/sdk/bus`)};\nimport * as bridgeClient from "@gajae-code/bridge-client";\nconst required = [[root, "createAgentSession", "root"], [sdk, "createAgentSession", "sdk"], [bus, "createNotificationsExtension", "sdk/bus"], [sdk, "SdkClient", "sdk"], [bridgeClient, "SdkClient", "bridge-client"]] as const;\nfor (const [module, name, subpath] of required) if (!(name in module)) throw new Error(subpath + " missing " + name);\nif (sdk.SdkClient !== bridgeClient.SdkClient) throw new Error("SdkClient class identity differs between sdk and bridge-client");\nprocess.stdout.write(JSON.stringify({ root: Object.keys(root).sort(), sdk: Object.keys(sdk).sort() }));\n`,
+		);
+		const surface = JSON.parse(run(["bun", "run", probePath], tempDir)) as Surface;
+		assertExport(Object.fromEntries(surface.root.map(name => [name, true])), "createAgentSession", "root");
+		assertExport(Object.fromEntries(surface.sdk.map(name => [name, true])), "SdkClient", "sdk");
+		return { root: [...surface.root].sort(), sdk: [...surface.sdk].sort() };
+	} finally {
+		await fs.rm(tempDir, { recursive: true, force: true });
+	}
+}
+
+async function main(): Promise<void> {
+	const surface = await runSmoke();
+	await fs.mkdir(manifestsDir, { recursive: true });
+	await fs.writeFile(generatedPath, `${JSON.stringify(surface, null, 2)}\n`);
+	const baseline = JSON.parse(await Bun.file(baselinePath).text()) as Surface;
+	const removals = (Object.keys(baseline) as Array<keyof Surface>).flatMap(area =>
+		baseline[area].filter(name => !surface[area].includes(name)).map(name => `${area}.${name}`),
+	);
+	if (removals.length > 0) throw new Error(`SDK public surface removals are not allowed:\n${removals.join("\n")}`);
+	process.stdout.write(`SDK package smoke passed (root: ${surface.root.length}, sdk: ${surface.sdk.length}).\n`);
+}
+
+await main();