@junghanacs/entwurf 0.13.0 → 0.14.0

package/pi-extensions/lib/entwurf-v2-spawn.ts

@@ -1,323 +0,0 @@
-/**
- * entwurf-v2-spawn — the 5c-3a spawn-bg RESUME watcher hand (0.11 Stage 0 step 5c-3a).
- * It WIRES the real spawn + socket-observe IO onto the pure release reducer (5c-1):
- * launch the resume child, watch for the FIRST observable liveness transition, feed
- * that observation to `reduceRelease`, and release the held lock EXACTLY ONCE — or, if
- * NO observation can be obtained, RETAIN the lock and surface the evidence rather than
- * release blind. Every IO seam is an injected dep (the gate fakes it with controlled
- * promises), so the spawn→observe→release ORDERING is gate-provable without a real
- * child, socket, or timer — the same "pure-before-IO, IO-via-dep" discipline 5b/5c-2
- * used.
- *
- * The load-bearing contract (Fable 3, the whole reason 5c is sliced pure-before-IO):
- *   TIMEOUT IS NOT A RELEASE EVENT. A spawn-bg dispatch holds its per-gid lock until an
- *   OBSERVED transition — `socket-alive` (the resumed child stood its control socket up)
- *   or `child-exited` (any code, incl. null = killed by signal). A bare `observeTimeoutMs`
- *   expiry proves NOTHING (the child may stand its socket up a moment later), so releasing
- *   on it would reopen the exact double-spawn window 5a's lock exists to close. Instead the
- *   timeout RESOLVES BY OBSERVATION: kill the child, then wait a BOUNDED `killGraceMs` for
- *   the kill to produce a real `child-exited` (or a racing `socket-alive`). Only THAT
- *   observation releases. If even the grace elapses with no observation, the hand does NOT
- *   release — it returns a `lock-retained` diagnostic (released:false, with pid / socket /
- *   lockPath / timeouts) so an operator can SEE the long-held lock, exactly as F2-P2
- *   ("관측 가능해야 수용") demands. The function always returns BOUNDED — it never hangs.
- *
- * Post-spawn unexpected dep failure follows the SAME rule (GPT 5c-3a correction): once a
- * child exists, an observation-less release is forbidden. A watch/timer/kill dep that
- * throws is handled by best-effort kill → bounded attempt to OBSERVE the exit → release
- * if observed, else `lock-retained` fail-closed. There is NO direct-release escape hatch:
- * `deps.releaseLock` is reached ONLY through `reduceRelease` on a real observation event.
- *
- * Release authority is ALWAYS the LockClaim the decider handed over; the watcher reads
- * ONLY `plan.expectedSocketPath` and never re-derives a socket path or a lock by gid.
- */
-
-import type { ExecutionPlan } from "./entwurf-v2-decider.ts";
-import type { LockClaim } from "./entwurf-v2-lock.ts";
-import {
-	decideReleasePolicy,
-	initialReleaseState,
-	type ReleaseEvent,
-	type ReleasePolicy,
-	type ReleaseState,
-	reduceRelease,
-} from "./entwurf-v2-release.ts";
-
-/** The spawn-bg plan shape, narrowed from the decider's ExecutionPlan union. */
-export type SpawnBgPlan = Extract<ExecutionPlan, { transport: "spawn-bg" }>;
-
-/** A started resume child. `pid` is diagnostic-only (surfaced on a retained lock); the
- * watcher tracks the child by this opaque handle, never by gid. */
-export interface SpawnedChild {
-	pid?: number;
-}
-
-/**
- * Every IO seam is a REQUIRED dep — the hand performs ZERO IO of its own so the gate can
- * drive every observation order without a real spawn/socket/timer.
- *   - spawnChild       — launch the resume child. Resolves a handle on a STARTED process;
- *     THROWS on a spawn-time failure (→ `spawn-start-failed`: no child to watch).
- *   - awaitSocketAlive — resolve when `expectedSocketPath` becomes observable (the child
- *     stood its control socket up). NEVER resolves if the socket never appears — the
- *     timeout path handles that. Honors the abort signal so a loser can be torn down.
- *   - awaitChildExit   — resolve with the child's exit code (null = killed by signal).
- *     Honors the abort signal.
- *   - awaitTimeout     — resolve after `ms` (the observe deadline, and again the kill
- *     grace). Honors the abort signal. NOTE: a timeout is NEVER fed to the reducer.
- *   - killChild        — terminate the started child. Used ONLY to escalate a timeout (or
- *     a post-spawn dep failure) into a real `child-exited`; it is never a release itself.
- *   - releaseLock      — release the held claim; reached ONLY via reduceRelease, at most
- *     once, only on a real observation event.
- *   - killGraceMs      — bounded wait, after a kill, for the resulting observation. Keeps
- *     the watcher from hanging on a zombie: if it elapses, the lock is RETAINED (surfaced),
- *     not released. A watcher-policy constant (NOT a routing decision — so it lives on the
- *     dep, not the decider's plan).
- */
-export interface SpawnBgResumeDeps {
-	spawnChild: (plan: SpawnBgPlan) => Promise<SpawnedChild>;
-	awaitSocketAlive: (socketPath: string, signal: AbortSignal) => Promise<void>;
-	awaitChildExit: (child: SpawnedChild, signal: AbortSignal) => Promise<number | null>;
-	awaitTimeout: (ms: number, signal: AbortSignal) => Promise<void>;
-	killChild: (child: SpawnedChild) => void;
-	releaseLock: (lock: LockClaim) => void;
-	killGraceMs: number;
-}
-
-/** Evidence carried on a `lock-retained` outcome so an operator can SEE (and clear) the
- * lock that no observation released. */
-export interface SpawnRetainedDiagnostic {
-	targetGardenId: string;
-	pid?: number;
-	expectedSocketPath: string;
-	lockPath: string;
-	observeTimeoutMs: number;
-	killGraceMs: number;
-}
-
-/**
- * The terminal outcome of a spawn-bg resume watch. The three RELEASED outcomes each fed
- * exactly one observation event to the reducer; the `lock-retained` outcome fed NONE (it
- * is the observation-less fail-closed — `released:false`, lock left for the operator).
- *   - socket-alive       — the resumed child stood its socket up.
- *   - child-exited        — the child exited (any code; null = signal/kill).
- *   - spawn-start-failed  — the child never started (spawnChild threw); nothing to watch.
- *   - lock-retained       — no observation was obtainable (kill grace elapsed, or a
- *     post-spawn dep failed and the exit could not be observed). Lock NOT released.
- */
-export type SpawnBgResumeResult =
-	| { kind: "socket-alive"; released: true; pid?: number }
-	| { kind: "child-exited"; released: true; exitCode: number | null; pid?: number }
-	| { kind: "spawn-start-failed"; released: true; error: string }
-	| {
-			kind: "lock-retained";
-			released: false;
-			reason: "kill-unconfirmed" | "observe-failed";
-			error?: string;
-			diagnostic: SpawnRetainedDiagnostic;
-	  };
-
-// An internal tag for the observation race: which source settled first.
-type Observation = { tag: "socket" } | { tag: "exit"; code: number | null } | { tag: "timeout" };
-
-function tagSocket(p: Promise<void>): Promise<Observation> {
-	return p.then(() => ({ tag: "socket" }) as const);
-}
-function tagExit(p: Promise<number | null>): Promise<Observation> {
-	return p.then((code) => ({ tag: "exit", code }) as const);
-}
-function tagTimeout(p: Promise<void>): Promise<Observation> {
-	return p.then(() => ({ tag: "timeout" }) as const);
-}
-
-function errMsg(err: unknown): string {
-	return err instanceof Error ? err.message : String(err);
-}
-
-/** Swallow a watcher promise's eventual rejection when it is abandoned without a race
- * handler (the S1 sync-throw path tears down before the race attaches one), so an aborted
- * loser cannot surface as an unhandledRejection. A no-op when the promise never started. */
-function defuse(p: Promise<unknown> | undefined): void {
-	if (p) void p.catch(() => {});
-}
-
-/**
- * Launch a spawn-bg resume child and watch for the first observable liveness transition,
- * releasing the held lock EXACTLY ONCE on that observation — or RETAINING the lock (with
- * surfaced evidence) if no observation can be obtained. `lock` MUST be the in-domain claim
- * the decider handed over — `decideReleasePolicy` throws if it is null or paired with the
- * wrong gid (a mis-wire is fail-loud, not a runtime branch). Always returns bounded.
- *
- * A `releaseLock` throw on a RELEASED path propagates honestly (the observation already
- * happened, so the caller must NOT re-spawn; the lock is dirty and needs manual cleanup —
- * 5b masking direction). Such a throw is the ONE non-result exit; every other terminal
- * state is a returned `SpawnBgResumeResult`.
- */
-export async function executeSpawnBgResume(
-	plan: SpawnBgPlan,
-	lock: LockClaim | null,
-	deps: SpawnBgResumeDeps,
-): Promise<SpawnBgResumeResult> {
-	// Throws on a null / mis-paired lock (？7 + gid invariants). After this the spawn-bg
-	// policy is release-after-spawn-observation and the lock is non-null.
-	const policy: ReleasePolicy = decideReleasePolicy(plan, lock);
-	const held = lock as LockClaim;
-
-	let state: ReleaseState = initialReleaseState();
-	// The ONLY path to deps.releaseLock: fold a real observation event through the reducer
-	// and release iff (and exactly once) the reducer says so. No direct-release hatch.
-	const fire = (event: ReleaseEvent): void => {
-		const r = reduceRelease(policy, state, event);
-		state = r.state;
-		if (r.shouldRelease) deps.releaseLock(held);
-	};
-
-	// Spawn. A throw here means NO child exists → spawn-start-failed releases (nothing to
-	// watch; keeping the lock would pin the gid forever). No child means no lock-leak risk.
-	let child: SpawnedChild;
-	try {
-		child = await deps.spawnChild(plan);
-	} catch (err) {
-		fire({ kind: "spawn-start-failed", error: errMsg(err) });
-		return { kind: "spawn-start-failed", released: true, error: errMsg(err) };
-	}
-
-	const controller = new AbortController();
-	const { signal } = controller;
-	// Created ONCE and reused across the primary race and the kill-grace race; in the
-	// timeout branch both are still pending (timeout won), so re-racing them is safe.
-	//
-	// S1 (Fable 2차): the creation is in its OWN try because a watch dep can throw
-	// SYNCHRONOUSLY (a buggy dep that throws where it must RETURN a Promise — the same grade
-	// the send hand's case-13 backstop covers). The child already exists, so this is a
-	// post-spawn failure and the SAME rule applies: an observation-less release is forbidden.
-	// Best-effort kill, defuse any watcher that DID start (so its later rejection is not
-	// unhandled), tear down, and fail-closed to a retained diagnostic. We do NOT try to
-	// observe the exit — awaitChildExit may itself be the thrower; retained is the honest
-	// floor. (The async-rejection path is handled later by the race catch → backstop.)
-	let socketP!: Promise<Observation>;
-	let exitP!: Promise<Observation>;
-	try {
-		socketP = tagSocket(deps.awaitSocketAlive(plan.expectedSocketPath, signal));
-		exitP = tagExit(deps.awaitChildExit(child, signal));
-	} catch (err) {
-		try {
-			deps.killChild(child);
-		} catch {
-			// best-effort
-		}
-		controller.abort();
-		defuse(socketP);
-		defuse(exitP);
-		return retained(plan, child, "observe-failed", deps.killGraceMs, held.lockPath, errMsg(err));
-	}
-
-	try {
-		// Primary observation race. `timeout` participates but is NEVER a release event.
-		let first: Observation;
-		try {
-			const timeoutP = tagTimeout(deps.awaitTimeout(plan.observeTimeoutMs, signal));
-			first = await Promise.race([socketP, exitP, timeoutP]);
-		} catch (err) {
-			// A watch/timer dep rejected BEFORE any observation → post-spawn backstop.
-			return await backstop(plan, deps, child, held.lockPath, exitP, signal, fire, errMsg(err));
-		}
-
-		if (first.tag === "socket") {
-			fire({ kind: "socket-alive" });
-			return { kind: "socket-alive", released: true, pid: child.pid };
-		}
-		if (first.tag === "exit") {
-			fire({ kind: "child-exited", code: first.code });
-			return { kind: "child-exited", released: true, exitCode: first.code, pid: child.pid };
-		}
-
-		// first.tag === "timeout": NOT a release. Escalate to a kill, then wait a BOUNDED
-		// grace for the kill to produce a real child-exited (or a racing socket-alive).
-		try {
-			deps.killChild(child);
-		} catch {
-			// kill itself threw — still try to observe within the grace; if nothing, retain.
-		}
-		let second: Observation;
-		try {
-			const graceP = tagTimeout(deps.awaitTimeout(deps.killGraceMs, signal));
-			second = await Promise.race([socketP, exitP, graceP]);
-		} catch (err) {
-			// A dep rejected during the grace → cannot confirm; retain the lock, surface it.
-			return retained(plan, child, "kill-unconfirmed", deps.killGraceMs, held.lockPath, errMsg(err));
-		}
-		if (second.tag === "socket") {
-			fire({ kind: "socket-alive" });
-			return { kind: "socket-alive", released: true, pid: child.pid };
-		}
-		if (second.tag === "exit") {
-			fire({ kind: "child-exited", code: second.code });
-			return { kind: "child-exited", released: true, exitCode: second.code, pid: child.pid };
-		}
-		// Grace elapsed with NO observation → the kill is unconfirmed. Do NOT release blind;
-		// retain the lock and surface the evidence (bounded return, never a hang).
-		return retained(plan, child, "kill-unconfirmed", deps.killGraceMs, held.lockPath, undefined);
-	} finally {
-		// Tear down the losing watchers (their timers / FS watches) on every exit.
-		controller.abort();
-	}
-}
-
-/**
- * Post-spawn backstop (GPT 5c-3a correction): a child exists but a watch/timer dep threw
- * before any observation. An observation-less release is forbidden (it reopens the
- * double-spawn window), so: best-effort kill → BOUNDED attempt to OBSERVE the exit →
- * release iff observed, else `lock-retained` fail-closed. We race ONLY the exit (not the
- * already-suspect socket watcher) plus a fresh grace timer.
- */
-async function backstop(
-	plan: SpawnBgPlan,
-	deps: SpawnBgResumeDeps,
-	child: SpawnedChild,
-	lockPath: string,
-	exitP: Promise<Observation>,
-	signal: AbortSignal,
-	fire: (event: ReleaseEvent) => void,
-	originalError: string,
-): Promise<SpawnBgResumeResult> {
-	try {
-		deps.killChild(child);
-	} catch {
-		// best-effort
-	}
-	try {
-		const graceP = tagTimeout(deps.awaitTimeout(deps.killGraceMs, signal));
-		const obs = await Promise.race([exitP, graceP]);
-		if (obs.tag === "exit") {
-			fire({ kind: "child-exited", code: obs.code });
-			return { kind: "child-exited", released: true, exitCode: obs.code, pid: child.pid };
-		}
-	} catch {
-		// exit watcher itself was the failing dep (or threw again) → fall through to retain.
-	}
-	return retained(plan, child, "observe-failed", deps.killGraceMs, lockPath, originalError);
-}
-
-function retained(
-	plan: SpawnBgPlan,
-	child: SpawnedChild,
-	reason: "kill-unconfirmed" | "observe-failed",
-	killGraceMs: number,
-	lockPath: string,
-	error: string | undefined,
-): SpawnBgResumeResult {
-	return {
-		kind: "lock-retained",
-		released: false,
-		reason,
-		error,
-		diagnostic: {
-			targetGardenId: plan.targetGardenId,
-			pid: child.pid,
-			expectedSocketPath: plan.expectedSocketPath,
-			lockPath,
-			observeTimeoutMs: plan.observeTimeoutMs,
-			killGraceMs,
-		},
-	};
-}

package/scripts/check-acp-sdk-surface.ts

@@ -1,236 +0,0 @@
-// Deterministic gate for the S2a ACP SDK dependency surface.
-//
-// Pins the ACP runtime deps to the current behavior-oracle versions and locks
-// the peer-resolution that makes the Claude ACP adapter satisfiable:
-//
-//   @agentclientprotocol/sdk              1.3.0    wire SDK (acp-bridge import source)
-//   @agentclientprotocol/claude-agent-acp 0.62.0   Claude adapter (spawn binary)
-//   @anthropic-ai/sdk                     0.100.1  peer-resolution pin ONLY (see below)
-//
-// 2026-07-27 bump 0.61.0 → 0.62.0: the adapter's own `dist/` is byte-identical
-// across the two releases; 0.62.0 moves only its declared deps
-// (claude-agent-sdk 0.3.217 → 0.3.219; its devDep anthropic sdk, which does not
-// reach us). So this bump is a dependency refresh that carries NO adapter-code
-// change — and specifically NOT a fix for the bundled-MCP readiness race
-// (ROADMAP 🔴): 0.62.0 adds no explicit readiness fence. Effective runtime
-// behavior is NOT claimed identical: the transitive SDK moved, and MCP startup
-// lives inside it, so timing may differ — what is established is only that no
-// new fence was added.
-//
-// The anthropic SDK is NOT an API client / auth surface here. It is a direct
-// dep solely to satisfy @anthropic-ai/claude-agent-sdk@0.3.219's peer floor
-// (>=0.93.0 — re-measured at 0.3.219, unchanged from 0.3.217, so the 0.100.1
-// pin stands rather than rising mechanically); drop it and the tree resolves a stale 0.91.1 so the peer goes
-// unmet — a failure that would only surface at the first raw turn. The
-// lockfile proves the same shape. Source-level import / API-client
-// instantiation / credential use stays forbidden — asserted in layer (4).
-// (GPT hard constraint 2, revised 2026-06-18: direct dep allowed ONLY as an
-// exact peer-resolution pin; source-level use remains forbidden.)
-//
-// Layers:
-//   (1)  package.json exact pins for all three deps;
-//   (2)  pnpm-lock peer-resolution lock (adapter + claude-agent-sdk → 0.100.1);
-//   (2b) runtime peer-resolution probe (claude-agent-sdk context → 0.100.1);
-//   (3)  @agentclientprotocol/sdk value-export surface (silent-rename gate);
-//   (4)  no tracked source imports the anthropic SDK or builds an API client.
-
-import { strict as assert } from "node:assert";
-import { execFileSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, resolve } from "node:path";
-
-// Split literals so this gate's own regexes never self-match in layer (4).
-const ANTHROPIC_SDK = `@anthropic-ai/${"sdk"}`;
-const API_CLIENT_CLASS = `${"Anthropic"}`;
-
-const repoRoot = resolve(import.meta.dirname, "..");
-const read = (p: string): string => readFileSync(resolve(repoRoot, p), "utf8");
-
-// ---------------------------------------------------------------------------
-// (1) package.json — exact pins (no caret/range; S2a freezes the oracle set)
-// ---------------------------------------------------------------------------
-const pkg = JSON.parse(read("package.json")) as { dependencies?: Record<string, string> };
-const deps = pkg.dependencies ?? {};
-const PINS: Record<string, string> = {
-	"@agentclientprotocol/sdk": "1.3.0",
-	"@agentclientprotocol/claude-agent-acp": "0.62.0",
-	[ANTHROPIC_SDK]: "0.100.1",
-};
-for (const [name, ver] of Object.entries(PINS)) {
-	assert.equal(
-		deps[name],
-		ver,
-		`package.json dependencies["${name}"] must be exact "${ver}" (got "${deps[name]}") — S2a pins the current oracle versions`,
-	);
-}
-
-// ---------------------------------------------------------------------------
-// (2) pnpm-lock — peer-resolution lock
-//     The adapter and claude-agent-sdk MUST peer-resolve the anthropic SDK to
-//     0.100.1; a 0.91.1 resolution means the >=0.93.0 peer is unmet (the bug
-//     this whole pin exists to prevent).
-// ---------------------------------------------------------------------------
-const lock = read("pnpm-lock.yaml");
-assert.match(
-	lock,
-	/@agentclientprotocol\/claude-agent-acp@0\.62\.0\(@anthropic-ai\/sdk@0\.100\.1/,
-	"pnpm-lock: claude-agent-acp@0.62.0 must peer-resolve @anthropic-ai/sdk@0.100.1 (peer-pin), not the stale 0.91.1",
-);
-assert.match(
-	lock,
-	/@anthropic-ai\/claude-agent-sdk@0\.3\.219\(@anthropic-ai\/sdk@0\.100\.1/,
-	"pnpm-lock: claude-agent-sdk@0.3.219 must peer-resolve @anthropic-ai/sdk@0.100.1 — else its >=0.93.0 peer floor is unmet",
-);
-
-// ---------------------------------------------------------------------------
-// (2b) runtime peer-resolution probe — the actual Node resolver, not lock text.
-//      Layer (2) freezes the publish/install floor; this probes that the
-//      claude-agent-sdk → @anthropic-ai/sdk peer edge really resolves to
-//      0.100.1 in a live module graph. Two different failures, both needed.
-//      Note: a top-level/adapter-context resolve of the anthropic SDK may see
-//      0.91.1 (pi's own transitive) — that is normal. The edge that must be
-//      0.100.1 is the one *inside* claude-agent-sdk's context.
-// ---------------------------------------------------------------------------
-const pkgInfoFromEntry = (entryPath: string): { name: string; version: string; dir: string } => {
-	// A `<pkg>/package.json` subpath resolve can fail under "exports"; walk up
-	// from the resolved entry to the nearest package.json instead.
-	let dir = dirname(entryPath);
-	for (;;) {
-		try {
-			const pj = JSON.parse(readFileSync(resolve(dir, "package.json"), "utf8")) as {
-				name?: string;
-				version?: string;
-			};
-			if (pj.name && pj.version) return { name: pj.name, version: pj.version, dir };
-		} catch {
-			// no package.json here (or unreadable) — keep walking up.
-		}
-		const parent = dirname(dir);
-		if (parent === dir) throw new Error(`no package.json found walking up from ${entryPath}`);
-		dir = parent;
-	}
-};
-
-const rootRequire = createRequire(resolve(repoRoot, "package.json"));
-const adapterPkgJson = rootRequire.resolve("@agentclientprotocol/claude-agent-acp/package.json");
-const adapterRequire = createRequire(adapterPkgJson);
-const casEntry = adapterRequire.resolve("@anthropic-ai/claude-agent-sdk");
-const casInfo = pkgInfoFromEntry(casEntry);
-assert.equal(
-	casInfo.version,
-	"0.3.219",
-	`@anthropic-ai/claude-agent-sdk must runtime-resolve to 0.3.219 from the adapter context (got ${casInfo.version})`,
-);
-const casRequire = createRequire(resolve(casInfo.dir, "package.json"));
-const sdkEntry = casRequire.resolve(ANTHROPIC_SDK);
-const sdkInfo = pkgInfoFromEntry(sdkEntry);
-assert.equal(
-	sdkInfo.version,
-	"0.100.1",
-	`${ANTHROPIC_SDK} must peer-resolve to 0.100.1 from the claude-agent-sdk context (got ${sdkInfo.version}) — a 0.91.1 here means the >=0.93.0 peer is unmet and the raw turn would break`,
-);
-
-// ---------------------------------------------------------------------------
-// (2c) adapter-context wire-SDK + MCP-SDK runtime resolve — the ACP dep bump's
-//      real fault surface. Lock text (layer 2) freezes the publish floor; these probe
-//      the LIVE module graph the adapter actually traverses: the adapter must SEE
-//      the same wire SDK the backend imports at root (1.3.0), and claude-agent-sdk
-//      must SEE its declared MCP peer (1.29.x). Cheap edges, both newly relevant
-//      after the 0.54→0.61 / 1.1→1.3 bump.
-// ---------------------------------------------------------------------------
-const wireEntry = adapterRequire.resolve("@agentclientprotocol/sdk");
-const wireInfo = pkgInfoFromEntry(wireEntry);
-assert.equal(
-	wireInfo.version,
-	"1.3.0",
-	`@agentclientprotocol/sdk must runtime-resolve to 1.3.0 from the adapter context (got ${wireInfo.version}) — the adapter and the backend must share one wire SDK`,
-);
-// @modelcontextprotocol/sdk gates its bare specifier behind "exports", so a
-// require.resolve of the package ROOT throws (no resolvable entry) — resolve a
-// real SUBPATH instead and walk up to its package.json.
-//
-// This used to read the repo's own hoisted copy and justify it with "pnpm
-// hoists ONE mcp instance". That is true of today's lockfile, which is exactly
-// why it asserted nothing: the read never traversed the edge it claimed to
-// verify, so a nested @modelcontextprotocol/sdk under claude-agent-sdk would
-// leave this gate GREEN while the adapter loaded a peer no gate had seen. A
-// probe whose subject is "whatever the root happens to hoist" is a coincidence,
-// not a check. Resolve FROM the claude-agent-sdk context so the assertion binds
-// the real adapter → claude-agent-sdk → MCP edge, the same way the anthropic
-// SDK peer above is bound.
-const mcpEntry = casRequire.resolve("@modelcontextprotocol/sdk/server/index.js");
-const mcpInfo = pkgInfoFromEntry(mcpEntry);
-assert.ok(
-	mcpInfo.version.startsWith("1.29."),
-	`@modelcontextprotocol/sdk must runtime-resolve to 1.29.x from the claude-agent-sdk context (got ${mcpInfo.version}) — claude-agent-sdk 0.3.219 declares a ^1.29.0 peer`,
-);
-
-// ---------------------------------------------------------------------------
-// (3) @agentclientprotocol/sdk value-export surface (silent-rename gate)
-//     The ACP bridge imports these from the wire SDK; a silent upstream
-//     rename would not fail typecheck (type-only erasure) but would break the
-//     raw turn. Assert the *value* exports exist at runtime.
-// ---------------------------------------------------------------------------
-// These are the value imports the real ACP code uses: the connectAcpClient
-// adapter (acp-client.ts) drives `client` + the `AGENT_METHODS`/`CLIENT_METHODS`
-// method tables; the backend + raw-turn smoke value-import `ndJsonStream` (the
-// stdio transport) and `PROTOCOL_VERSION`. The deprecated `ClientSideConnection`
-// is no longer used, so it is no longer gated. (Per GPT: gate only the value
-// imports the real code uses — type-only imports are erased.)
-const acpSdk = (await import("@agentclientprotocol/sdk")) as Record<string, unknown>;
-for (const sym of ["client", "ndJsonStream", "PROTOCOL_VERSION", "AGENT_METHODS", "CLIENT_METHODS"]) {
-	assert.ok(
-		sym in acpSdk,
-		`@agentclientprotocol/sdk lost value export "${sym}" — silent upstream rename; the raw ACP turn would break`,
-	);
-}
-
-// ---------------------------------------------------------------------------
-// (4) no source-level anthropic SDK import / API client
-//     peer-pin only. The credential boundary (AGENTS §Operating boundaries)
-//     forbids the bridge from importing the SDK or instantiating an API client.
-//     Line-based: only real `import ... from` / `require(...)` statements count,
-//     so this gate's own split-literal regexes above are never offenders.
-// ---------------------------------------------------------------------------
-const tracked = execFileSync("git", ["ls-files", "*.ts", "*.js", "*.mjs", "*.cjs"], {
-	cwd: repoRoot,
-	encoding: "utf8",
-})
-	.split("\n")
-	.filter(Boolean)
-	// `git ls-files` still names an UNSTAGED deletion (same contract as
-	// check-install-surface / the run.sh floor sweeps): a release-surface
-	// migration deletes tracked files before the commit workflow stages them;
-	// absence cannot import the SDK and must not crash this read-only sweep.
-	.filter((f) => existsSync(resolve(repoRoot, f)));
-
-// Specifier-shaped: any module binding to the anthropic SDK, in any of the
-// forms a source file could reach it — static `from`, `export ... from`,
-// side-effect `import "X"`, dynamic `import("X")`, and `require("X")`.
-const spec = `["']${ANTHROPIC_SDK.replace("/", "\\/")}["']`;
-const specifierPatterns: ReadonlyArray<{ re: RegExp; kind: string }> = [
-	{ re: new RegExp(String.raw`\bfrom\s+${spec}`), kind: `import/export from ${ANTHROPIC_SDK}` },
-	{ re: new RegExp(String.raw`^\s*import\s+${spec}`), kind: `side-effect import ${ANTHROPIC_SDK}` },
-	{ re: new RegExp(String.raw`\bimport\(\s*${spec}\s*\)`), kind: `dynamic import(${ANTHROPIC_SDK})` },
-	{ re: new RegExp(String.raw`\brequire\(\s*${spec}\s*\)`), kind: `require(${ANTHROPIC_SDK})` },
-];
-const clientRe = new RegExp(String.raw`\bnew\s+${API_CLIENT_CLASS}\s*\(`);
-
-const offenders: string[] = [];
-for (const f of tracked) {
-	const src = read(f);
-	for (const line of src.split("\n")) {
-		for (const { re, kind } of specifierPatterns) {
-			if (re.test(line)) offenders.push(`${f}: ${kind}`);
-		}
-		if (clientRe.test(line)) offenders.push(`${f}: new ${API_CLIENT_CLASS}() API client`);
-	}
-}
-assert.equal(
-	offenders.length,
-	0,
-	`${ANTHROPIC_SDK} is a peer-resolution pin ONLY — no source import / API client allowed:\n  ${offenders.join("\n  ")}`,
-);
-
-console.log("[check-acp-sdk-surface] ACP dep pins + peer-resolution lock + wire-SDK export surface + no-client-use ok");