@sayknow-cli/coding-agent 0.3.16 → 0.4.0

package/scripts/verify-skc-sdk-canonicalization.ts

@@ -0,0 +1,3647 @@
+#!/usr/bin/env bun
+
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { type ParserPlugin, parse } from "@babel/parser";
+import traverse, { type Binding, type NodePath } from "@babel/traverse";
+import * as t from "@babel/types";
+
+const repoRoot = process.env.SKC_SDK_CANONICALIZATION_SCAN_ROOT
+	? path.resolve(process.env.SKC_SDK_CANONICALIZATION_SCAN_ROOT)
+	: path.resolve(import.meta.dir, "..", "..", "..");
+const scannerPath = "packages/coding-agent/scripts/verify-skc-sdk-canonicalization.ts";
+const packageManifestPath = "packages/coding-agent/package.json";
+const retiredPythonRpcPackagePath = "python/skc-rpc/";
+const bridgeClientPackageManifestPath = "packages/bridge-client/package.json";
+const bridgeClientPackageName = "@sayknow-cli/bridge-client";
+const bridgeOrUnattendedImportPattern =
+	/(?:\b(?:import|export)\s+(?:type\s+)?(?:[^"'`;]*?\s+from\s+)?|\bimport\s*\(\s*)["'][^"']*(?:(?:^|\/)unattended)(?:["'/]|$)/g;
+const bridgeClientImportPattern = /(?:\bfrom\s*|\bimport\s*\(\s*)["'](@sayknow-cli\/bridge-client[^"']*)["']/g;
+const legacyBridgeClientSurfacePattern = /\b(?:BridgeClient|handshake|commands|SSE|control)\b/;
+
+const pythonUnattendedProtocolClientPattern =
+	/\b(?:negotiate_unattended|UnattendedAccepted|UnattendedBudget|parse_unattended_accepted|workflow_gate_response)\b/g;
+const pythonSkcRpcImportPattern = /^\s*(?:from\s+skc_rpc(?:\.|\s)|import\s+skc_rpc(?:\.|\s|,|$))/gm;
+const retiredExternalModeInvocationPatterns = [
+	/--mode(?:\s+|=)["']?(?:rpc|bridge|unattended)[A-Za-z0-9_.-]*(?:\b|["'])/gi,
+	/["']--mode["']\s*,\s*["'](?:rpc|bridge|unattended)[A-Za-z0-9_.-]*["']/gi,
+];
+const constructedRetiredIngressPatterns = [
+	/\[\s*["']r["']\s*,\s*["']pc["']\s*\]\.join\(\s*["']{2}\s*\)/g,
+	/["']r["']\s*\+\s*["']pc["']/g,
+	/`(?:r|\$\{\s*["']r["']\s*\})(?:pc|\$\{\s*["']pc["']\s*\})`/g,
+	/\[\s*["']brid["']\s*,\s*["']ge["']\s*\]\.join\(\s*["']{2}\s*\)/gi,
+	/`(?:brid|\$\{\s*["']brid["']\s*\})(?:ge|\$\{\s*["']ge["']\s*\})`/gi,
+	/\[\s*["']un["']\s*,\s*["']attended["']\s*\]\.join\(\s*["']{2}\s*\)/gi,
+	/`(?:un|\$\{\s*["']un["']\s*\})(?:attended|\$\{\s*["']attended["']\s*\})`/gi,
+	/["'](?:\.\/)?modes\/["']\s*\+\s*["'](?:rpc|bridge|unattended)[A-Za-z0-9_.-]*["']/gi,
+	/\[\s*["'](?:\.\/)?modes["']\s*,\s*["'](?:rpc|bridge|unattended)[A-Za-z0-9_.-]*["']\s*\]\.join\(\s*["']\/["']\s*\)/gi,
+];
+const retiredModeValuePattern = /^(?:rpc|bridge|unattended)[A-Za-z0-9_.-]*$/i;
+const retiredModeArgumentPattern = /^--mode(?:\s+|=)(?:rpc|bridge|unattended)[A-Za-z0-9_.-]*$/i;
+const MAX_STATIC_FILE_STEPS = 1_024;
+const MAX_STATIC_EXPRESSION_STEPS = 256;
+const MAX_STATIC_ALIAS_HOPS = 64;
+
+const allowedRpcModeInvocationTests = new Set([
+	"packages/coding-agent/test/sdk-downgrade-rollback.test.ts",
+	"packages/coding-agent/test/sdk-removed-ingresses.test.ts",
+]);
+const retiredAgentWireSubpaths = [
+	"./modes/shared/agent-wire/host-tool-bridge",
+	"./modes/shared/agent-wire/host-uri-bridge",
+	"./modes/shared/agent-wire/ui-request-broker",
+	"./modes/shared/agent-wire/ui-result",
+	"./modes/shared/agent-wire/wire-types",
+] as const;
+const retiredTmuxMachineBusPaths = new Set(["scripts/skc-session/prompt.sh", "scripts/skc-session/tail.sh"]);
+const machineTmuxDocumentationPaths = new Set([
+	"docs/skc-session-clawhip-routing.md",
+	"packages/coding-agent/src/setup/hermes/templates/operator-instructions.v1.md",
+]);
+const machineTmuxDocumentationPattern =
+	/(?:scripts\/skc-session\/(?:prompt|tail)\.sh|\b(?:load-buffer|paste-buffer|send-keys|capture-pane|pipe-pane)\b|(?:\.\/)?(?:scripts\/)?skc-session\/create\.sh(?:[ \t]+(?:"[^"\n]*"|'[^'\n]*'|[^\s]+)){3})/g;
+function normalizeShellContinuations(contents: string): string {
+	return contents.replace(/\\\r?\n[ \t]*/g, " ");
+}
+
+type TmuxMachineBusPrimitive =
+	| "load-buffer"
+	| "paste-buffer"
+	| "send-keys"
+	| "capture-pane"
+	| "pipe-pane"
+	| "set-buffer";
+
+const tmuxMachineBusPrimitives: readonly TmuxMachineBusPrimitive[] = [
+	"load-buffer",
+	"paste-buffer",
+	"send-keys",
+	"capture-pane",
+	"pipe-pane",
+	"set-buffer",
+];
+
+interface TmuxPrimitiveOccurrence {
+	primitive: TmuxMachineBusPrimitive;
+	start: number;
+	end: number;
+}
+
+interface StaticStringAssignment {
+	name: string;
+	expression: string;
+	start: number;
+}
+
+function maskCodeComments(contents: string): string {
+	let masked = "";
+	let quote: "'" | '"' | "`" | undefined;
+	for (let index = 0; index < contents.length; index++) {
+		const character = contents[index];
+		if (quote) {
+			masked += character;
+			if (character === "\\") {
+				masked += contents[index + 1] ?? "";
+				index++;
+			} else if (character === quote) {
+				quote = undefined;
+			}
+			continue;
+		}
+		if (character === "'" || character === '"' || character === "`") {
+			quote = character;
+			masked += character;
+			continue;
+		}
+		if (character === "/" && contents[index + 1] === "/") {
+			while (index < contents.length && contents[index] !== "\n") {
+				masked += " ";
+				index++;
+			}
+			masked += contents[index] ?? "";
+			continue;
+		}
+		if (character === "/" && contents[index + 1] === "*") {
+			masked += "  ";
+			index++;
+			while (index + 1 < contents.length && !(contents[index] === "*" && contents[index + 1] === "/")) {
+				masked += contents[index] === "\n" ? "\n" : " ";
+				index++;
+			}
+			if (index + 1 < contents.length) {
+				masked += "  ";
+				index++;
+			}
+			continue;
+		}
+		masked += character;
+	}
+	return masked;
+}
+
+function quotedStringValue(expression: string): string | undefined {
+	const match = /^(["'])([^\\\r\n]*)\1$/.exec(expression.trim());
+	return match?.[2];
+}
+
+function staticStringValue(expression: string, bindings: ReadonlyMap<string, string>): string | undefined {
+	const trimmed = expression.trim();
+	const literal = quotedStringValue(trimmed);
+	if (literal !== undefined) return literal;
+	if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(trimmed)) return bindings.get(trimmed);
+	if (trimmed.startsWith("`") && trimmed.endsWith("`")) {
+		const interpolated = trimmed
+			.slice(1, -1)
+			.replace(/\$\{\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*\}/g, (source, name: string) => bindings.get(name) ?? source);
+		return interpolated.includes("${") ? undefined : interpolated;
+	}
+	const join = /^\[\s*([^\]]*?)\s*\]\.join\(\s*(["'])([^\\\r\n]*)\2\s*\)$/.exec(trimmed);
+	if (join) {
+		const parts = join[1].split(",").map(part => staticStringValue(part, bindings));
+		return parts.every((part): part is string => part !== undefined) ? parts.join(join[3]) : undefined;
+	}
+	const parts = trimmed.split("+").map(part => part.trim());
+	if (parts.length > 1) {
+		const values = parts.map(part => staticStringValue(part, bindings));
+		return values.every((part): part is string => part !== undefined) ? values.join("") : undefined;
+	}
+	return undefined;
+}
+
+function staticStringBindings(contents: string): {
+	assignments: StaticStringAssignment[];
+	masked: string;
+	values: ReadonlyMap<string, string>;
+} {
+	const masked = maskCodeComments(contents);
+	const assignments: StaticStringAssignment[] = [];
+	for (const match of masked.matchAll(/\b(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*([^;\r\n]+);?/g)) {
+		const expression = match[2];
+		const start = (match.index ?? 0) + match[0].lastIndexOf(expression);
+		assignments.push({ name: match[1], expression, start });
+	}
+	const values = new Map<string, string>();
+	for (let pass = 0; pass < assignments.length; pass++) {
+		let changed = false;
+		for (const assignment of assignments) {
+			const value = staticStringValue(assignment.expression, values);
+			if (value === undefined || values.get(assignment.name) === value) continue;
+			values.set(assignment.name, value);
+			changed = true;
+		}
+		if (!changed) break;
+	}
+	return { assignments, masked, values };
+}
+
+function tmuxPrimitiveOccurrences(contents: string): TmuxPrimitiveOccurrence[] {
+	const { assignments, masked, values: bindings } = staticStringBindings(contents);
+	const occurrences = new Map<string, TmuxPrimitiveOccurrence>();
+	const add = (primitive: TmuxMachineBusPrimitive, start: number, end: number) => {
+		occurrences.set(`${primitive}:${start}`, { primitive, start, end });
+	};
+	for (const match of masked.matchAll(
+		/["'`](load-buffer|paste-buffer|send-keys|capture-pane|pipe-pane|set-buffer)["'`]/g,
+	)) {
+		add(match[1] as TmuxMachineBusPrimitive, match.index ?? 0, (match.index ?? 0) + match[0].length);
+	}
+	for (const match of masked.matchAll(/\b(load-buffer|paste-buffer|send-keys|capture-pane|pipe-pane|set-buffer)\b/g)) {
+		add(match[1] as TmuxMachineBusPrimitive, match.index ?? 0, (match.index ?? 0) + match[0].length);
+	}
+	for (const primitive of tmuxMachineBusPrimitives) {
+		const [prefix, suffix] = primitive.split("-");
+		const construction = new RegExp(
+			"(?:\\[\\s*[\"']" +
+				prefix +
+				"[\"']\\s*,\\s*[\"']-?" +
+				suffix +
+				"[\"']\\s*\\]\\s*\\.join\\(\\s*[\"']-?[\"']\\s*\\)|[\"']" +
+				prefix +
+				"[\"']\\s*\\+\\s*[\"']-?" +
+				suffix +
+				"[\"']|`(?:" +
+				prefix +
+				"|\\$\\{\\s*[\"']" +
+				prefix +
+				"[\"']\\s*\\})-(?:" +
+				suffix +
+				"|\\$\\{\\s*[\"']" +
+				suffix +
+				"[\"']\\s*\\})`)",
+			"g",
+		);
+		for (const match of masked.matchAll(construction)) {
+			add(primitive, match.index ?? 0, (match.index ?? 0) + match[0].length);
+		}
+	}
+	for (const assignment of assignments) {
+		const value = bindings.get(assignment.name);
+		if (value && tmuxMachineBusPrimitives.includes(value as TmuxMachineBusPrimitive)) {
+			add(value as TmuxMachineBusPrimitive, assignment.start, assignment.start + assignment.expression.length);
+		}
+	}
+	return [...occurrences.values()].sort((left, right) => left.start - right.start);
+}
+
+function resolveExportTarget(exports: Record<string, unknown>, subpath: string): unknown {
+	if (Object.hasOwn(exports, subpath)) return exports[subpath];
+	const candidates = Object.entries(exports)
+		.filter(([key]) => key.includes("*"))
+		.map(([key, target]) => {
+			const [prefix, suffix] = key.split("*");
+			return subpath.startsWith(prefix) && subpath.endsWith(suffix) ? { key, target } : undefined;
+		})
+		.filter((candidate): candidate is { key: string; target: unknown } => candidate !== undefined)
+		.sort((left, right) => right.key.length - left.key.length);
+	return candidates[0]?.target;
+}
+
+function exportTargetStrings(target: unknown): string[] {
+	if (typeof target === "string") return [target];
+	if (!target || typeof target !== "object") return [];
+	return Object.values(target as Record<string, unknown>).flatMap(exportTargetStrings);
+}
+
+function retiredIngressSource(file: string): boolean {
+	return /\/src\/(?:modes\/(?:rpc|bridge|unattended)[A-Za-z0-9_.-]*(?:\/|$)|(?:rpc|bridge|unattended)[A-Za-z0-9_.-]*(?:\/|\.[cm]?[jt]sx?$))/i.test(
+		file,
+	);
+}
+
+function broadExportReachesSource(
+	exports: Record<string, unknown>,
+	exportPath: string,
+	target: unknown,
+	sourcePath: string,
+): boolean {
+	for (const targetPath of exportTargetStrings(target)) {
+		if (!targetPath.includes("*")) continue;
+		const [prefix, suffix] = targetPath.split("*");
+		if (!sourcePath.startsWith(prefix) || !sourcePath.endsWith(suffix)) continue;
+		const wildcard = sourcePath.slice(prefix.length, sourcePath.length - suffix.length);
+		const resolved = resolveExportTarget(exports, exportPath.replace("*", wildcard));
+		if (exportTargetStrings(resolved).length > 0) return true;
+	}
+	return false;
+}
+
+function isPython(file: string): boolean {
+	return file.endsWith(".py");
+}
+
+function isPythonDistributionMetadata(file: string): boolean {
+	return /(?:^|\/)(?:pyproject\.toml|setup\.(?:py|cfg)|requirements(?:[-._][^/]*)?\.txt)$/.test(file);
+}
+
+function isPackageMetadata(file: string): boolean {
+	return file.endsWith("package.json") || isPythonDistributionMetadata(file);
+}
+
+function isGeneratedDocumentationIndex(file: string): boolean {
+	return file === "packages/coding-agent/src/internal-urls/docs-index.generated.ts";
+}
+
+function isHistoricalLegacyPythonRpcArtifact(file: string): boolean {
+	return (
+		file.startsWith("artifacts/") ||
+		file.startsWith("issues/") ||
+		file.includes("/artifacts/") ||
+		file.includes("/issues/") ||
+		/(?:^|\/)(?:CHANGELOG|HISTORY)\.[^/]+$/i.test(file)
+	);
+}
+
+function isActiveLegacyPythonRpcTarget(file: string): boolean {
+	if (
+		isGeneratedDocumentationIndex(file) ||
+		isHistoricalLegacyPythonRpcArtifact(file) ||
+		/(?:^|\/)(?:test|tests|fixtures)(?:\/|$)/.test(file)
+	)
+		return false;
+	if (isPackageMetadata(file)) return true;
+	return (
+		file.startsWith("src/") ||
+		file.startsWith("scripts/") ||
+		/^(?:packages|python)\/[^/]+\/(?:src|scripts)\//.test(file)
+	);
+}
+
+function legacyPythonRpcViolations(file: string, contents: string): string[] {
+	const violations: string[] = [];
+	if (isPython(file)) {
+		for (const match of contents.matchAll(pythonSkcRpcImportPattern)) {
+			violations.push(`${file}:${lineNumber(contents, match.index ?? 0)}: imports removed skc_rpc Python client`);
+		}
+		for (const match of contents.matchAll(pythonUnattendedProtocolClientPattern)) {
+			violations.push(
+				`${file}:${lineNumber(contents, match.index ?? 0)}: uses removed Python unattended protocol client ${match[0]}`,
+			);
+		}
+	}
+	if (isPythonDistributionMetadata(file)) {
+		for (const match of contents.matchAll(/\bskc-rpc\b/gi)) {
+			violations.push(
+				`${file}:${lineNumber(contents, match.index ?? 0)}: declares removed skc-rpc distribution metadata`,
+			);
+		}
+	}
+	return violations;
+}
+
+type RetiredModeSourceType = "unambiguous" | "commonjs" | "module";
+type StaticAnalysisBudgetKind = "file_steps" | "expression_steps" | "alias_hops";
+type StaticStringResult = { kind: "known"; value: string } | { kind: "unknown"; reason: string };
+type StaticArrayResult = { kind: "known"; values: string[] } | { kind: "unknown"; reason: string };
+type StaticDefinitionResult = { kind: "definition"; definition: StaticDefinition } | StaticStringResult;
+
+interface RetiredModeParserOptions {
+	sourceType: RetiredModeSourceType;
+	plugins: ParserPlugin[];
+}
+
+interface StaticAnalysisFileState {
+	steps: number;
+}
+
+interface StaticEvaluationContext {
+	file: string;
+	expressionSteps: number;
+	aliasHops: number;
+	activeBindings: Set<Binding>;
+	evaluationSteps: NodePath<t.Expression>[];
+}
+
+interface StaticDefinition {
+	expressionPath: NodePath<t.Expression>;
+	start: number;
+	end: number;
+}
+
+class StaticAnalysisParseError extends Error {
+	constructor(file: string, line: number, column: number) {
+		super(`${file}:${line}:${column}: static retired-mode analysis parse failed`);
+		this.name = "StaticAnalysisParseError";
+	}
+}
+
+class StaticAnalysisBudgetExceeded extends Error {
+	constructor(file: string, node: t.Node, kind: StaticAnalysisBudgetKind, limit: number, observed: number) {
+		const location = staticNodeLocation(node);
+		super(
+			`${file}:${location.line}:${location.column}: static retired-mode analysis budget exceeded (kind=${kind}, limit=${limit}, observed=${observed})`,
+		);
+		this.name = "StaticAnalysisBudgetExceeded";
+	}
+}
+
+function isExecutableSource(file: string): boolean {
+	return /\.(?:[cm]?[jt]sx?|py)$/.test(file);
+}
+
+function retiredModeParserOptions(file: string): RetiredModeParserOptions | undefined {
+	const importAttributePlugins: ParserPlugin[] = ["importAttributes"];
+	if (file.endsWith(".d.mts")) {
+		return {
+			sourceType: "module",
+			plugins: [["typescript", { dts: true, disallowAmbiguousJSXLike: true }]],
+		};
+	}
+	if (file.endsWith(".d.cts")) {
+		return {
+			sourceType: "commonjs",
+			plugins: [["typescript", { dts: true, disallowAmbiguousJSXLike: true }]],
+		};
+	}
+	if (file.endsWith(".d.ts")) {
+		return { sourceType: "unambiguous", plugins: [["typescript", { dts: true }]] };
+	}
+	if (file.endsWith(".tsx")) return { sourceType: "unambiguous", plugins: ["typescript", "jsx"] };
+	if (file.endsWith(".mts")) {
+		return {
+			sourceType: "unambiguous",
+			plugins: [["typescript", { disallowAmbiguousJSXLike: true }]],
+		};
+	}
+	if (file.endsWith(".cts")) {
+		return {
+			sourceType: "commonjs",
+			plugins: [["typescript", { disallowAmbiguousJSXLike: true }]],
+		};
+	}
+	if (file.endsWith(".ts")) return { sourceType: "unambiguous", plugins: ["typescript"] };
+	if (file.endsWith(".jsx")) return { sourceType: "unambiguous", plugins: ["jsx", ...importAttributePlugins] };
+	if (file.endsWith(".cjs")) return { sourceType: "commonjs", plugins: importAttributePlugins };
+	if (file.endsWith(".js") || file.endsWith(".mjs")) {
+		return { sourceType: "unambiguous", plugins: importAttributePlugins };
+	}
+	return undefined;
+}
+
+function parserErrorLocation(error: unknown): { line: number; column: number } {
+	const parserError = error as { loc?: unknown };
+	const location = parserError.loc;
+	if (location && typeof location === "object") {
+		const parserLocation = location as { line?: unknown; column?: unknown };
+		if (typeof parserLocation.line === "number" && typeof parserLocation.column === "number") {
+			return { line: parserLocation.line, column: parserLocation.column };
+		}
+	}
+	return { line: 1, column: 0 };
+}
+
+function parseRetiredModeSource(file: string, contents: string): t.File | undefined {
+	const options = retiredModeParserOptions(file);
+	if (!options) return undefined;
+	try {
+		return parse(contents, options);
+	} catch (error) {
+		const location = parserErrorLocation(error);
+		throw new StaticAnalysisParseError(file, location.line, location.column);
+	}
+}
+
+function staticNodeLocation(node: t.Node): { line: number; column: number } {
+	return { line: node.loc?.start.line ?? 1, column: node.loc?.start.column ?? 0 };
+}
+
+function staticNodeOffset(node: t.Node): number | undefined {
+	return typeof node.start === "number" ? node.start : undefined;
+}
+
+function staticNodeEnd(node: t.Node): number | undefined {
+	return typeof node.end === "number" ? node.end : undefined;
+}
+
+function staticKnown(value: string): StaticStringResult {
+	return { kind: "known", value };
+}
+
+function staticUnknown(reason: string): StaticStringResult {
+	return { kind: "unknown", reason };
+}
+
+function staticExpressionPath(path: NodePath, key: string): NodePath<t.Expression> | undefined {
+	const childPath = path.get(key) as NodePath | NodePath[];
+	if (Array.isArray(childPath) || !childPath.isExpression()) return undefined;
+	return childPath;
+}
+
+function staticExecutionContext(path: NodePath): NodePath | undefined {
+	let current: NodePath | null = path;
+	while (current) {
+		if (current.isProgram() || current.isFunction()) return current;
+		current = current.parentPath;
+	}
+	return undefined;
+}
+
+function isExecutionContextAncestor(ancestor: NodePath, descendant: NodePath): boolean {
+	let current: NodePath | null = descendant;
+	while (current) {
+		if (current.node === ancestor.node) return true;
+		current = current.parentPath;
+	}
+	return false;
+}
+
+function recordStaticEvaluationStep(path: NodePath<t.Expression>, context: StaticEvaluationContext): void {
+	context.evaluationSteps.push(path);
+	context.expressionSteps++;
+	if (context.expressionSteps > MAX_STATIC_EXPRESSION_STEPS) {
+		throw new StaticAnalysisBudgetExceeded(
+			context.file,
+			path.node,
+			"expression_steps",
+			MAX_STATIC_EXPRESSION_STEPS,
+			context.expressionSteps,
+		);
+	}
+}
+
+function commitStaticFileSteps(
+	evaluationSteps: readonly NodePath<t.Expression>[],
+	file: string,
+	fileState: StaticAnalysisFileState,
+): void {
+	for (const path of evaluationSteps) {
+		fileState.steps++;
+		if (fileState.steps > MAX_STATIC_FILE_STEPS) {
+			throw new StaticAnalysisBudgetExceeded(file, path.node, "file_steps", MAX_STATIC_FILE_STEPS, fileState.steps);
+		}
+	}
+}
+
+function incrementStaticAliasHop(path: NodePath<t.Identifier>, context: StaticEvaluationContext): void {
+	context.aliasHops++;
+	if (context.aliasHops > MAX_STATIC_ALIAS_HOPS) {
+		throw new StaticAnalysisBudgetExceeded(
+			context.file,
+			path.node,
+			"alias_hops",
+			MAX_STATIC_ALIAS_HOPS,
+			context.aliasHops,
+		);
+	}
+}
+
+function bindingInitializer(binding: Binding): StaticDefinitionResult {
+	if (!binding.path.isVariableDeclarator()) return staticUnknown("unsupported binding");
+	const declaration = binding.path.node;
+	if (!t.isIdentifier(declaration.id) || declaration.id.name !== binding.identifier.name) {
+		return staticUnknown("unsupported binding");
+	}
+	const initializerPath = staticExpressionPath(binding.path, "init");
+	if (!initializerPath) return staticUnknown("missing initializer");
+	const start = staticNodeOffset(initializerPath.node);
+	const end = staticNodeEnd(initializerPath.node);
+	if (start === undefined || end === undefined) return staticUnknown("missing initializer position");
+	return { kind: "definition", definition: { expressionPath: initializerPath, start, end } };
+}
+
+function assignmentPathForViolation(violationPath: NodePath): NodePath<t.AssignmentExpression> | undefined {
+	if (violationPath.isAssignmentExpression()) return violationPath;
+	const parentPath = violationPath.parentPath;
+	if (parentPath?.isAssignmentExpression() && parentPath.node.left === violationPath.node) return parentPath;
+	return undefined;
+}
+
+function staticAssignmentDefinition(binding: Binding, violationPath: NodePath): StaticDefinitionResult {
+	const assignmentPath = assignmentPathForViolation(violationPath);
+	if (assignmentPath?.node.operator !== "=") return staticUnknown("unsupported write");
+	if (!t.isIdentifier(assignmentPath.node.left)) return staticUnknown("unsupported write");
+	if (assignmentPath.scope.getBinding(assignmentPath.node.left.name) !== binding) {
+		return staticUnknown("unsupported write");
+	}
+	if (!assignmentPath.parentPath?.isExpressionStatement()) return staticUnknown("ambiguous write");
+	const expressionPath = staticExpressionPath(assignmentPath, "right");
+	if (!expressionPath) return staticUnknown("unsupported write");
+	const start = staticNodeOffset(assignmentPath.node);
+	const end = staticNodeEnd(assignmentPath.node);
+	if (start === undefined || end === undefined) return staticUnknown("missing write position");
+	return { kind: "definition", definition: { expressionPath, start, end } };
+}
+
+function isUnambiguousStaticWrite(path: NodePath<t.AssignmentExpression>, context: NodePath): boolean {
+	let current: NodePath | null = path.parentPath;
+	while (current && current.node !== context.node) {
+		if (
+			current.isIfStatement() ||
+			current.isSwitchCase() ||
+			current.isForStatement() ||
+			current.isForInStatement() ||
+			current.isForOfStatement() ||
+			current.isWhileStatement() ||
+			current.isDoWhileStatement() ||
+			current.isTryStatement() ||
+			current.isConditionalExpression() ||
+			current.isLogicalExpression()
+		) {
+			return false;
+		}
+		current = current.parentPath;
+	}
+	return current !== null;
+}
+
+function staticReachingDefinition(identifierPath: NodePath<t.Identifier>, binding: Binding): StaticDefinitionResult {
+	const initialDefinition = bindingInitializer(binding);
+	if (initialDefinition.kind !== "definition") return initialDefinition;
+	const useOffset = staticNodeOffset(identifierPath.node);
+	const bindingContext = staticExecutionContext(binding.path);
+	const useContext = staticExecutionContext(identifierPath);
+	if (useOffset === undefined || !bindingContext || !useContext) return staticUnknown("missing use position");
+	if (bindingContext.node !== useContext.node) {
+		if (binding.kind !== "const" || !binding.constant || !isExecutionContextAncestor(bindingContext, useContext)) {
+			return staticUnknown("ambiguous cross-context binding");
+		}
+		return initialDefinition;
+	}
+	if (initialDefinition.definition.end > useOffset) return staticUnknown("direct TDZ");
+
+	let selectedDefinition = initialDefinition.definition;
+	for (const violationPath of binding.constantViolations) {
+		const violationContext = staticExecutionContext(violationPath);
+		if (!violationContext || violationContext.node !== bindingContext.node) {
+			return staticUnknown("ambiguous cross-context write");
+		}
+		const violationOffset = staticNodeOffset(violationPath.node);
+		if (violationOffset === undefined) return staticUnknown("missing write position");
+		if (violationOffset >= useOffset) continue;
+		const writeDefinition = staticAssignmentDefinition(binding, violationPath);
+		if (writeDefinition.kind !== "definition") return writeDefinition;
+		if (writeDefinition.definition.end > useOffset) return staticUnknown("ambiguous write order");
+		const assignmentPath = assignmentPathForViolation(violationPath);
+		if (!assignmentPath || !isUnambiguousStaticWrite(assignmentPath, bindingContext)) {
+			return staticUnknown("ambiguous write");
+		}
+		if (writeDefinition.definition.start === selectedDefinition.start) return staticUnknown("ambiguous write order");
+		if (writeDefinition.definition.start > selectedDefinition.start) selectedDefinition = writeDefinition.definition;
+	}
+	return { kind: "definition", definition: selectedDefinition };
+}
+
+function evaluateStaticArrayElements(
+	path: NodePath<t.ArrayExpression>,
+	context: StaticEvaluationContext,
+): StaticArrayResult {
+	recordStaticEvaluationStep(path, context);
+	const elementPaths = path.get("elements");
+	if (!Array.isArray(elementPaths)) return { kind: "unknown", reason: "unsupported array" };
+	const values: string[] = [];
+	for (const elementPath of elementPaths) {
+		if (!elementPath.isExpression()) return { kind: "unknown", reason: "unsupported array element" };
+		const value = evaluateStaticString(elementPath, context);
+		if (value.kind !== "known") return value;
+		values.push(value.value);
+	}
+	return { kind: "known", values };
+}
+
+function evaluateStaticJoin(path: NodePath<t.CallExpression>, context: StaticEvaluationContext): StaticStringResult {
+	if (path.node.optional) return staticUnknown("unsupported call");
+	const calleePath = staticExpressionPath(path, "callee");
+	if (!calleePath?.isMemberExpression()) return staticUnknown("unsupported call");
+	if (
+		calleePath.node.computed ||
+		calleePath.node.optional ||
+		!t.isIdentifier(calleePath.node.property, { name: "join" })
+	) {
+		return staticUnknown("unsupported call");
+	}
+	const objectPath = staticExpressionPath(calleePath, "object");
+	if (!objectPath?.isArrayExpression()) return staticUnknown("unsupported call");
+	const argumentPaths = path.get("arguments");
+	if (!Array.isArray(argumentPaths) || argumentPaths.length > 1) return staticUnknown("unsupported call");
+	let separator = ",";
+	if (argumentPaths.length === 1) {
+		const separatorPath = argumentPaths[0];
+		if (!separatorPath.isExpression()) return staticUnknown("unsupported call");
+		const separatorResult = evaluateStaticString(separatorPath, context);
+		if (separatorResult.kind !== "known") return separatorResult;
+		separator = separatorResult.value;
+	}
+	const arrayResult = evaluateStaticArrayElements(objectPath as NodePath<t.ArrayExpression>, context);
+	return arrayResult.kind === "known" ? staticKnown(arrayResult.values.join(separator)) : arrayResult;
+}
+
+function evaluateStaticIdentifier(path: NodePath<t.Identifier>, context: StaticEvaluationContext): StaticStringResult {
+	const binding = path.scope.getBinding(path.node.name);
+	if (!binding) return staticUnknown("missing binding");
+	if (context.activeBindings.has(binding)) return staticUnknown("binding cycle");
+	const definition = staticReachingDefinition(path, binding);
+	if (definition.kind !== "definition") return definition;
+	context.activeBindings.add(binding);
+	try {
+		incrementStaticAliasHop(path, context);
+		return evaluateStaticString(definition.definition.expressionPath, context);
+	} finally {
+		context.activeBindings.delete(binding);
+	}
+}
+
+function evaluateStaticString(path: NodePath<t.Expression>, context: StaticEvaluationContext): StaticStringResult {
+	recordStaticEvaluationStep(path, context);
+	const node = path.node;
+	if (t.isStringLiteral(node)) return staticKnown(node.value);
+	if (t.isIdentifier(node)) return evaluateStaticIdentifier(path as NodePath<t.Identifier>, context);
+	if (
+		t.isTSAsExpression(node) ||
+		t.isTSTypeAssertion(node) ||
+		t.isTSSatisfiesExpression(node) ||
+		t.isTSNonNullExpression(node) ||
+		t.isParenthesizedExpression(node)
+	) {
+		const expressionPath = staticExpressionPath(path, "expression");
+		return expressionPath ? evaluateStaticString(expressionPath, context) : staticUnknown("unsupported wrapper");
+	}
+	if (t.isTemplateLiteral(node)) {
+		const expressionPaths = path.get("expressions");
+		if (!Array.isArray(expressionPaths) || expressionPaths.length !== node.expressions.length) {
+			return staticUnknown("unsupported template");
+		}
+		let value = "";
+		for (let index = 0; index < node.quasis.length; index++) {
+			const cooked = node.quasis[index]?.value.cooked;
+			if (cooked === null || cooked === undefined) return staticUnknown("unsupported template");
+			value += cooked;
+			if (index === expressionPaths.length) continue;
+			const expressionPath = expressionPaths[index];
+			if (!expressionPath.isExpression()) return staticUnknown("unsupported template");
+			const expressionResult = evaluateStaticString(expressionPath, context);
+			if (expressionResult.kind !== "known") return expressionResult;
+			value += expressionResult.value;
+		}
+		return staticKnown(value);
+	}
+	if (t.isBinaryExpression(node) && node.operator === "+") {
+		const leftPath = staticExpressionPath(path, "left");
+		const rightPath = staticExpressionPath(path, "right");
+		if (!leftPath || !rightPath) return staticUnknown("unsupported binary expression");
+		const left = evaluateStaticString(leftPath, context);
+		if (left.kind !== "known") return left;
+		const right = evaluateStaticString(rightPath, context);
+		return right.kind === "known" ? staticKnown(left.value + right.value) : right;
+	}
+	if (t.isCallExpression(node)) return evaluateStaticJoin(path as NodePath<t.CallExpression>, context);
+	return staticUnknown("unsupported expression");
+}
+
+function isStaticModeCandidate(
+	elements: readonly ({ path: NodePath<t.Expression>; value: string | undefined } | undefined)[],
+): boolean {
+	return elements.some(element => element?.value === "--mode" || /^--mode(?:\s+|=)/.test(element?.value ?? ""));
+}
+
+function staticRetiredModeInvocationViolations(file: string, contents: string): string[] {
+	const ast = parseRetiredModeSource(file, contents);
+	if (!ast) return [];
+	const fileState: StaticAnalysisFileState = { steps: 0 };
+	const violations = new Set<string>();
+	traverse(ast, {
+		ArrayExpression(arrayPath) {
+			const elementPaths = arrayPath.get("elements");
+			if (!Array.isArray(elementPaths)) return;
+			const evaluationSteps: NodePath<t.Expression>[] = [];
+			const elements: Array<{ path: NodePath<t.Expression>; value: string | undefined } | undefined> = [];
+			for (const elementPath of elementPaths) {
+				if (!elementPath.isExpression()) {
+					elements.push(undefined);
+					continue;
+				}
+				const context: StaticEvaluationContext = {
+					file,
+					expressionSteps: 0,
+					aliasHops: 0,
+					activeBindings: new Set<Binding>(),
+					evaluationSteps,
+				};
+				const result = evaluateStaticString(elementPath, context);
+				elements.push({ path: elementPath, value: result.kind === "known" ? result.value : undefined });
+			}
+			if (!isStaticModeCandidate(elements)) return;
+			commitStaticFileSteps(evaluationSteps, file, fileState);
+			for (let index = 0; index < elements.length; index++) {
+				const current = elements[index];
+				if (!current?.value) continue;
+				const preceding = index > 0 ? elements[index - 1] : undefined;
+				if (
+					!retiredModeArgumentPattern.test(current.value) &&
+					!(preceding?.value === "--mode" && retiredModeValuePattern.test(current.value))
+				)
+					continue;
+				const violationPath = preceding?.value === "--mode" ? preceding.path : current.path;
+				violations.add(`${file}:${staticNodeLocation(violationPath.node).line}: invokes removed --mode rpc`);
+			}
+		},
+	});
+	return [...violations];
+}
+
+function legacyRpcModeAliasViolations(file: string, contents: string): string[] {
+	const { masked, values: bindings } = staticStringBindings(contents);
+	const violations: string[] = [];
+	for (const match of masked.matchAll(/\[[^\]\r\n]*\]/g)) {
+		const argv = match[0].slice(1, -1).split(",");
+		for (let index = 0; index < argv.length; index++) {
+			const expression = argv[index].trim();
+			if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(expression)) continue;
+			const value = staticStringValue(expression, bindings);
+			const preceding = index > 0 ? staticStringValue(argv[index - 1], bindings) : undefined;
+			if (
+				value !== undefined &&
+				(retiredModeArgumentPattern.test(value) || (preceding === "--mode" && retiredModeValuePattern.test(value)))
+			) {
+				violations.push(`${file}:${lineNumber(contents, match.index ?? 0)}: invokes removed --mode rpc`);
+			}
+		}
+	}
+	return violations;
+}
+
+function rpcModeInvocationViolations(file: string, contents: string): string[] {
+	if (isGeneratedDocumentationIndex(file) || !isExecutableSource(file) || allowedRpcModeInvocationTests.has(file))
+		return [];
+	const patterns = [...retiredExternalModeInvocationPatterns, ...constructedRetiredIngressPatterns];
+	const violations = patterns.flatMap(pattern =>
+		[...contents.matchAll(pattern)].map(
+			match => `${file}:${lineNumber(contents, match.index ?? 0)}: invokes removed --mode rpc`,
+		),
+	);
+	if (retiredModeParserOptions(file)) {
+		violations.push(...staticRetiredModeInvocationViolations(file, contents));
+	} else {
+		violations.push(...legacyRpcModeAliasViolations(file, contents));
+	}
+	return [...new Set(violations)];
+}
+
+function bridgeClientPackageMetadataViolation(file: string, contents: string): string | undefined {
+	if (
+		!file.endsWith("package.json") ||
+		(file !== bridgeClientPackageManifestPath && !contents.includes(bridgeClientPackageName))
+	)
+		return undefined;
+	try {
+		const manifest = JSON.parse(contents) as {
+			catalog?: Record<string, unknown>;
+			dependencies?: Record<string, unknown>;
+			name?: unknown;
+			optionalDependencies?: Record<string, unknown>;
+			peerDependencies?: Record<string, unknown>;
+			workspaces?: { catalog?: Record<string, unknown> };
+		};
+		if (file === bridgeClientPackageManifestPath) {
+			if (manifest.name !== bridgeClientPackageName)
+				return `${file}: is not the canonical bridge-client package manifest`;
+			if (
+				Object.keys(manifest.dependencies ?? {}).length > 0 ||
+				Object.keys(manifest.peerDependencies ?? {}).length > 0 ||
+				Object.keys(manifest.optionalDependencies ?? {}).length > 0
+			)
+				return `${file}: canonical bridge-client package must remain runtime-dependency-free`;
+			return undefined;
+		}
+		if (
+			file === "package.json" &&
+			(typeof manifest.catalog?.[bridgeClientPackageName] === "string" ||
+				typeof manifest.workspaces?.catalog?.[bridgeClientPackageName] === "string")
+		)
+			return undefined;
+		if (file === packageManifestPath && typeof manifest.dependencies?.[bridgeClientPackageName] === "string")
+			return undefined;
+	} catch {
+		return `${file}: declares unsupported bridge-client package metadata`;
+	}
+
+	return `${file}: declares unsupported bridge-client package metadata`;
+}
+
+function bridgeClientImportViolations(file: string, contents: string): string[] {
+	const violations: string[] = [];
+	for (const match of contents.matchAll(bridgeClientImportPattern)) {
+		const specifier = match[1];
+		const start = match.index ?? 0;
+		if (specifier !== bridgeClientPackageName) {
+			violations.push(`${file}:${lineNumber(contents, start)}: imports unsupported bridge-client subpath`);
+			continue;
+		}
+		const statementStart = Math.max(contents.lastIndexOf(";", start), contents.lastIndexOf("\n", start - 512));
+		const statement = contents.slice(statementStart + 1, start);
+		if (legacyBridgeClientSurfacePattern.test(statement)) {
+			violations.push(`${file}:${lineNumber(contents, start)}: imports historical bridge-client protocol surface`);
+		}
+	}
+	if (!isGeneratedDocumentationIndex(file) && /\.[cm]?[jt]sx?$/u.test(file) && /\bBridgeClient\b/.test(contents)) {
+		violations.push(`${file}: historical BridgeClient surface survived`);
+	}
+	return violations;
+}
+
+function bridgeClientOwnershipViolations(file: string, contents: string): string[] {
+	if (!file.startsWith("packages/bridge-client/src/") || !/\.(?:[cm]?[jt]sx?)$/u.test(file)) return [];
+	const violations: string[] = [];
+	for (const match of contents.matchAll(relativeImportPattern)) {
+		const specifier = match[1] ?? match[2];
+		const start = match.index ?? 0;
+		if (
+			specifier.startsWith(".") &&
+			!path.posix
+				.normalize(path.posix.join(path.posix.dirname(file), specifier))
+				.startsWith("packages/bridge-client/")
+		) {
+			violations.push(`${file}:${lineNumber(contents, start)}: bridge-client import escapes its package`);
+		}
+		if (
+			/(?:^|\/)(?:coding-agent|agent-session|sdk\/(?:host|session)|session)(?:\/|$)|@sayknow-cli\/coding-agent/.test(
+				specifier,
+			)
+		) {
+			violations.push(
+				`${file}:${lineNumber(contents, start)}: bridge-client imports coding-agent or AgentSession authority`,
+			);
+		}
+		if (/\b(?:AgentSession|SessionManager|SessionHost|HostControl|SdkHost|SDKHost|HostSession)\b/.test(match[0])) {
+			violations.push(`${file}:${lineNumber(contents, start)}: bridge-client imports host or session authority`);
+		}
+		if (/^node:(?:net|http|https|child_process)(?:\/|$)/.test(specifier)) {
+			violations.push(
+				`${file}:${lineNumber(contents, start)}: bridge-client imports server or process ownership module ${specifier}`,
+			);
+		}
+		if (legacyBridgeClientSurfacePattern.test(match[0])) {
+			violations.push(`${file}:${lineNumber(contents, start)}: bridge-client imports historical protocol surface`);
+		}
+	}
+	for (const pattern of [
+		/\b(?:AgentSession|SessionManager|SessionHost|HostControl|SdkHost|SDKHost|HostSession)\b/g,
+		/\b(?:Bun\.serve|(?:createServer|createSecureServer)\s*\(|\.listen\s*\(|(?:spawn|spawnSync|exec|execFile|fork)\s*\(|process\.)/g,
+	]) {
+		for (const match of contents.matchAll(pattern)) {
+			violations.push(
+				`${file}:${lineNumber(contents, match.index ?? 0)}: bridge-client owns forbidden host, session, server, listener, or process authority`,
+			);
+		}
+	}
+	for (const match of contents.matchAll(/\b(?:BridgeClient|handshake|commands|SSE)\b/g)) {
+		violations.push(
+			`${file}:${lineNumber(contents, match.index ?? 0)}: bridge-client retains historical protocol symbol ${match[0]}`,
+		);
+	}
+	return [...new Set(violations)];
+}
+
+// These are the only server owners permitted to couple a listener to session/control internals.
+const sanctionedServerHosts = new Map<string, string>([
+	[
+		"packages/coding-agent/src/sdk/bus/index.ts",
+		"NotificationServer is the SDK-owned notification host and wires the sanctioned SDK control surface.",
+	],
+	[
+		"packages/coding-agent/src/sdk/broker/transport.ts",
+		"BrokerTransport is the SDK-owned broker WebSocket transport.",
+	],
+	[
+		"packages/coding-agent/src/harness-control-plane/control-endpoint.ts",
+		"ControlServer owns a private owner-local Unix socket; it is not an external session server.",
+	],
+]);
+
+function commandOutput(command: string[]): string {
+	const result = Bun.spawnSync(command, { cwd: repoRoot, stdout: "pipe", stderr: "pipe" });
+	if (result.exitCode !== 0) {
+		throw new Error(`${command.join(" ")} failed: ${new TextDecoder().decode(result.stderr)}`);
+	}
+	return new TextDecoder().decode(result.stdout);
+}
+
+function isSource(file: string): boolean {
+	return /\.(?:[cm]?[jt]sx?|json|py|toml)$/.test(file);
+}
+
+const teamRuntimeTmuxPath = "packages/coding-agent/src/skc-runtime/team-runtime.ts";
+const teamWorkersTmuxPath = "packages/coding-agent/src/skc-runtime/team-workers.ts";
+
+const coordinatorMcpRoot = "packages/coding-agent/src/coordinator-mcp/server.ts";
+function isPublishedSkcSessionShellHelper(file: string): boolean {
+	return file.startsWith("scripts/skc-session/") && file.endsWith(".sh");
+}
+
+interface ShellStructure {
+	parentheses: number;
+	braces: number;
+	controls: number;
+}
+
+function shellStructureBefore(contents: string, offset: number): ShellStructure {
+	const structure: ShellStructure = { parentheses: 0, braces: 0, controls: 0 };
+	let quote: "'" | '"' | undefined;
+	let word = "";
+	const commitWord = () => {
+		if (["if", "while", "until", "for", "case", "select"].includes(word)) structure.controls++;
+		if (["fi", "done", "esac"].includes(word)) structure.controls = Math.max(0, structure.controls - 1);
+		word = "";
+	};
+	for (let index = 0; index < offset; index++) {
+		const character = contents[index];
+		if (quote) {
+			if (character === "\\" && quote === '"') index++;
+			else if (character === quote) quote = undefined;
+			continue;
+		}
+		if (character === "'" || character === '"') {
+			commitWord();
+			quote = character;
+			continue;
+		}
+		if (character === "#") {
+			commitWord();
+			while (index < offset && contents[index] !== "\n") index++;
+			continue;
+		}
+		if (/[A-Za-z_]/.test(character)) {
+			word += character;
+			continue;
+		}
+		if (/[0-9]/.test(character) && word) {
+			word += character;
+			continue;
+		}
+		commitWord();
+		if (character === "(") structure.parentheses++;
+		if (character === ")") structure.parentheses = Math.max(0, structure.parentheses - 1);
+		if (character === "{" && contents[index - 1] !== "$") structure.braces++;
+		if (character === "}") structure.braces = Math.max(0, structure.braces - 1);
+	}
+	commitWord();
+	return structure;
+}
+
+function hasLeadingShellContinuation(contents: string, offset: number): boolean {
+	const lines = normalizeShellContinuations(contents.slice(0, offset)).split(/\r?\n/);
+	for (let index = lines.length - 1; index >= 0; index--) {
+		const line = lines[index].replace(/(?:^|\s)#.*$/, "").trim();
+		if (line) return /(?:&&|\|\||\|)$/.test(line);
+	}
+	return false;
+}
+
+function isUnconditionalTopLevelShellPosition(contents: string, offset: number): boolean {
+	const structure = shellStructureBefore(contents, offset);
+	if (structure.parentheses !== 0 || structure.braces !== 0 || structure.controls !== 0) return false;
+	return !hasLeadingShellContinuation(contents, offset);
+}
+
+interface ShellRange {
+	start: number;
+	end: number;
+}
+
+function shellArrayAssignmentRanges(contents: string): ShellRange[] {
+	const ranges: ShellRange[] = [];
+	const assignments = /\b[A-Za-z_][A-Za-z0-9_]*\s*=\s*\(/g;
+	for (const assignment of contents.matchAll(assignments)) {
+		const openingParen = (assignment.index ?? 0) + assignment[0].lastIndexOf("(");
+		let depth = 1;
+		let quote: "'" | '"' | undefined;
+		for (let index = openingParen + 1; index < contents.length; index++) {
+			const character = contents[index];
+			if (quote) {
+				if (character === "\\" && quote === '"') index++;
+				else if (character === quote) quote = undefined;
+				continue;
+			}
+			if (character === "'" || character === '"') {
+				quote = character;
+				continue;
+			}
+			if (character === "(") depth++;
+			if (character === ")") depth--;
+			if (depth === 0) {
+				ranges.push({ start: assignment.index ?? 0, end: index + 1 });
+				break;
+			}
+		}
+	}
+	return ranges;
+}
+
+function shellSkcBinaryReferenceViolations(contents: string): ShellRange[] {
+	const normalizedContents = normalizeShellContinuations(contents);
+	const arrayRanges = shellArrayAssignmentRanges(normalizedContents);
+	const references = /(["']?)\$(?:SKC_BIN|SKC_SESSION_SKC_BIN|\{(?:SKC_BIN|SKC_SESSION_SKC_BIN)\})\1/g;
+	const violations: ShellRange[] = [];
+	for (const reference of normalizedContents.matchAll(references)) {
+		const start = reference.index ?? 0;
+		const before = normalizedContents.slice(0, start);
+		if (/(?:^|[\s"'])SKC_SESSION_SKC_BIN\s*=\s*$/.test(before)) continue;
+		if (arrayRanges.some(range => start >= range.start && start < range.end)) {
+			violations.push({ start, end: start + reference[0].length });
+			continue;
+		}
+		const lineStart = before.lastIndexOf("\n") + 1;
+		const lineEnd = normalizedContents.indexOf("\n", start);
+		const line = normalizedContents.slice(lineStart, lineEnd === -1 ? normalizedContents.length : lineEnd);
+		const linePrefix = normalizedContents.slice(lineStart, start);
+		const lastConditionalOpen = linePrefix.lastIndexOf("[[");
+		const lastConditionalClose = linePrefix.lastIndexOf("]]");
+		const isConditionalCheck = lastConditionalOpen > lastConditionalClose;
+		const isPythonHeredocArgument = /^\s*python3\s+-\s+.*<<["']PY["']\s*$/.test(line);
+		const isCommandLookup = /\bcommand\s+-v\s*$/.test(linePrefix);
+		const statementStart =
+			Math.max(
+				before.lastIndexOf("\n"),
+				before.lastIndexOf(";"),
+				before.lastIndexOf("|"),
+				before.lastIndexOf("&"),
+				before.lastIndexOf("("),
+			) + 1;
+		const prefix = before.slice(statementStart);
+		const isDirectInvocation = /^\s*$/.test(prefix);
+		const isTimedInvocation = /^\s*timeout\s+(?:"[^"\r\n]*"|'[^'\r\n]*'|[^\s]+)\s+$/.test(prefix);
+		if (
+			!isDirectInvocation &&
+			!isTimedInvocation &&
+			!isConditionalCheck &&
+			!isPythonHeredocArgument &&
+			!isCommandLookup
+		) {
+			violations.push({ start, end: start + reference[0].length });
+		}
+	}
+	return violations;
+}
+
+function pythonFirstArgument(contents: string, openingParen: number): { text: string; start: number } | undefined {
+	let depth = 0;
+	let quote: "'" | '"' | undefined;
+	for (let index = openingParen + 1; index < contents.length; index++) {
+		const character = contents[index];
+		if (quote) {
+			if (character === "\\") {
+				index++;
+			} else if (character === quote) {
+				quote = undefined;
+			}
+			continue;
+		}
+		if (character === "'" || character === '"') {
+			quote = character;
+			continue;
+		}
+		if (character === "(" || character === "[" || character === "{") {
+			depth++;
+			continue;
+		}
+		if (character === ")" || character === "]" || character === "}") {
+			if (depth === 0 && character === ")") {
+				return { text: contents.slice(openingParen + 1, index), start: openingParen + 1 };
+			}
+			depth--;
+			continue;
+		}
+		if (character === "," && depth === 0) {
+			return { text: contents.slice(openingParen + 1, index), start: openingParen + 1 };
+		}
+	}
+	return undefined;
+}
+
+function tmuxCreateStartupViolations(file: string, contents: string): string[] {
+	if (file !== "scripts/skc-session/create.sh") return [];
+	const violations: string[] = [];
+	const violation = (offset: number, detail: string) =>
+		violations.push(`${file}:${lineNumber(contents, offset)}: ${detail}`);
+	const exactArityGuard =
+		/^\s*\[\[\s+\$#\s+-eq\s+2\s+\]\]\s+\|\|\s+\{\s*echo\s+["']Usage:\s+\$0\s+<session-name>\s+<worktree-path>["']\s+>&2;\s+exit\s+2;\s*\}\s*$/gm;
+	const arityGuards = [...contents.matchAll(exactArityGuard)];
+	const topLevelArityGuards = arityGuards.filter(guard =>
+		isUnconditionalTopLevelShellPosition(contents, guard.index ?? 0),
+	);
+	const twoOperandArityChecks = [...contents.matchAll(/\[\[\s+\$#\s+-eq\s+2\s+\]\]/g)];
+	const arityGuard = topLevelArityGuards[0] ?? arityGuards[0];
+	if (arityGuards.length !== 1 || topLevelArityGuards.length !== 1 || twoOperandArityChecks.length !== 1) {
+		violation(arityGuard?.index ?? 0, "human-only tmux owner must have one fail-closed exact two-operand guard");
+	}
+	const positionalRewrites = [...contents.matchAll(/^\s*(?:set\s+--(?:\s|$)|shift(?:\s|$))/gm)];
+	if (positionalRewrites.length > 0) {
+		violation(
+			positionalRewrites[0].index ?? 0,
+			"human-only tmux owner must not rewrite positional arguments before launch",
+		);
+	}
+	const guardStart = arityGuard?.index ?? 0;
+	const guardNeutralizers = [
+		...contents.matchAll(
+			/(?:^|\n)\s*(?:(?:function\s+)?(?:exit|echo)\s*(?:\(\s*\))?\s*\{|alias\s+(?:exit|echo)\b|enable\s+-n\s+(?:exit|echo)\b)/gm,
+		),
+	].filter(match => (match.index ?? 0) < guardStart);
+	if (guardNeutralizers.length > 0) {
+		violation(
+			guardNeutralizers[0].index ?? 0,
+			"human-only tmux owner must not neutralize the exact two-operand guard",
+		);
+	}
+
+	const canonicalCommand = /^\s*command\s*=\s*\[\s*os\.environ\[\s*["']SKC_SESSION_SKC_BIN["']\s*\]\s*\]\s*$/gm;
+	const canonicalCommands = [...contents.matchAll(canonicalCommand)];
+	const commandMutations = [
+		...contents.matchAll(/\bcommand\s*(?:\[[^\]\n]*\]\s*=|\.\s*[A-Za-z_][A-Za-z0-9_]*\s*\(|\+=|=)/g),
+	];
+	if (
+		canonicalCommands.length !== 1 ||
+		commandMutations.length !== 1 ||
+		commandMutations[0]?.index !== canonicalCommands[0]?.index
+	) {
+		violation(
+			commandMutations[0]?.index ?? 0,
+			"human-only tmux owner must launch exactly SKC_SESSION_SKC_BIN with zero startup arguments",
+		);
+	}
+	const canonicalInteractivePopenAssignment =
+		/^\s*child\s*=\s*subprocess\.Popen\(\s*command\s*(?:,\s*cwd\s*=\s*os\.environ\[\s*["']SKC_SESSION_WORKDIR["']\s*\])?\s*\)\s*$/;
+	const expectedLifecycleCallsites = [
+		{
+			operation: "terminal observer",
+			pattern:
+				/\bcompleted\s*=\s*subprocess\.run\(\s*\[\s*os\.environ\[\s*["']SKC_SESSION_SKC_BIN["']\s*\]\s*,\s*["']--internal-tmux-owner-isolation["']\s*\]\s*,/g,
+		},
+		{
+			operation: "owner-isolation plan",
+			pattern:
+				/\bPLAN_RESPONSE\s*=\s*"\$\(\s*printf\s+["'][^"']*["']\s+"\$PLAN_LINE"\s*\|\s*"\$SKC_BIN"\s+--internal-tmux-owner-isolation\s*\)"/g,
+		},
+		{
+			operation: "post-spawn proof",
+			pattern:
+				/\bPOST_SPAWN_RESPONSE\s*=\s*"\$\(\s*printf\s+["'][^"']*["']\s+"\$PLAN_LINE"\s*\|\s*"\$SKC_BIN"\s+--internal-tmux-owner-isolation\s*\)"/g,
+		},
+		{
+			operation: "generation publication",
+			pattern:
+				/\bGENERATION_PUBLISH_RESPONSE\s*=\s*"\$\(\s*printf\s+["'][^"']*["']\s+"\$GENERATION_PUBLISH_REQUEST"\s*\|\s*"\$SKC_BIN"\s+--internal-tmux-owner-isolation\s*\)"/g,
+		},
+		{
+			operation: "terminal monitor",
+			pattern:
+				/\bif\s+verdict\s*=\s*"\$\(\s*printf\s+["'][^"']*["']\s+"\$request"\s*\|\s*timeout\s+"[^"]+"\s+"\$SKC_SESSION_SKC_BIN"\s+--internal-tmux-owner-isolation\s*\)"\s*;\s*then/g,
+		},
+	];
+	const expectedLifecycleRanges: ShellRange[] = [];
+	for (const callsite of expectedLifecycleCallsites) {
+		const matches = [...contents.matchAll(callsite.pattern)];
+		if (matches.length !== 1) {
+			violation(
+				matches[0]?.index ?? 0,
+				`human-only tmux owner must bind one exact ${callsite.operation} lifecycle callsite`,
+			);
+			continue;
+		}
+		const match = matches[0];
+		expectedLifecycleRanges.push({ start: match.index ?? 0, end: (match.index ?? 0) + match[0].length });
+	}
+	const pythonCommandAssignment =
+		/^\s*[A-Za-z_][A-Za-z0-9_]*\s*=\s*(?=(?:\(\s*)?(?:command\b|\[\s*\*?command\b|[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*\s*\(\s*command\b))[^\n]*$/gm;
+	for (const match of contents.matchAll(pythonCommandAssignment)) {
+		if (canonicalInteractivePopenAssignment.test(match[0])) continue;
+		violation(match.index ?? 0, "human-only tmux owner must not construct or wrap a non-lifecycle SKC argv");
+	}
+
+	const allowedSkcEnvironmentReferences: ShellRange[] = canonicalCommands.map(match => ({
+		start: match.index ?? 0,
+		end: (match.index ?? 0) + match[0].length,
+	}));
+	const allowedCommandReferences = [...allowedSkcEnvironmentReferences];
+	const subprocessCalls = /\bsubprocess\.(Popen|run|call|check_call|check_output)\s*\(/g;
+	let interactiveLaunches = 0;
+	for (const match of contents.matchAll(subprocessCalls)) {
+		const openingParen = (match.index ?? 0) + match[0].lastIndexOf("(");
+		const argument = pythonFirstArgument(contents, openingParen);
+		if (!argument) continue;
+		const lineStart = contents.lastIndexOf("\n", match.index ?? 0) + 1;
+		const lineEnd = contents.indexOf("\n", match.index ?? 0);
+		const line = contents.slice(lineStart, lineEnd === -1 ? contents.length : lineEnd);
+		const isInteractiveLaunch =
+			match[1] === "Popen" && argument.text.trim() === "command" && canonicalInteractivePopenAssignment.test(line);
+		const isLifecycleCall =
+			/^\s*\[\s*os\.environ\[\s*["']SKC_SESSION_SKC_BIN["']\s*\]\s*,\s*["']--internal-tmux-owner-isolation["']\s*\]\s*$/.test(
+				argument.text,
+			);
+		if (isInteractiveLaunch) {
+			interactiveLaunches++;
+			allowedCommandReferences.push({ start: lineStart, end: lineEnd === -1 ? contents.length : lineEnd });
+			continue;
+		}
+		if (isLifecycleCall) {
+			const lifecycleStart = match.index ?? 0;
+			if (!expectedLifecycleRanges.some(range => lifecycleStart >= range.start && lifecycleStart < range.end)) {
+				violation(
+					lifecycleStart,
+					"human-only tmux owner must bind owner-isolation to its expected lifecycle callsite",
+				);
+				continue;
+			}
+			allowedSkcEnvironmentReferences.push({ start: argument.start, end: argument.start + argument.text.length });
+			continue;
+		}
+		if (/\bcommand\b|os\.environ\[\s*["']SKC_SESSION_SKC_BIN["']\s*\]/.test(argument.text)) {
+			violation(
+				match.index ?? 0,
+				"human-only tmux owner must invoke SKC only with zero interactive argv or the exact owner-isolation lifecycle argv",
+			);
+		}
+	}
+	for (const match of contents.matchAll(/\[\s*["']skc["'](?:\s*,|\s*\])/g)) {
+		violation(match.index ?? 0, "human-only tmux owner must not launch a literal skc executable");
+	}
+	for (const match of contents.matchAll(/(?:^|\n)\s*(?:export\s+)?[A-Za-z_][A-Za-z0-9_]*\s*=\s*["']skc["']\s*$/gm)) {
+		violation(match.index ?? 0, "human-only tmux owner must not alias or wrap the skc executable");
+	}
+	for (const match of contents.matchAll(
+		/(?:^|\n)\s*(?:alias\s+[A-Za-z_][A-Za-z0-9_]*\s*=\s*['"]?skc\b|(?:function\s+)?[A-Za-z_][A-Za-z0-9_]*\s*\(\s*\)\s*\{[^\n]*\bskc\b)/gm,
+	)) {
+		violation(match.index ?? 0, "human-only tmux owner must not alias or wrap the skc executable");
+	}
+	for (const match of contents.matchAll(
+		/(?:^|[|;&({]\s*|\b(?:command|exec|env|sudo|nice|nohup)\s+)["']?skc["']?(?=\s|$)/gm,
+	)) {
+		violation(match.index ?? 0, "human-only tmux owner must not launch a literal skc executable");
+	}
+	for (const match of contents.matchAll(
+		/\benv(?:\s+(?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s]+)|"[^"]*"|'[^']*'))*\s+["']?skc["']?(?=\s|$)/gm,
+	)) {
+		violation(match.index ?? 0, "human-only tmux owner must not launch a literal skc executable");
+	}
+	for (const match of contents.matchAll(/\b(?:bash|sh)\s+-c\s+(["'])[^\r\n]*?\bskc\b/g)) {
+		violation(match.index ?? 0, "human-only tmux owner must not alias or wrap the skc executable");
+	}
+	if (interactiveLaunches !== 1) {
+		violation(0, "human-only tmux owner must launch exactly one zero-argv interactive SKC process");
+	}
+	for (const match of contents.matchAll(/\bcommand\b/g)) {
+		const offset = match.index ?? 0;
+		const lineStart = contents.lastIndexOf("\n", offset) + 1;
+		const before = contents.slice(lineStart, offset);
+		const lineEnd = contents.indexOf("\n", offset);
+		const after = contents.slice(offset + match[0].length, lineEnd === -1 ? contents.length : lineEnd);
+		if (/\bcommand\s+-[^\s]*\s*$/.test(before) || /^\s+-[A-Za-z]/.test(after)) continue;
+		if (!allowedCommandReferences.some(range => offset >= range.start && offset < range.end)) {
+			violation(offset, "human-only tmux owner must not construct or wrap a non-lifecycle SKC argv");
+		}
+	}
+	for (const match of contents.matchAll(/["']command["']/g)) {
+		violation(match.index ?? 0, "human-only tmux owner must not construct or wrap a non-lifecycle SKC argv");
+	}
+	for (const match of contents.matchAll(/\b(?:globals|locals|vars|getattr|setattr|delattr|eval|exec)\s*\(/g)) {
+		violation(match.index ?? 0, "human-only tmux owner must not construct or wrap a non-lifecycle SKC argv");
+	}
+	for (const match of contents.matchAll(/os\.environ\[\s*["']SKC_SESSION_SKC_BIN["']\s*\]/g)) {
+		const offset = match.index ?? 0;
+		if (!allowedSkcEnvironmentReferences.some(range => offset >= range.start && offset < range.end)) {
+			violation(offset, "human-only tmux owner must not construct or wrap a non-lifecycle SKC argv");
+		}
+	}
+
+	const normalizedContents = normalizeShellContinuations(contents);
+	const normalizedExpectedLifecycleRanges = expectedLifecycleCallsites.flatMap(callsite =>
+		[...normalizedContents.matchAll(callsite.pattern)].map(match => ({
+			start: match.index ?? 0,
+			end: (match.index ?? 0) + match[0].length,
+		})),
+	);
+	const shellSkcInvocations =
+		/(?:^|[|;&(]\s*|\b(?:command|exec)\s+|\btimeout\s+(?:"[^"\r\n]*"|'[^'\r\n]*'|[^\s]+)\s+)(["']?)\$(?:SKC_BIN|SKC_SESSION_SKC_BIN|\{(?:SKC_BIN|SKC_SESSION_SKC_BIN)\})\1([^\r\n;|&)]*)/gm;
+	for (const match of normalizedContents.matchAll(shellSkcInvocations)) {
+		const argumentsText = (match[2] ?? "").trim().replace(/["']$/, "");
+		const isLifecycleCall = /^(?:["']?--internal-tmux-owner-isolation["']?)$/.test(argumentsText);
+		const invocationStart = match.index ?? 0;
+		if (
+			!isLifecycleCall ||
+			!normalizedExpectedLifecycleRanges.some(range => invocationStart >= range.start && invocationStart < range.end)
+		) {
+			violation(invocationStart, "human-only tmux owner invokes SKC with a non-lifecycle startup argument");
+		}
+	}
+	for (const reference of shellSkcBinaryReferenceViolations(contents)) {
+		violation(reference.start, "human-only tmux owner must not construct or wrap a non-lifecycle SKC argv");
+	}
+	for (const match of contents.matchAll(/\bSKC_SESSION_FLAGS\b/g)) {
+		violation(match.index ?? 0, "human-only tmux owner exposes caller-provided startup arguments");
+	}
+	return violations;
+}
+
+const canonicalSdkClientModule = "packages/coding-agent/src/sdk/client/client.ts";
+const coordinatorDirectAuthorityPatterns = [
+	/\bimport\s+(?:type\s+)?[\s\S]*?\sfrom\s*["'][^"']*(?:session\/agent-session|sdk\/session|sdk\/host\/control)["']/g,
+	/\b(?:new\s+)?AgentSession\b/g,
+	/\b(?:agentSession|agent_session|session)\s*\.\s*(?:prompt|promptCustomMessage|abort|abortAndPrompt|followUp|answer)\s*\(/g,
+];
+
+function braceBlockRange(contents: string, openingBrace: number): ShellRange | undefined {
+	const structural = maskCodeComments(contents.slice(openingBrace));
+	let depth = 0;
+	let quote: "'" | '"' | "`" | undefined;
+	for (let relative = 0; relative < structural.length; relative++) {
+		const character = structural[relative];
+		if (quote) {
+			if (character === "\\") relative++;
+			else if (character === quote) quote = undefined;
+			continue;
+		}
+		if (character === "'" || character === '"' || character === "`") {
+			quote = character;
+			continue;
+		}
+		if (character === "{") depth++;
+		if (character === "}") depth--;
+		if (depth === 0) return { start: openingBrace, end: openingBrace + relative + 1 };
+	}
+	return undefined;
+}
+
+function exactTeamRuntimeSendKeysRanges(contents: string): ShellRange[] {
+	const guardMatches = [...contents.matchAll(/if\s*\(\s*useSendKeysFallback\s*\)\s*\{/g)];
+	const payloadMatches = [
+		...contents.matchAll(
+			/Bun\.spawnSync\(\s*\[\s*config\.tmux_command\s*,\s*["']send-keys["']\s*,\s*["']-l["']\s*,\s*["']-t["']\s*,\s*paneId\s*,\s*workerCommand\s*\]\s*,\s*\{[\s\S]{0,200}?stdout\s*:\s*["']ignore["'][\s\S]{0,200}?stderr\s*:\s*["']ignore["'][\s\S]{0,100}?\}\s*\)\s*;/g,
+		),
+	];
+	const continuationPromptMatches = [
+		...contents.matchAll(
+			/(?:const\s+SKC_TEAM_CONTINUATION_PROMPT\s*=\s*["']Continue only your current claimed SKC team task\. Re-read current SKC team state; do not replay prior output; report status\.["']\s*;|import\s*\{[\s\S]{0,1000}?\bSKC_TEAM_CONTINUATION_PROMPT\b[\s\S]{0,1000}?\}\s*from\s*["']\.\/team-workers["']\s*;)/g,
+		),
+	];
+	const continuationMatches = [
+		...contents.matchAll(
+			/const\s+args\s*=\s*Object\.freeze\(\s*\[\s*["']send-keys["']\s*,\s*["']-l["']\s*,\s*["']-t["']\s*,\s*worker\.pane_id\s*,\s*SKC_TEAM_CONTINUATION_PROMPT\s*,\s*["'];["']\s*,\s*["']send-keys["']\s*,\s*["']-t["']\s*,\s*worker\.pane_id\s*,\s*["']Enter["']\s*,?\s*\]\s*\)\s*;\s*const\s+dispatch\s*=\s*skcTeamRuntimeTestSeams\?\.continuationTmuxDispatch\s*\?\s*skcTeamRuntimeTestSeams\.continuationTmuxDispatch\(config\.tmux_command\s*,\s*args\)\s*:\s*Bun\.spawnSync\(\[config\.tmux_command\s*,\s*\.\.\.args\]\s*,\s*\{\s*stdout\s*:\s*["']ignore["']\s*,\s*stderr\s*:\s*["']ignore["']\s*,\s*timeout\s*:\s*SKC_TEAM_CONTINUATION_DISPATCH_TIMEOUT_MS\s*,?\s*\}\s*\)\s*;/g,
+		),
+	];
+	const enterMatches = [
+		...contents.matchAll(
+			/const\s+sendKeys\s*=\s*Bun\.spawnSync\(\s*\[\s*config\.tmux_command\s*,\s*["']send-keys["']\s*,\s*["']-t["']\s*,\s*paneId\s*,\s*["']Enter["']\s*\]\s*,\s*\{[\s\S]{0,200}?stdout\s*:\s*["']ignore["'][\s\S]{0,200}?stderr\s*:\s*["']ignore["'][\s\S]{0,100}?\}\s*\)\s*;/g,
+		),
+	];
+	const fallbackPredicateMatches = [
+		...contents.matchAll(
+			/function\s+shouldDispatchWorkerWithSendKeys\([^)]*\)\s*:\s*boolean\s*\{\s*return\s+platform\s*===\s*["']win32["']\s*\|\|\s*path\.basename\(tmuxCommand\)\.toLowerCase\(\)\s*===\s*["']psmux["']\s*;\s*\}/g,
+		),
+	];
+	const useFallbackMatches = [
+		...contents.matchAll(
+			/const\s+useSendKeysFallback\s*=\s*shouldDispatchWorkerWithSendKeys\(config\.tmux_command\)\s*;/g,
+		),
+	];
+	const splitWorkerCommandMatches = [
+		...contents.matchAll(/\.\.\.\(useSendKeysFallback\s*\?\s*\[\]\s*:\s*\[workerCommand\]\)\s*,/g),
+	];
+	if (
+		guardMatches.length !== 1 ||
+		payloadMatches.length !== 1 ||
+		enterMatches.length !== 1 ||
+		continuationPromptMatches.length !== 1 ||
+		continuationMatches.length !== 1 ||
+		fallbackPredicateMatches.length !== 1 ||
+		useFallbackMatches.length !== 1 ||
+		splitWorkerCommandMatches.length !== 1
+	)
+		return [];
+	const guardStart = guardMatches[0].index ?? 0;
+	const payloadStart = payloadMatches[0].index ?? 0;
+	const enterStart = enterMatches[0].index ?? 0;
+	const voidStart = contents.indexOf("void sendKeys.exitCode;", enterStart);
+	if (
+		(useFallbackMatches[0].index ?? 0) >= (splitWorkerCommandMatches[0].index ?? 0) ||
+		(splitWorkerCommandMatches[0].index ?? 0) >= guardStart ||
+		payloadStart >= enterStart ||
+		voidStart < enterStart
+	)
+		return [];
+	const guard = guardMatches[0];
+	const openingBrace = (guard.index ?? 0) + guard[0].lastIndexOf("{");
+	const range = braceBlockRange(contents, openingBrace);
+	const continuationFunction =
+		/async\s+function\s+continueStalledSkcTeamWorkers\s*\([^)]*\)\s*:\s*Promise<void>\s*\{/.exec(contents);
+	const monitorFence = /await\s+withSkcTeamTaskMutation\([\s\S]{0,500}?async\s+capability\s*=>\s*\{/.exec(contents);
+	if (!range || !continuationFunction || !monitorFence) return [];
+	const continuationOpeningBrace = (continuationFunction.index ?? 0) + continuationFunction[0].lastIndexOf("{");
+	const continuationRange = braceBlockRange(contents, continuationOpeningBrace);
+	const monitorOpeningBrace = (monitorFence.index ?? 0) + monitorFence[0].lastIndexOf("{");
+	const monitorRange = braceBlockRange(contents, monitorOpeningBrace);
+	if (!continuationRange || !monitorRange) return [];
+	const monitorBody = contents.slice(monitorRange.start, monitorRange.end);
+	const continuationCall = /await\s+continueStalledSkcTeamWorkers\s*\(/.exec(monitorBody);
+	const reconciliationCall = /await\s+reconcileSkcTeamStaleClaimsUnlocked\s*\(/.exec(monitorBody);
+	const continuationStart = continuationMatches[0].index ?? 0;
+	const finalValidationStart = contents.lastIndexOf("const revalidationReason =", continuationStart);
+	const skippedBranch = finalValidationStart === -1 ? "" : contents.slice(finalValidationStart, continuationStart);
+	if (
+		payloadStart < range.start ||
+		payloadStart >= range.end ||
+		enterStart < range.start ||
+		enterStart >= range.end ||
+		contents.indexOf("void sendKeys.exitCode;", enterStart) >= range.end ||
+		continuationStart < continuationRange.start ||
+		continuationStart >= continuationRange.end ||
+		finalValidationStart < continuationRange.start ||
+		!continuationCall ||
+		!reconciliationCall ||
+		(continuationCall.index ?? 0) >= (reconciliationCall.index ?? 0) ||
+		!/if\s*\(\s*revalidationReason\s*\)[\s\S]*?return\s*;/.test(skippedBranch)
+	)
+		return [];
+	return [
+		{ start: payloadStart, end: payloadStart + payloadMatches[0][0].length },
+		{ start: enterStart, end: enterStart + enterMatches[0][0].length },
+		{
+			start: continuationMatches[0].index ?? 0,
+			end: (continuationMatches[0].index ?? 0) + continuationMatches[0][0].length,
+		},
+	];
+}
+
+function isExactTmuxScrollCopyModeSendKeys(
+	file: string,
+	contents: string,
+	occurrence: TmuxPrimitiveOccurrence,
+): boolean {
+	if (file !== "packages/coding-agent/src/modes/tmux-scroll.ts" || occurrence.primitive !== "send-keys") return false;
+	const openingBracket = contents.lastIndexOf("[", occurrence.start);
+	const closingBracket = contents.indexOf("]", occurrence.end);
+	if (openingBracket === -1 || closingBracket === -1) return false;
+	return /^\[\s*["']send-keys["']\s*,\s*\.\.\.targetArgs\s*,\s*["']-X["']\s*,\s*(?:["']history-bottom["']|["']search-backward["']\s*,\s*TMUX_PREVIOUS_USER_INPUT_SEARCH_PATTERN)\s*\]$/.test(
+		contents.slice(openingBracket, closingBracket + 1),
+	);
+}
+
+function isTypeOnlyTmuxPrimitiveOccurrence(contents: string, occurrence: TmuxPrimitiveOccurrence): boolean {
+	const lineStart = contents.lastIndexOf("\n", occurrence.start) + 1;
+	const lineEnd = contents.indexOf("\n", occurrence.end);
+	return /^\s*(?:export\s+)?type\b/.test(contents.slice(lineStart, lineEnd === -1 ? contents.length : lineEnd));
+}
+
+function tmuxMachineBusViolations(file: string, contents: string): string[] {
+	if (isGeneratedDocumentationIndex(file)) return [];
+	const allowedTeamFallbackRanges = file === teamRuntimeTmuxPath ? exactTeamRuntimeSendKeysRanges(contents) : [];
+	const violations: string[] = [];
+	for (const occurrence of tmuxPrimitiveOccurrences(contents)) {
+		const isExactTeamFallback =
+			occurrence.primitive === "send-keys" &&
+			allowedTeamFallbackRanges.some(range => occurrence.start >= range.start && occurrence.end <= range.end);
+		if (
+			isExactTeamFallback ||
+			isExactTmuxScrollCopyModeSendKeys(file, contents, occurrence) ||
+			isTypeOnlyTmuxPrimitiveOccurrence(contents, occurrence)
+		)
+			continue;
+		const detail =
+			occurrence.primitive === "capture-pane" || occurrence.primitive === "pipe-pane"
+				? `tmux ${occurrence.primitive} pane access is outside sanctioned test fixtures`
+				: `tmux ${occurrence.primitive} content injection is outside sanctioned process lifecycle`;
+		violations.push(`${file}:${lineNumber(contents, occurrence.start)}: ${detail}`);
+	}
+	return violations;
+}
+
+function lineNumber(contents: string, offset: number): number {
+	return contents.slice(0, offset).split(/\r?\n/).length;
+}
+
+const machineEntrypoints = new Map<string, string>([
+	["packages/coding-agent/src/modes/acp/acp-agent.ts", "ACP"],
+	["packages/coding-agent/src/commands/mcp-serve.ts", "MCP"],
+	["packages/coding-agent/src/sdk/cli/session-cli.ts", "daemon session CLI"],
+]);
+
+const machineWrapperEntrypoints = new Map<string, string>([
+	["packages/coding-agent/src/commands/acp.ts", "ACP command"],
+	["packages/coding-agent/src/commands/daemon.ts", "daemon command"],
+	["packages/coding-agent/src/commands/mcp-serve.ts", "MCP command"],
+	["packages/coding-agent/src/sdk/cli/session-cli.ts", "daemon session CLI"],
+]);
+const rootAcpEntrypoint = "packages/coding-agent/src/main.ts";
+const directMachineWrapperRoutePattern =
+	/(?:\b(?:import|export)\s+(?:type\s+)?(?:[\s\S]*?\s+from\s+)?["'][^"']*(?:session\/agent-session|sdk\/session|sdk\/host\/(?:control|query)|session\/client-bridge|modes\/(?:rpc|bridge)|\/(?:rpc|bridge)(?=[-"'/.]|$)|unattended)(?:[-"'/.]|$)|\bimport\s*\(\s*["'][^"']*(?:session\/agent-session|sdk\/session|sdk\/host\/(?:control|query)|session\/client-bridge|modes\/(?:rpc|bridge)|\/(?:rpc|bridge)(?=[-"'/.]|$)|unattended)(?:[-"'/.]|$)|["'](?:rpc|bridge)(?:[-"'/.]|$)|--mode(?:\s+|=)["']?rpc(?:\b|["'])|["']--mode["']\s*,\s*["']rpc["']|\b(?:new\s+)?AgentSession\b|\b(?:agentSession|agent_session|session)\s*\.\s*(?:prompt|promptCustomMessage|abort|abortAndPrompt|followUp|answer)\s*\(|(?:Bun\.(?:spawn|spawnSync)|runner)\s*\(\s*\[[^\]]*?\b(?:tmux|tmux_command)\b)/g;
+
+function directMachineWrapperRouteViolations(file: string, owner: string, contents: string): string[] {
+	return [...contents.matchAll(directMachineWrapperRoutePattern)].map(
+		match =>
+			`${file}:${lineNumber(contents, match.index ?? 0)}: ${owner} wrapper bypasses SDK/ACP/Coordinator through direct session, RPC, or tmux routing (${match[0]})`,
+	);
+}
+
+function rootAcpModeViolations(contents: string): string[] {
+	const branch = /if\s*\(\s*mode\s*===\s*["']acp["']\s*\)\s*\{([\s\S]*?)\n\s*\}\s*else\s*\{/.exec(contents)?.[1];
+	if (branch === undefined) return [`${rootAcpEntrypoint}: root --mode acp lacks an isolated ACP dispatch branch`];
+	const violations: string[] = [];
+	if (
+		!/await\s*\(\s*deps\.runAcpMode\s*\?\?\s*\(await import\(["']\.\/modes\/acp["']\)\)\.runAcpMode\)\s*\(/.test(
+			branch,
+		)
+	) {
+		violations.push(`${rootAcpEntrypoint}: root --mode acp must dispatch only through the SDK ACP bootstrap`);
+	}
+	const branchOffset = contents.indexOf(branch);
+	for (const match of branch.matchAll(directMachineWrapperRoutePattern)) {
+		violations.push(
+			`${rootAcpEntrypoint}:${lineNumber(contents, branchOffset + (match.index ?? 0))}: root --mode acp bypasses SDK ACP through direct session, RPC, or tmux routing (${match[0]})`,
+		);
+	}
+	return violations;
+}
+
+const relativeImportPattern =
+	/(?:import|export)\s+(?:type\s+)?(?:[^"'`;]*?\s+from\s+)?["']([^"']+)["']|import\s*\(\s*["']([^"']+)["']\s*\)/g;
+const sourceExtensions = [".ts", ".tsx", ".mts", ".cts"];
+
+function isProductionTypeScript(file: string): boolean {
+	return (
+		file.startsWith("packages/coding-agent/src/") &&
+		/\.(?:[cm]?tsx?)$/.test(file) &&
+		!/\.(?:test|spec)\.[cm]?tsx?$/.test(file)
+	);
+}
+
+function isProductionTypeScriptOrJavaScript(file: string): boolean {
+	return (
+		file.startsWith("packages/coding-agent/src/") &&
+		/\.(?:[cm]?[jt]sx?)$/.test(file) &&
+		!/\.(?:test|spec)\.[cm]?[jt]sx?$/.test(file)
+	);
+}
+
+function relativeImports(contents: string): string[] {
+	return [...contents.matchAll(relativeImportPattern)]
+		.map(match => match[1] ?? match[2])
+		.filter(specifier => specifier.startsWith("."));
+}
+
+function resolveRelativeImport(importer: string, specifier: string, sourceFiles: Set<string>): string | undefined {
+	const resolved = path.posix.normalize(path.posix.join(path.posix.dirname(importer), specifier));
+	const extension = path.posix.extname(resolved);
+	const nodeNextSourceExtensions =
+		extension === ".js" ? [".ts", ".tsx"] : extension === ".mjs" ? [".mts"] : extension === ".cjs" ? [".cts"] : [];
+	const candidates = extension
+		? [
+				...nodeNextSourceExtensions.map(
+					sourceExtension => `${resolved.slice(0, -extension.length)}${sourceExtension}`,
+				),
+				resolved,
+			]
+		: [
+				...sourceExtensions.map(sourceExtension => `${resolved}${sourceExtension}`),
+				...sourceExtensions.map(sourceExtension => `${resolved}/index${sourceExtension}`),
+			];
+	return candidates.find(candidate => sourceFiles.has(candidate));
+}
+
+function importGraphReaches(root: string, target: string, contentsByFile: Map<string, string>): boolean {
+	const sourceFiles = new Set(contentsByFile.keys());
+	const pending = [root];
+	const visited = new Set<string>();
+	while (pending.length > 0) {
+		const current = pending.shift();
+		if (!current || visited.has(current)) continue;
+		if (current === target) return true;
+		visited.add(current);
+		for (const specifier of relativeImports(contentsByFile.get(current) ?? "")) {
+			const resolved = resolveRelativeImport(current, specifier, sourceFiles);
+			if (resolved && !visited.has(resolved)) pending.push(resolved);
+		}
+	}
+	return false;
+}
+
+function scanPackageExports(contents: string, sourceFiles: readonly string[]): string[] {
+	let manifest: { exports?: Record<string, unknown> };
+	try {
+		manifest = JSON.parse(contents) as { exports?: Record<string, unknown> };
+	} catch (error) {
+		return [
+			`${packageManifestPath}: invalid package manifest: ${error instanceof Error ? error.message : String(error)}`,
+		];
+	}
+	if (!manifest.exports || typeof manifest.exports !== "object") return [];
+
+	const violations: string[] = [];
+	for (const [exportPath, target] of Object.entries(manifest.exports)) {
+		if (target === null) continue;
+		if (/^\.\/modes\/rpc(?:[A-Za-z0-9_./-]|$)/i.test(exportPath)) {
+			violations.push(
+				`${packageManifestPath}: removed RPC mode remains externally exported as ${JSON.stringify(exportPath)}`,
+			);
+		}
+		if (/(?:^|\/|[-_])(?:bridge|unattended)[A-Za-z0-9_.-]*(?:\/|$)/i.test(exportPath)) {
+			violations.push(
+				`${packageManifestPath}: removed bridge or unattended surface remains externally exported as ${JSON.stringify(exportPath)}`,
+			);
+		}
+	}
+	for (const sourceFile of sourceFiles) {
+		if (!retiredIngressSource(sourceFile)) continue;
+		const sourcePath = `./${sourceFile.slice("packages/coding-agent/".length)}`;
+		for (const [exportPath, target] of Object.entries(manifest.exports)) {
+			if (!exportPath.includes("*")) continue;
+			if (broadExportReachesSource(manifest.exports, exportPath, target, sourcePath)) {
+				violations.push(
+					`${packageManifestPath}: retired ingress source ${sourceFile} is reachable through broad export ${JSON.stringify(exportPath)}`,
+				);
+			}
+		}
+	}
+	for (const subpath of retiredAgentWireSubpaths) {
+		if (resolveExportTarget(manifest.exports, subpath) != null) {
+			violations.push(
+				`${packageManifestPath}: retired agent-wire surface remains externally exported as ${JSON.stringify(subpath)}`,
+			);
+		}
+	}
+	return violations;
+}
+
+function forbiddenMachineModule(file: string): string | undefined {
+	if (file === "packages/coding-agent/src/modes/acp/acp-event-mapper.ts") return undefined;
+	if (file === "packages/coding-agent/src/main.ts" || file === "packages/coding-agent/src/modes/interactive-mode.ts")
+		return "process bootstrap/main session host";
+	if (file === "packages/coding-agent/src/sdk/session.ts") return "direct session mutation module";
+	if (file === "packages/coding-agent/src/session/agent-session.ts") return "AgentSession";
+	if (file.startsWith("packages/coding-agent/src/runtime-mcp/")) return "MCPManager";
+	if (file === "packages/coding-agent/src/extensibility/extensions/runner.ts") return "extension runner";
+	if (
+		file === "packages/coding-agent/src/session/client-bridge.ts" ||
+		file === "packages/coding-agent/src/modes/acp/acp-client-bridge.ts"
+	)
+		return "direct client bridge";
+	if (
+		file === "packages/coding-agent/src/sdk/host/control.ts" ||
+		file === "packages/coding-agent/src/sdk/host/query.ts"
+	)
+		return "host control/query dispatch";
+	if (file.startsWith("packages/coding-agent/src/session/")) return "direct session mutation module";
+	return undefined;
+}
+
+function scanMachineImportGraphs(contentsByFile: Map<string, string>): string[] {
+	const sourceFiles = new Set(contentsByFile.keys());
+	const violations: string[] = [];
+	for (const [root, owner] of machineEntrypoints) {
+		if (!sourceFiles.has(root)) continue;
+		const pending = [{ file: root, chain: [root] }];
+		const visited = new Set<string>();
+		while (pending.length > 0) {
+			const current = pending.shift();
+			if (!current || visited.has(current.file)) continue;
+			visited.add(current.file);
+			const forbidden = current.file === root ? undefined : forbiddenMachineModule(current.file);
+			if (forbidden) {
+				violations.push(
+					`${root}: ${owner} machine entrypoint reaches forbidden ${forbidden} via ${current.chain.join(" -> ")}`,
+				);
+				continue;
+			}
+			if (current.file === "packages/coding-agent/src/modes/acp/acp-event-mapper.ts") continue;
+			for (const specifier of relativeImports(contentsByFile.get(current.file) ?? "")) {
+				const target = resolveRelativeImport(current.file, specifier, sourceFiles);
+				if (target && !visited.has(target)) pending.push({ file: target, chain: [...current.chain, target] });
+			}
+		}
+	}
+	return violations;
+}
+
+async function scan(): Promise<string[]> {
+	const deleted = new Set(commandOutput(["git", "ls-files", "-z", "--deleted"]).split("\0").filter(Boolean));
+	const files = commandOutput(["git", "ls-files", "-z", "--cached", "--others", "--exclude-standard"])
+		.split("\0")
+		.filter(file => file && !deleted.has(file));
+	const violations: string[] = [];
+	const contentsByFile = new Map<string, string>();
+
+	for (const file of files) {
+		if (retiredIngressSource(file)) {
+			violations.push(`${file}: retired RPC/bridge/unattended ingress source survived`);
+		}
+
+		if (file.startsWith(retiredPythonRpcPackagePath)) {
+			violations.push(`${file}: retired Python skc-rpc package source survived`);
+		}
+		if (retiredTmuxMachineBusPaths.has(file)) {
+			violations.push(`${file}: retired tmux machine prompt or viewing helper survived`);
+		}
+		if (machineTmuxDocumentationPaths.has(file)) {
+			const contents = await Bun.file(path.join(repoRoot, file)).text();
+			const normalizedContents = normalizeShellContinuations(contents);
+			for (const match of normalizedContents.matchAll(machineTmuxDocumentationPattern)) {
+				violations.push(
+					`${file}:${lineNumber(normalizedContents, match.index ?? 0)}: published machine documentation directs tmux prompt or viewing access`,
+				);
+			}
+		}
+		if (isPublishedSkcSessionShellHelper(file)) {
+			const contents = await Bun.file(path.join(repoRoot, file)).text();
+			const occurrences = tmuxPrimitiveOccurrences(contents);
+			for (const match of contents.matchAll(
+				/\b(?:load-buffer|paste-buffer|send-keys|capture-pane|pipe-pane|set-buffer)\b/g,
+			)) {
+				const start = match.index ?? 0;
+				if (!occurrences.some(occurrence => start >= occurrence.start && start < occurrence.end)) {
+					occurrences.push({
+						primitive: match[0] as TmuxMachineBusPrimitive,
+						start,
+						end: start + match[0].length,
+					});
+				}
+			}
+			for (const occurrence of occurrences) {
+				violations.push(
+					`${file}:${lineNumber(contents, occurrence.start)}: published shell helper performs tmux machine prompt injection or pane viewing`,
+				);
+			}
+			violations.push(...tmuxCreateStartupViolations(file, contents));
+		}
+		if (file === scannerPath || !isSource(file)) continue;
+
+		let contents: string;
+		try {
+			contents = await Bun.file(path.join(repoRoot, file)).text();
+		} catch (error) {
+			throw new Error(
+				`Unable to scan tracked file ${file}: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+		violations.push(...rpcModeInvocationViolations(file, contents));
+		if (isActiveLegacyPythonRpcTarget(file)) violations.push(...legacyPythonRpcViolations(file, contents));
+		if (file === packageManifestPath) violations.push(...scanPackageExports(contents, files));
+		violations.push(...bridgeClientImportViolations(file, contents));
+		violations.push(...bridgeClientOwnershipViolations(file, contents));
+		const bridgeClientMetadataViolation = bridgeClientPackageMetadataViolation(file, contents);
+		if (bridgeClientMetadataViolation) violations.push(bridgeClientMetadataViolation);
+
+		if (isProductionTypeScript(file)) contentsByFile.set(file, contents);
+		const wrapper = machineWrapperEntrypoints.get(file);
+		if (wrapper) violations.push(...directMachineWrapperRouteViolations(file, wrapper, contents));
+		if (file === rootAcpEntrypoint) violations.push(...rootAcpModeViolations(contents));
+
+		for (const match of contents.matchAll(
+			/(?:import|export)\s+(?:type\s+)?(?:[\s\S]*?\s+from\s+)?["'][^"']*modes\/(?:rpc|bridge|unattended)[A-Za-z0-9_.-]*(?:["'/]|$)/gi,
+		)) {
+			violations.push(
+				`${file}:${lineNumber(contents, match.index ?? 0)}: imports removed modes/rpc or modes/bridge`,
+			);
+		}
+		for (const match of contents.matchAll(bridgeOrUnattendedImportPattern)) {
+			violations.push(`${file}:${lineNumber(contents, match.index ?? 0)}: imports removed unattended surface`);
+		}
+
+		for (const match of contents.matchAll(/\bSKC_BRIDGE_[A-Z0-9_]*\b/g)) {
+			violations.push(
+				`${file}:${lineNumber(contents, match.index ?? 0)}: forbidden bridge environment reference ${match[0]}`,
+			);
+		}
+
+		if (file === "packages/coding-agent/src/cli.ts") {
+			const modeFlag = /mode:\s*Flags\.string\([\s\S]*?options:\s*\[([^\]]*)\]/.exec(contents);
+			if (modeFlag && /["'](?:rpc|rpc-ui|bridge)["']/.test(modeFlag[1])) {
+				violations.push(`${file}: --mode option retains rpc, rpc-ui, or bridge`);
+			}
+		}
+		if (file === "packages/coding-agent/src/commands/acp.ts") {
+			if (
+				!/parsed\.mode\s*=\s*["']acp["']/.test(contents) ||
+				!/runRootCommand\s*\(\s*parsed\s*,\s*args\s*\)/.test(contents)
+			) {
+				violations.push(`${file}: shipped ACP command does not dispatch through the root ACP bootstrap`);
+			}
+		}
+		if (file === "packages/coding-agent/src/commands/daemon.ts") {
+			if (!/runSdkSessionCli\s*\(/.test(contents)) {
+				violations.push(`${file}: shipped daemon session command does not dispatch the SDK session CLI`);
+			}
+		}
+		if (file === "packages/coding-agent/src/modes/acp/acp-agent.ts") {
+			if (!/from\s*["'][^"']*sdk\/acp(?:\/adapter)?["']/.test(contents)) {
+				violations.push(`${file}: shipped ACP entrypoint does not import the SDK ACP adapter`);
+			}
+			for (const match of contents.matchAll(/\brecord\.session\.(?:prompt|promptCustomMessage|abort)\s*\(/g)) {
+				violations.push(
+					`${file}:${lineNumber(contents, match.index ?? 0)}: shipped ACP entrypoint bypasses SDK control`,
+				);
+			}
+		}
+		if (file === "packages/coding-agent/src/commands/mcp-serve.ts") {
+			if (
+				!/from\s*["'][^"']*sdk\/mcp\/server["']/.test(contents) ||
+				!/from\s*["'][^"']*coordinator-mcp\/server["']/.test(contents) ||
+				!/runSdkMcpStdio\s*\(/.test(contents) ||
+				!/runCoordinatorMcpStdio\s*\(/.test(contents)
+			) {
+				violations.push(`${file}: shipped MCP command does not dispatch the SDK MCP server`);
+			}
+		}
+
+		const createsListener =
+			/\b(?:Bun\.(?:serve|listen)|\w+\.createServer\s*\(|\w+\.listen\s*\(|new\s+NotificationServer\s*\()/.test(
+				contents,
+			);
+		const importsSessionInternals =
+			/import[\s\S]*?from\s*["'][^"']*(?:agent-session|sdk\/host\/control|session\/agent-session)["']/.test(
+				contents,
+			);
+		if (
+			createsListener &&
+			importsSessionInternals &&
+			file.startsWith("packages/coding-agent/src/") &&
+			!sanctionedServerHosts.has(file)
+		) {
+			violations.push(`${file}: listener imports AgentSession or dispatch internals outside a sanctioned host`);
+		}
+
+		if (isProductionTypeScriptOrJavaScript(file)) {
+			if (file === coordinatorMcpRoot) {
+				for (const occurrence of tmuxPrimitiveOccurrences(contents)) {
+					const detail =
+						occurrence.primitive === "capture-pane" || occurrence.primitive === "pipe-pane"
+							? "coordinator MCP reads tmux pane content outside SDK queries"
+							: `tmux ${occurrence.primitive} content injection is outside sanctioned process lifecycle`;
+					violations.push(`${file}:${lineNumber(contents, occurrence.start)}: ${detail}`);
+				}
+			} else {
+				violations.push(...tmuxMachineBusViolations(file, contents));
+			}
+			if (
+				file === teamWorkersTmuxPath &&
+				!/^export const SKC_TEAM_CONTINUATION_PROMPT =\n\t"Continue only your current claimed SKC team task\. Re-read current SKC team state; do not replay prior output; report status\.";$/m.test(
+					contents,
+				)
+			)
+				violations.push(
+					`${file}: stalled-worker continuation prompt must remain the exact source-controlled literal`,
+				);
+		}
+		if (file === coordinatorMcpRoot) {
+			for (const pattern of coordinatorDirectAuthorityPatterns) {
+				for (const match of contents.matchAll(pattern)) {
+					violations.push(
+						`${file}:${lineNumber(contents, match.index ?? 0)}: coordinator MCP directly mutates AgentSession or control internals`,
+					);
+				}
+			}
+		}
+	}
+	violations.push(...scanMachineImportGraphs(contentsByFile));
+	if (
+		contentsByFile.has(coordinatorMcpRoot) &&
+		!importGraphReaches(coordinatorMcpRoot, canonicalSdkClientModule, contentsByFile)
+	) {
+		violations.push(
+			`${coordinatorMcpRoot}: coordinator MCP does not reach the canonical SDK client through its import graph`,
+		);
+	}
+	return violations;
+}
+
+interface SelfTestFixtureOptions {
+	expectedDiagnostics?: readonly string[];
+	timeoutMs?: number;
+}
+
+async function runSelfTestFixture(
+	files: Record<string, string>,
+	expectedExitCode: number,
+	expectedOutput?: string,
+	options: SelfTestFixtureOptions = {},
+): Promise<void> {
+	const fixture = await fs.mkdtemp(path.join(os.tmpdir(), "skc-sdk-canonicalization-"));
+	try {
+		for (const [file, contents] of Object.entries(files)) {
+			const destination = path.join(fixture, file);
+			await fs.mkdir(path.dirname(destination), { recursive: true });
+			await fs.writeFile(destination, contents);
+		}
+		const init = Bun.spawnSync(["git", "init", "-q"], { cwd: fixture, stdout: "pipe", stderr: "pipe" });
+		const add = Bun.spawnSync(["git", "add", "."], { cwd: fixture, stdout: "pipe", stderr: "pipe" });
+		if (init.exitCode !== 0 || add.exitCode !== 0) throw new Error("unable to create scanner self-test fixture");
+		const timeoutMs = options.timeoutMs ?? 10_000;
+		const scanner = Bun.spawn([process.execPath, import.meta.path], {
+			cwd: repoRoot,
+			env: { ...process.env, SKC_SDK_CANONICALIZATION_SCAN_ROOT: fixture },
+			stdout: "pipe",
+			stderr: "pipe",
+			timeout: timeoutMs,
+		});
+		const [exitCode, stdout, stderr] = await Promise.all([
+			scanner.exited,
+			new Response(scanner.stdout).text(),
+			new Response(scanner.stderr).text(),
+		]);
+		const output = `${stdout}${stderr}`;
+		if (scanner.signalCode !== null) {
+			throw new Error(`self-test timed out after ${timeoutMs}ms: ${output}`);
+		}
+		if (exitCode !== expectedExitCode) {
+			throw new Error(`self-test expected exit ${expectedExitCode}, got ${exitCode}: ${output}`);
+		}
+		if (expectedOutput && !output.includes(expectedOutput)) {
+			throw new Error(`self-test expected output ${JSON.stringify(expectedOutput)}, got: ${output}`);
+		}
+		if (options.expectedDiagnostics) {
+			const diagnostics = output.split(/\r?\n/).filter(line => line.endsWith(": invokes removed --mode rpc"));
+			if (
+				diagnostics.length !== options.expectedDiagnostics.length ||
+				diagnostics.some((diagnostic, index) => diagnostic !== options.expectedDiagnostics?.[index])
+			) {
+				throw new Error(
+					`self-test expected diagnostics ${JSON.stringify(options.expectedDiagnostics)}, got ${JSON.stringify(diagnostics)}`,
+				);
+			}
+		}
+	} finally {
+		await fs.rm(fixture, { recursive: true, force: true });
+	}
+}
+
+const retiredModeFixtureDirectory = "packages/coding-agent/test/fixtures/";
+
+function retiredModeFixturePath(name: string): string {
+	return `${retiredModeFixtureDirectory}${name}`;
+}
+
+function retiredModeDiagnostic(file: string, line = 1): string {
+	return `${file}:${line}: invokes removed --mode rpc`;
+}
+
+interface ExactRetiredModeFixtureOptions {
+	expectedOutput?: string;
+	timeoutMs?: number;
+}
+
+async function runExactRetiredModeFixture(
+	name: string,
+	contents: string,
+	expectedExitCode: number,
+	expectedDiagnostics: readonly string[],
+	options: ExactRetiredModeFixtureOptions = {},
+): Promise<void> {
+	const file = retiredModeFixturePath(name);
+	await runSelfTestFixture({ [file]: contents }, expectedExitCode, options.expectedOutput, {
+		expectedDiagnostics,
+		timeoutMs: options.timeoutMs,
+	});
+}
+
+function staticBinaryExpression(left: string, right: string, operandCount: number): string {
+	return [JSON.stringify(left), JSON.stringify(right), ...Array.from({ length: operandCount - 2 }, () => '""')].join(
+		" + ",
+	);
+}
+
+function sourceLocationAt(contents: string, offset: number): { line: number; column: number } {
+	return {
+		line: lineNumber(contents, offset),
+		column: offset - contents.lastIndexOf("\n", offset - 1) - 1,
+	};
+}
+
+function staticBudgetDiagnostic(
+	file: string,
+	location: { line: number; column: number },
+	kind: StaticAnalysisBudgetKind,
+	limit: number,
+	observed: number,
+): string {
+	return `${file}:${location.line}:${location.column}: static retired-mode analysis budget exceeded (kind=${kind}, limit=${limit}, observed=${observed})`;
+}
+
+function aliasChainSource(bindingCount: number): string {
+	const bindings = Array.from({ length: bindingCount }, (_, index) =>
+		index === 0 ? 'const a0 = "rpc";' : `const a${index} = a${index - 1};`,
+	);
+	return `${bindings.join("\n")}\nBun.spawnSync(["--mode", a${bindingCount - 1}]);\n`;
+}
+
+async function selfTest(): Promise<void> {
+	await runSelfTestFixture(
+		{ "packages/coding-agent/package.json": '{"exports":{"./modes/rpc/*":"./src/modes/rpc/*.ts"}}\n' },
+		1,
+		"removed RPC mode remains externally exported",
+	);
+	await runSelfTestFixture(
+		{ "packages/coding-agent/package.json": '{"exports":{"./modes/rpc-compat/*":"./src/modes/rpc-compat/*.ts"}}\n' },
+		1,
+		"removed RPC mode remains externally exported",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/test/fixtures/rpc-compat-mode.ts": 'Bun.spawnSync(["skc", "--mode", "rpc-compat"]);\n',
+		},
+		1,
+		"invokes removed --mode rpc",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/test/fixtures/bridge-compat-mode.ts":
+				'Bun.spawnSync(["skc", "--mode", "bridge-compat"]);\n',
+		},
+		1,
+		"invokes removed --mode rpc",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/test/fixtures/aliased-retired-modes.ts":
+				'const rpcMode = "rpc";\nlet bridgeMode = "bridge-compat";\nvar unattendedMode = "unattended";\nBun.spawnSync(["skc", "--mode", rpcMode]);\nBun.spawnSync(["skc", "--mode", bridgeMode]);\nBun.spawnSync(["skc", "--mode", unattendedMode]);\n',
+		},
+		1,
+		"invokes removed --mode rpc",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/test/fixtures/constructed-aliased-retired-modes.ts":
+				'const rpcPrefix = "r";\nconst rpcMode = rpcPrefix + "pc";\nconst bridgeMode = ["brid", "ge-compat"].join("");\nconst unattendedPrefix = "un";\nvar unattendedMode = unattendedPrefix + "attended";\nconst args = ["skc", "--mode", rpcMode];\nBun.spawnSync(args);\nBun.spawnSync(["skc", "--mode", bridgeMode]);\nBun.spawnSync(["skc", "--mode", unattendedMode]);\n',
+		},
+		1,
+		"invokes removed --mode rpc",
+	);
+	await runExactRetiredModeFixture(
+		"typed-rpc-alias.ts",
+		'const retiredMode: string = "rpc"; Bun.spawnSync(["skc", "--mode", retiredMode]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("typed-rpc-alias.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"typed-bridge-alias.ts",
+		'const retiredMode: string = "bridge-compat"; Bun.spawnSync(["skc", "--mode", retiredMode]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("typed-bridge-alias.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"typed-unattended-alias.ts",
+		'const retiredMode: string = "unattended"; Bun.spawnSync(["skc", "--mode", retiredMode]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("typed-unattended-alias.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"ts-as-string.ts",
+		'const mode = "rpc" as string; Bun.spawnSync(["skc", "--mode", mode]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("ts-as-string.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"ts-as-const.ts",
+		'const mode = "rpc" as const; Bun.spawnSync(["skc", "--mode", mode]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("ts-as-const.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"ts-use-assertion.ts",
+		'const mode = "rpc"; Bun.spawnSync(["skc", "--mode", mode as string]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("ts-use-assertion.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"ts-angle-assertion.ts",
+		'const mode = <string>"rpc"; Bun.spawnSync(["skc", "--mode", mode]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("ts-angle-assertion.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"ts-satisfies.ts",
+		'const mode = "rpc" satisfies string; Bun.spawnSync(["skc", "--mode", mode]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("ts-satisfies.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"ts-non-null.ts",
+		'const mode = ("rpc" as string)!; Bun.spawnSync(["skc", "--mode", mode]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("ts-non-null.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"parenthesized-alias.ts",
+		'const mode = (("rpc")); Bun.spawnSync(["skc", "--mode", mode]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("parenthesized-alias.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"typed-alias-chain.ts",
+		'const prefix: string = "r"; const mode = (prefix + "pc") as string; Bun.spawnSync(["skc", "--mode", mode]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("typed-alias-chain.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"template-alias.ts",
+		`const prefix = "r"; const mode = \`\${prefix}pc\`; Bun.spawnSync(["skc", "--mode", mode]);\n`,
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("template-alias.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"literal-join-alias.ts",
+		'const mode = ["r", "pc"].join(""); Bun.spawnSync(["skc", "--mode", mode]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("literal-join-alias.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"constructed-mode-flag-alias.ts",
+		'const flag = ["--", "mode"].join(""); const mode: string = "rpc"; Bun.spawnSync(["skc", flag, mode]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("constructed-mode-flag-alias.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"constructed-mode-flag-join.ts",
+		'Bun.spawnSync(["skc", ["--m", "ode"].join(""), "rpc"]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("constructed-mode-flag-join.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"constructed-mode-flag-binary.ts",
+		'const mode: string = "rpc"; Bun.spawnSync(["skc", "--m" + "ode", mode]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("constructed-mode-flag-binary.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"constructed-mode-flag-template.ts",
+		`const suffix = "ode"; Bun.spawnSync(["skc", \`--m\${suffix}\`, "rpc"]);\n`,
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("constructed-mode-flag-template.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"constructed-mode-flag-aliased.ts",
+		'const flag = ["--m", "ode"].join(""); const mode: string = "rpc"; Bun.spawnSync(["skc", flag, mode]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("constructed-mode-flag-aliased.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"inner-retired-shadow.ts",
+		'const mode = "acp";\n{ const mode: string = "rpc"; Bun.spawnSync(["skc", "--mode", mode]); }\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("inner-retired-shadow.ts"), 2)],
+	);
+	await runExactRetiredModeFixture(
+		"closure-forward-const.ts",
+		'const launch = () => Bun.spawnSync(["skc", "--mode", mode]);\nconst mode = "rpc";\nlaunch();\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("closure-forward-const.ts"), 1)],
+	);
+	await runExactRetiredModeFixture(
+		"safe-block-shadow.ts",
+		'const mode = "rpc"; { const mode = "acp"; Bun.spawnSync(["skc", "--mode", mode]); }\n',
+		0,
+		[],
+	);
+	await runExactRetiredModeFixture(
+		"parameter-shadow.ts",
+		'const mode = "rpc"; function launch(mode: string) { Bun.spawnSync(["skc", "--mode", mode]); } launch("acp");\n',
+		0,
+		[],
+	);
+	await runExactRetiredModeFixture(
+		"catch-shadow.ts",
+		'const mode = "rpc"; try { throw "acp"; } catch (mode) { Bun.spawnSync(["skc", "--mode", mode]); }\n',
+		0,
+		[],
+	);
+	await runExactRetiredModeFixture(
+		"destructure-shadow.ts",
+		'const mode = "rpc"; const { mode: shadow } = { mode: "acp" }; Bun.spawnSync(["skc", "--mode", shadow]);\n',
+		0,
+		[],
+	);
+	await runExactRetiredModeFixture(
+		"sibling-shadow.ts",
+		'{ const mode = "rpc"; void mode; } { const mode = "acp"; Bun.spawnSync(["skc", "--mode", mode]); }\n',
+		0,
+		[],
+	);
+	await runExactRetiredModeFixture(
+		"direct-tdz.ts",
+		'Bun.spawnSync(["skc", "--mode", mode]); const mode = "rpc";\n',
+		0,
+		[],
+	);
+	await runExactRetiredModeFixture(
+		"pre-use-safe-to-retired.ts",
+		'let mode = "acp"; mode = "rpc"; Bun.spawnSync(["skc", "--mode", mode]);\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("pre-use-safe-to-retired.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"pre-use-retired-to-safe.ts",
+		'let mode = "rpc"; mode = "acp"; Bun.spawnSync(["skc", "--mode", mode]);\n',
+		0,
+		[],
+	);
+	await runExactRetiredModeFixture(
+		"later-safe-write.ts",
+		'let mode = "rpc"; Bun.spawnSync(["skc", "--mode", mode]); mode = "acp";\n',
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("later-safe-write.ts"))],
+	);
+	await runExactRetiredModeFixture(
+		"later-retired-write.ts",
+		'let mode = "acp"; Bun.spawnSync(["skc", "--mode", mode]); mode = "rpc";\n',
+		0,
+		[],
+	);
+	await runExactRetiredModeFixture(
+		"branch-write.ts",
+		'let mode = "acp"; if (condition) mode = "rpc"; Bun.spawnSync(["skc", "--mode", mode]);\n',
+		0,
+		[],
+	);
+	await runExactRetiredModeFixture(
+		"compound-write.ts",
+		'let mode = "rpc"; mode += "-compat"; Bun.spawnSync(["skc", "--mode", mode]);\n',
+		0,
+		[],
+	);
+	await runExactRetiredModeFixture(
+		"update-write.ts",
+		'let mode = "rpc"; mode++; Bun.spawnSync(["skc", "--mode", mode]);\n',
+		0,
+		[],
+	);
+	await runExactRetiredModeFixture(
+		"dynamic-member-controls.ts",
+		'const dynamicMode = process.env.MODE; const state = { mode: "rpc" }; Bun.spawnSync(["skc", "--mode", dynamicMode]); Bun.spawnSync(["skc", "--mode", state.mode]);\n',
+		0,
+		[],
+	);
+	await runExactRetiredModeFixture(
+		"typed-acp-control.ts",
+		'const mode: string = "acp"; Bun.spawnSync(["skc", "--mode", mode]);\n',
+		0,
+		[],
+	);
+	await runExactRetiredModeFixture("unused-retired-alias.ts", 'const mode = "rpc"; void mode;\n', 0, []);
+	await runExactRetiredModeFixture(
+		"unrelated-array.ts",
+		'const values = ["rpc", "bridge-compat", "unattended"]; void values;\n',
+		0,
+		[],
+	);
+	await runExactRetiredModeFixture(
+		"cycle.ts",
+		'const a = b; const b = a; Bun.spawnSync(["skc", "--mode", a]);\n',
+		0,
+		[],
+		{ timeoutMs: 2_000 },
+	);
+	await runExactRetiredModeFixture("deduplicated-direct-mode.ts", 'Bun.spawnSync(["skc", "--mode", "rpc"]);\n', 1, [
+		retiredModeDiagnostic(retiredModeFixturePath("deduplicated-direct-mode.ts")),
+	]);
+	await runExactRetiredModeFixture(
+		"harmless-comment.ts",
+		'// RPC compatibility was retired; use ACP instead.\nconst mode = "acp";\nvoid mode;\n',
+		0,
+		[],
+	);
+	const parserFixtures: ReadonlyArray<readonly [string, string]> = [
+		["parser-js.js", 'const mode = "acp";\n'],
+		["parser-jsx.jsx", "const element = <div />;\nvoid element;\n"],
+		["parser-mjs.mjs", 'export const mode = "acp";\n'],
+		["parser-cjs.cjs", 'const mode = "acp";\n'],
+		["parser-ts.ts", 'const mode: string = "acp";\n'],
+		["parser-tsx.tsx", "const element: JSX.Element = <div />;\nvoid element;\n"],
+		["parser-mts.mts", 'export const mode: string = "acp";\n'],
+		["parser-cts.cts", 'const mode: string = "acp";\n'],
+		["parser-d-ts.d.ts", "declare const mode: string;\n"],
+		["parser-d-mts.d.mts", "export declare const mode: string;\n"],
+		["parser-d-cts.d.cts", "declare const mode: string;\n"],
+		["parser-import-attributes.js", 'import value from "./fixture.json" with { type: "json" };\nvoid value;\n'],
+		["parser-shebang.js", '#!/usr/bin/env bun\nconst mode = "acp";\n'],
+	];
+	for (const [name, contents] of parserFixtures) {
+		await runExactRetiredModeFixture(name, contents, 0, []);
+	}
+	const malformedSource = "const mode: string = ;\n";
+	await runExactRetiredModeFixture("malformed.ts", malformedSource, 2, [], {
+		expectedOutput: `${retiredModeFixturePath("malformed.ts")}:1:21: static retired-mode analysis parse failed`,
+	});
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/test/fixtures/python-text-only.py":
+				'def launch():\n    subprocess.run(["skc", "--mode", "rpc"])\n',
+		},
+		1,
+		undefined,
+		{
+			expectedDiagnostics: [retiredModeDiagnostic("packages/coding-agent/test/fixtures/python-text-only.py", 2)],
+		},
+	);
+	// 128/129 literals joined by binary nodes consume exactly 255/257 expression steps.
+	const expressionUnderSource = `Bun.spawnSync(["--mode", ${staticBinaryExpression("r", "pc", 128)}]);\n`;
+	await runExactRetiredModeFixture("expression-step-under-limit.ts", expressionUnderSource, 1, [
+		retiredModeDiagnostic(retiredModeFixturePath("expression-step-under-limit.ts")),
+	]);
+	const expressionOverSource = `Bun.spawnSync(["--mode", ${staticBinaryExpression("r", "pc", 129)}]);\n`;
+	const expressionOverOffset = expressionOverSource.lastIndexOf('""');
+	await runExactRetiredModeFixture("expression-step-over-limit.ts", expressionOverSource, 2, [], {
+		expectedOutput: staticBudgetDiagnostic(
+			retiredModeFixturePath("expression-step-over-limit.ts"),
+			sourceLocationAt(expressionOverSource, expressionOverOffset),
+			"expression_steps",
+			256,
+			257,
+		),
+	});
+	// a63 through a0 follows 64 bindings and evaluates 65 nodes including the literal initializer.
+	const aliasUnderSource = aliasChainSource(64);
+	await runExactRetiredModeFixture("alias-hop-under-limit.ts", aliasUnderSource, 1, [
+		retiredModeDiagnostic(retiredModeFixturePath("alias-hop-under-limit.ts"), 65),
+	]);
+	const aliasOverSource = aliasChainSource(65);
+	const aliasOverOffset = aliasOverSource.indexOf("a0;", aliasOverSource.indexOf("const a1"));
+	await runExactRetiredModeFixture("alias-hop-over-limit.ts", aliasOverSource, 2, [], {
+		expectedOutput: staticBudgetDiagnostic(
+			retiredModeFixturePath("alias-hop-over-limit.ts"),
+			sourceLocationAt(aliasOverSource, aliasOverOffset),
+			"alias_hops",
+			64,
+			65,
+		),
+	});
+	// Four arrays each consume one --mode literal plus a 255-node safe value: 4 × 256 = 1,024.
+	const fileUnderSource = Array.from(
+		{ length: 4 },
+		() => `["--mode", ${staticBinaryExpression("a", "cp", 128)}];`,
+	).join("\n");
+	await runExactRetiredModeFixture("file-step-under-limit.ts", `${fileUnderSource}\n`, 0, []);
+	const fileOverSource = `${fileUnderSource}\n["--mode", "acp"];\n`;
+	const fileOverOffset = fileOverSource.lastIndexOf('"--mode"');
+	await runExactRetiredModeFixture("file-step-over-limit.ts", fileOverSource, 2, [], {
+		expectedOutput: staticBudgetDiagnostic(
+			retiredModeFixturePath("file-step-over-limit.ts"),
+			sourceLocationAt(fileOverSource, fileOverOffset),
+			"file_steps",
+			1_024,
+			1_025,
+		),
+	});
+	const unrelatedFileBudgetSource = Array.from(
+		{ length: 4 },
+		() => `["unrelated", ${staticBinaryExpression("a", "cp", 128)}];`,
+	).join("\n");
+	await runExactRetiredModeFixture(
+		"unrelated-file-step-control.ts",
+		`${unrelatedFileBudgetSource}\n["--mode", "rpc"];\n`,
+		1,
+		[retiredModeDiagnostic(retiredModeFixturePath("unrelated-file-step-control.ts"), 5)],
+	);
+
+	await runSelfTestFixture(
+		{ "packages/coding-agent/src/modes/bridge-compat/legacy.ts": "export const retired = true;\n" },
+		1,
+		"retired RPC/bridge/unattended ingress source survived",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/test/fixtures/constructed-rpc-option.ts":
+				'const mode = ["r", "pc"].join("");\nconst flags = { options: [mode] };\nvoid flags;\n',
+		},
+		1,
+		"invokes removed --mode rpc",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/consumer.ts":
+				'const legacyIngress = ["./modes", "unattended-compat"].join("/");\nvoid legacyIngress;\n',
+		},
+		1,
+		"invokes removed --mode rpc",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/package.json":
+				'{"exports":{"./commands/skc-runtime-bridge":"./src/bridge.ts","./unattended":"./src/unattended.ts"}}\n',
+		},
+		1,
+		"removed bridge or unattended surface remains externally exported",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/package.json":
+				'{"exports":{"./modes/rpc/*":null,"./commands/skc-runtime-bridge":null,"./unattended":null,"./modes/shared/agent-wire/*":null}}\n',
+		},
+		0,
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/package.json": '{"exports":{"./modes/*":{"import":"./src/modes/*.ts"}}}\n',
+		},
+		1,
+		"retired agent-wire surface remains externally exported",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/package.json":
+				'{"exports":{"./modes/*":{"import":"./src/modes/*.ts"},"./modes/shared/agent-wire/*":null}}\n',
+		},
+		0,
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/package.json": '{"exports":{"./*":"./src/*.ts"}}\n',
+			"packages/coding-agent/src/unattended/legacy.ts": "export const retired = true;\n",
+		},
+		1,
+		"retired ingress source packages/coding-agent/src/unattended/legacy.ts is reachable through broad export",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/package.json": '{"exports":{"./*":"./src/*.ts"}}\n',
+			"packages/coding-agent/src/rpc.ts": "export const retired = true;\n",
+		},
+		1,
+		"retired ingress source packages/coding-agent/src/rpc.ts is reachable through broad export",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/package.json": '{"exports":{"./*":"./src/*.ts"}}\n',
+			"packages/coding-agent/src/bridge.ts": "export const retired = true;\n",
+		},
+		1,
+		"retired ingress source packages/coding-agent/src/bridge.ts is reachable through broad export",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/package.json": '{"exports":{"./*":"./src/*.ts"}}\n',
+			"packages/coding-agent/src/unattended.ts": "export const retired = true;\n",
+		},
+		1,
+		"retired ingress source packages/coding-agent/src/unattended.ts is reachable through broad export",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/package.json": '{"exports":{"./runtime-mcp/*":"./src/runtime-mcp/*.ts"}}\n',
+			"packages/coding-agent/src/runtime-mcp/tool-bridge.ts": "export const neutral = true;\n",
+		},
+		0,
+	);
+	const realManifest = await Bun.file(path.join(repoRoot, packageManifestPath)).text();
+	await runSelfTestFixture({ [packageManifestPath]: realManifest }, 0);
+	await runSelfTestFixture(
+		{
+			"package.json": '{"catalog":{"@sayknow-cli/bridge-client":"0.10.1"}}\n',
+			"packages/bridge-client/package.json": '{"name":"@sayknow-cli/bridge-client"}\n',
+			"packages/bridge-client/src/index.ts": "export class SdkClient {}\nexport type SdkClientOptions = {};\n",
+			"packages/coding-agent/package.json": '{"dependencies":{"@sayknow-cli/bridge-client":"catalog:"}}\n',
+			"packages/coding-agent/src/sdk/client/client.ts":
+				'export { SdkClient } from "@sayknow-cli/bridge-client";\nexport type { SdkClientOptions } from "@sayknow-cli/bridge-client";\n',
+		},
+		0,
+	);
+	await runSelfTestFixture(
+		{
+			"packages/bridge-client/package.json":
+				'{"name":"@sayknow-cli/bridge-client","dependencies":{"unsafe":"1.0.0"}}\n',
+		},
+		1,
+		"canonical bridge-client package must remain runtime-dependency-free",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/bridge-client/src/client.ts": 'import { HostControl } from "./host-control";\nvoid HostControl;\n',
+		},
+		1,
+		"bridge-client imports host or session authority",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/bridge-client/src/client.ts": 'Bun.serve({ fetch() { return new Response("ok"); } });\n',
+		},
+		1,
+		"bridge-client owns forbidden host, session, server, listener, or process authority",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/bridge-client/src/client.ts":
+				'import { AgentSession } from "../../coding-agent/src/session/agent-session";\nvoid AgentSession;\n',
+		},
+		1,
+		"bridge-client import escapes its package",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/bridge-client/src/client.ts":
+				'import { SdkClient } from "@sayknow-cli/coding-agent";\nvoid SdkClient;\n',
+		},
+		1,
+		"bridge-client imports coding-agent or AgentSession authority",
+	);
+	await runSelfTestFixture(
+		{ "packages/renamed-workspace/package.json": '{"name":"@sayknow-cli/bridge-client"}\n' },
+		1,
+		"declares unsupported bridge-client package metadata",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/consumer.ts":
+				'import { BridgeClient } from "@sayknow-cli/bridge-client";\nvoid BridgeClient;\n',
+		},
+		1,
+		"historical BridgeClient surface survived",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/consumer.ts":
+				'import { handshake } from "@sayknow-cli/bridge-client";\nvoid handshake;\n',
+		},
+		1,
+		"imports historical bridge-client protocol surface",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/consumer.ts":
+				'import { commands } from "@sayknow-cli/bridge-client";\nvoid commands;\n',
+		},
+		1,
+		"imports historical bridge-client protocol surface",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/consumer.ts":
+				'import { SdkClient } from "@sayknow-cli/bridge-client/commands";\nvoid SdkClient;\n',
+		},
+		1,
+		"imports unsupported bridge-client subpath",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/consumer.ts": 'import { SSE } from "@sayknow-cli/bridge-client";\nvoid SSE;\n',
+		},
+		1,
+		"imports historical bridge-client protocol surface",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/consumer.ts":
+				'import { control } from "@sayknow-cli/bridge-client";\nvoid control;\n',
+		},
+		1,
+		"imports historical bridge-client protocol surface",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/consumer.ts":
+				'import { legacyUnattended } from "./unattended";\nvoid legacyUnattended;\n',
+		},
+		1,
+		"imports removed unattended surface",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/test/fixtures/neutral-name.ts": 'Bun.spawnSync(["skc", "--mode", "rpc"]);\n',
+		},
+		1,
+		"invokes removed --mode rpc",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/test/fixtures/neutral-expect.ts":
+				'expect(Bun.spawnSync(["skc", "--mode", "rpc"])).toBeDefined();\n',
+		},
+		1,
+		"invokes removed --mode rpc",
+	);
+	await runSelfTestFixture({ "docs/rpc-removal.md": "The RPC compatibility fixture was removed.\n" }, 0);
+	await runSelfTestFixture(
+		{ "scripts/skc-session/prompt.sh": "#!/usr/bin/env bash\n" },
+		1,
+		"retired tmux machine prompt or viewing helper survived",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/unsafe.sh":
+				"#!/usr/bin/env bash\ntmux load-buffer -b prompt -\ntmux capture-pane -p -t session\n",
+		},
+		1,
+		"published shell helper performs tmux machine prompt injection or pane viewing",
+	);
+	const canonicalCreateFixture = `#!/usr/bin/env bash
+[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }
+command = [os.environ["SKC_SESSION_SKC_BIN"]]
+child = subprocess.Popen(command)
+completed = subprocess.run([os.environ["SKC_SESSION_SKC_BIN"], "--internal-tmux-owner-isolation"], input="{}")
+PLAN_RESPONSE="$(printf '%s\\n' "$PLAN_LINE" | "$SKC_BIN" --internal-tmux-owner-isolation)"
+POST_SPAWN_RESPONSE="$(printf '%s\\n' "$PLAN_LINE" | "$SKC_BIN" --internal-tmux-owner-isolation)"
+GENERATION_PUBLISH_RESPONSE="$(printf '%s\\n' "$GENERATION_PUBLISH_REQUEST" | "$SKC_BIN" --internal-tmux-owner-isolation)"
+if verdict="$(printf '%s\\n' "$request" | timeout "1s" "$SKC_SESSION_SKC_BIN" --internal-tmux-owner-isolation)"; then
+  true
+fi
+`;
+	await runSelfTestFixture({ "scripts/skc-session/create.sh": canonicalCreateFixture }, 0);
+	await runSelfTestFixture(
+		{ "scripts/skc-session/create.sh": `${canonicalCreateFixture}\nsubprocess.Popen(["skc"])\n` },
+		1,
+		"must not launch a literal skc executable",
+	);
+	await runSelfTestFixture(
+		{ "scripts/skc-session/create.sh": `${canonicalCreateFixture}\nlauncher="skc"\n"$launcher"\n` },
+		1,
+		"must not alias or wrap the skc executable",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": `${canonicalCreateFixture}\nrunner(){ skc --internal-tmux-owner-isolation; }\nrunner\n`,
+		},
+		1,
+		"must not alias or wrap the skc executable",
+	);
+	await runSelfTestFixture(
+		{ "scripts/skc-session/create.sh": `${canonicalCreateFixture}\n"$SKC_BIN" --internal-tmux-owner-isolation\n` },
+		1,
+		"invokes SKC with a non-lifecycle startup argument",
+	);
+	await runSelfTestFixture(
+		{ "scripts/skc-session/create.sh": `${canonicalCreateFixture}\nSKC_SESSION_FLAGS=unsafe\n` },
+		1,
+		"exposes caller-provided startup arguments",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }',
+				"[[ $# -eq 2 ]] || true",
+			),
+		},
+		1,
+		"must have one fail-closed exact two-operand guard",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }',
+				'set -- rewritten positional arguments\n[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }',
+			),
+		},
+		1,
+		"must not rewrite positional arguments before launch",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }',
+				'shift\n[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }',
+			),
+		},
+		1,
+		"must not rewrite positional arguments before launch",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }',
+				'exit(){ return 0; }\n[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }',
+			),
+		},
+		1,
+		"must not neutralize the exact two-operand guard",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }',
+				'if false; then\n[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }\nfi',
+			),
+		},
+		1,
+		"must have one fail-closed exact two-operand guard",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }',
+				'guard() {\n[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }\n}',
+			),
+		},
+		1,
+		"must have one fail-closed exact two-operand guard",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }',
+				'(\n[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }\n) || true',
+			),
+		},
+		1,
+		"must have one fail-closed exact two-operand guard",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }',
+				'{\n[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }\n} || true',
+			),
+		},
+		1,
+		"must have one fail-closed exact two-operand guard",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }',
+				'true &&\n[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }',
+			),
+		},
+		1,
+		"must have one fail-closed exact two-operand guard",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }',
+				'true && \\\n[[ $# -eq 2 ]] || { echo "Usage: $0 <session-name> <worktree-path>" >&2; exit 2; }',
+			),
+		},
+		1,
+		"must have one fail-closed exact two-operand guard",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				"child = subprocess.Popen(command)",
+				'command.extend(["--file", "task.md"])\nchild = subprocess.Popen(command)',
+			),
+		},
+		1,
+		"must launch exactly SKC_SESSION_SKC_BIN with zero startup arguments",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				"child = subprocess.Popen(command)",
+				'command.append("--file")\nchild = subprocess.Popen(command)',
+			),
+		},
+		1,
+		"must launch exactly SKC_SESSION_SKC_BIN with zero startup arguments",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				"child = subprocess.Popen(command)",
+				'command.insert(1, "--file")\nchild = subprocess.Popen(command)',
+			),
+		},
+		1,
+		"must launch exactly SKC_SESSION_SKC_BIN with zero startup arguments",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				"child = subprocess.Popen(command)",
+				'command += ["--file", "task.md"]\nchild = subprocess.Popen(command)',
+			),
+		},
+		1,
+		"must launch exactly SKC_SESSION_SKC_BIN with zero startup arguments",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				"child = subprocess.Popen(command)",
+				"mutate(command)\nchild = subprocess.Popen(command)",
+			),
+		},
+		1,
+		"must not construct or wrap a non-lifecycle SKC argv",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				"child = subprocess.Popen(command)",
+				'getattr(command, "append")("--file")\nchild = subprocess.Popen(command)',
+			),
+		},
+		1,
+		"must not construct or wrap a non-lifecycle SKC argv",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				"child = subprocess.Popen(command)",
+				'globals()["command"].append("--file")\nchild = subprocess.Popen(command)',
+			),
+		},
+		1,
+		"must not construct or wrap a non-lifecycle SKC argv",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				"child = subprocess.Popen(command)",
+				`vars()[f'{"com"}mand'] = ["skc", "--file"]\nchild = subprocess.Popen(command)`,
+			),
+		},
+		1,
+		"must not construct or wrap a non-lifecycle SKC argv",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				"child = subprocess.Popen(command)",
+				'child = subprocess.Popen(command + ["--file", "task.md"])',
+			),
+		},
+		1,
+		"must invoke SKC only with zero interactive argv or the exact owner-isolation lifecycle argv",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				"child = subprocess.Popen(command)",
+				'launch = command + ["--file", "task.md"]\nchild = subprocess.Popen(launch)',
+			),
+		},
+		1,
+		"must not construct or wrap a non-lifecycle SKC argv",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": `${canonicalCreateFixture}\nlaunch = [os.environ["SKC_SESSION_SKC_BIN"], "--file", "task.md"]\nsubprocess.Popen(launch)\n`,
+		},
+		1,
+		"must not construct or wrap a non-lifecycle SKC argv",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'[os.environ["SKC_SESSION_SKC_BIN"], "--internal-tmux-owner-isolation"]',
+				'[\n  os.environ["SKC_SESSION_SKC_BIN"],\n  "--internal-tmux-owner-isolation",\n  "--file",\n  "task.md",\n]',
+			),
+		},
+		1,
+		"must invoke SKC only with zero interactive argv or the exact owner-isolation lifecycle argv",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'"$SKC_BIN" --internal-tmux-owner-isolation',
+				'captured=$("$SKC_BIN" --file task.md)',
+			),
+		},
+		1,
+		"invokes SKC with a non-lifecycle startup argument",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'"$SKC_BIN" --internal-tmux-owner-isolation',
+				'command "$SKC_BIN" --file task.md',
+			),
+		},
+		1,
+		"invokes SKC with a non-lifecycle startup argument",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'"$SKC_BIN" --internal-tmux-owner-isolation',
+				'exec "$SKC_BIN" --file task.md',
+			),
+		},
+		1,
+		"invokes SKC with a non-lifecycle startup argument",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'"$SKC_BIN" --internal-tmux-owner-isolation',
+				'command -p "$SKC_BIN" --file task.md',
+			),
+		},
+		1,
+		"must not construct or wrap a non-lifecycle SKC argv",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'"$SKC_BIN" --internal-tmux-owner-isolation',
+				'exec -a skc "$SKC_BIN" --file task.md',
+			),
+		},
+		1,
+		"must not construct or wrap a non-lifecycle SKC argv",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'"$SKC_BIN" --internal-tmux-owner-isolation',
+				'LAUNCH=(\n  "$SKC_BIN"\n  --file\n  task.md\n)\n"$' + '{LAUNCH[@]}"',
+			),
+		},
+		1,
+		"must not construct or wrap a non-lifecycle SKC argv",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'"$SKC_BIN" --internal-tmux-owner-isolation',
+				'launcher="$SKC_BIN"\n"$launcher" --file task.md',
+			),
+		},
+		1,
+		"must not construct or wrap a non-lifecycle SKC argv",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'"$SKC_BIN" --internal-tmux-owner-isolation',
+				'"$SKC_BIN" --internal-tmux-owner-isolation \\\n  --file task.md',
+			),
+		},
+		1,
+		"invokes SKC with a non-lifecycle startup argument",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'"$SKC_BIN" --internal-tmux-owner-isolation',
+				'"$SKC_BIN" \\\n  --file task.md',
+			),
+		},
+		1,
+		"invokes SKC with a non-lifecycle startup argument",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'"$SKC_BIN" --internal-tmux-owner-isolation',
+				'"$SKC_BIN" \\\n  session status',
+			),
+		},
+		1,
+		"invokes SKC with a non-lifecycle startup argument",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'"$SKC_BIN" --internal-tmux-owner-isolation',
+				'"$SKC_BIN" \\\n  "write a prompt"',
+			),
+		},
+		1,
+		"invokes SKC with a non-lifecycle startup argument",
+	);
+	await runSelfTestFixture(
+		{
+			"scripts/skc-session/create.sh": canonicalCreateFixture.replace(
+				'"$SKC_BIN" --internal-tmux-owner-isolation',
+				'"$SKC_BIN" --internal-tmux-owner-isolation \\\n  "write a prompt"',
+			),
+		},
+		1,
+		"invokes SKC with a non-lifecycle startup argument",
+	);
+	const realCreate = await Bun.file(path.join(repoRoot, "scripts/skc-session/create.sh")).text();
+	await runSelfTestFixture({ "scripts/skc-session/create.sh": realCreate }, 0);
+	await runSelfTestFixture(
+		{ "scripts/skc-session/watch-output.sh": "#!/usr/bin/env bash\n$TMUX_BIN \\\n  pipe-pane -t session 'sink'\n" },
+		1,
+		"published shell helper performs tmux machine prompt injection or pane viewing",
+	);
+	await runSelfTestFixture(
+		{ "docs/skc-session-clawhip-routing.md": "$TMUX_BIN \\\n  pipe-pane -t owner 'sink'\n" },
+		1,
+		"published machine documentation directs tmux prompt or viewing access",
+	);
+	await runSelfTestFixture(
+		{
+			"docs/skc-session-clawhip-routing.md": './scripts/skc-session/create.sh bot /repo \\\n  --print "task"\n',
+		},
+		1,
+		"published machine documentation directs tmux prompt or viewing access",
+	);
+	await runSelfTestFixture(
+		{ "scripts/skc-session/watch-output.sh": "#!/usr/bin/env bash\ntmux pipe-pane -t session 'sink'\n" },
+		1,
+		"published shell helper performs tmux machine prompt injection or pane viewing",
+	);
+	await runSelfTestFixture(
+		{ "docs/skc-session-clawhip-routing.md": "scripts/skc-session/tail.sh visible output\n" },
+		1,
+		"published machine documentation directs tmux prompt or viewing access",
+	);
+	await runSelfTestFixture(
+		{ "docs/skc-session-clawhip-routing.md": "tmux pipe-pane -t owner 'sink'\n" },
+		1,
+		"published machine documentation directs tmux prompt or viewing access",
+	);
+	await runSelfTestFixture(
+		{ "docs/skc-session-clawhip-routing.md": './scripts/skc-session/create.sh bot /repo --print "task"\n' },
+		1,
+		"published machine documentation directs tmux prompt or viewing access",
+	);
+	await runSelfTestFixture(
+		{
+			"docs/skc-session-clawhip-routing.md": "./scripts/skc-session/create.sh bot /repo\n",
+		},
+		0,
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/unsanctioned.ts": 'Bun.spawnSync(["tmux", "send-keys", "-t", "pane", "prompt"]);\n',
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/skc-runtime/team-runtime.ts":
+				'Bun.spawnSync([config.tmux_command, "send-keys", "-t", paneId, "prompt"]);\n',
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
+	const canonicalTeamRuntimeSendKeysFixture = `
+async function continueStalledSkcTeamWorkers(): Promise<void> {
+	const revalidationReason = null;
+	if (revalidationReason) return;
+function shouldDispatchWorkerWithSendKeys(tmuxCommand: string, platform: NodeJS.Platform = process.platform): boolean {
+	return platform === "win32" || path.basename(tmuxCommand).toLowerCase() === "psmux";
+}
+const useSendKeysFallback = shouldDispatchWorkerWithSendKeys(config.tmux_command);
+const splitArgs = [...(useSendKeysFallback ? [] : [workerCommand]),];
+if (useSendKeysFallback) {
+	Bun.spawnSync([config.tmux_command, "send-keys", "-l", "-t", paneId, workerCommand], {
+		stdout: "ignore",
+		stderr: "ignore",
+	});
+	const sendKeys = Bun.spawnSync([config.tmux_command, "send-keys", "-t", paneId, "Enter"], {
+		stdout: "ignore",
+		stderr: "ignore",
+	});
+	void sendKeys.exitCode;
+}
+const SKC_TEAM_CONTINUATION_PROMPT = "Continue only your current claimed SKC team task. Re-read current SKC team state; do not replay prior output; report status.";
+const SKC_TEAM_CONTINUATION_DISPATCH_TIMEOUT_MS = 5_000;
+const args = Object.freeze([
+	"send-keys",
+	"-l",
+	"-t",
+	worker.pane_id,
+	SKC_TEAM_CONTINUATION_PROMPT,
+	";",
+	"send-keys",
+	"-t",
+	worker.pane_id,
+	"Enter",
+]);
+
+const dispatch = skcTeamRuntimeTestSeams?.continuationTmuxDispatch
+	? skcTeamRuntimeTestSeams.continuationTmuxDispatch(config.tmux_command, args)
+	: Bun.spawnSync([config.tmux_command, ...args], {
+		stdout: "ignore",
+		stderr: "ignore",
+		timeout: SKC_TEAM_CONTINUATION_DISPATCH_TIMEOUT_MS,
+	});
+}
+async function monitorSkcTeam(): Promise<void> {
+	await withSkcTeamTaskMutation(taskStore(dir), async capability => {
+		await continueStalledSkcTeamWorkers();
+		await reconcileSkcTeamStaleClaimsUnlocked(workerOrchestrationRuntime, teamName, dir, config, env, capability);
+	});
+}
+`;
+	await runSelfTestFixture(
+		{ "packages/coding-agent/src/skc-runtime/team-runtime.ts": canonicalTeamRuntimeSendKeysFixture },
+		0,
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/skc-runtime/team-runtime.ts": canonicalTeamRuntimeSendKeysFixture.replace(
+				"async function continueStalledSkcTeamWorkers(): Promise<void>",
+				"async function relocatedContinuation(): Promise<void>",
+			),
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/skc-runtime/team-runtime.ts": canonicalTeamRuntimeSendKeysFixture.replace(
+				"if (revalidationReason) return;",
+				"if (revalidationReason) {}",
+			),
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/skc-runtime/team-runtime.ts": canonicalTeamRuntimeSendKeysFixture.replace(
+				"await continueStalledSkcTeamWorkers();",
+				"",
+			),
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/skc-runtime/team-runtime.ts": canonicalTeamRuntimeSendKeysFixture.replace(
+				"await continueStalledSkcTeamWorkers();\n\t\tawait reconcileSkcTeamStaleClaimsUnlocked(workerOrchestrationRuntime, teamName, dir, config, env, capability);",
+				"await reconcileSkcTeamStaleClaimsUnlocked(workerOrchestrationRuntime, teamName, dir, config, env, capability);\n\t\tawait continueStalledSkcTeamWorkers();",
+			),
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/skc-runtime/team-runtime.ts": canonicalTeamRuntimeSendKeysFixture.replace(
+				"const dispatch =",
+				'args.push("forged");\nconst dispatch =',
+			),
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/skc-runtime/team-runtime.ts": canonicalTeamRuntimeSendKeysFixture.replace(
+				"report status.",
+				"report injected status.",
+			),
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/skc-runtime/team-runtime.ts": canonicalTeamRuntimeSendKeysFixture.replace(
+				'return platform === "win32" || path.basename(tmuxCommand).toLowerCase() === "psmux";',
+				"return true;",
+			),
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/skc-runtime/team-runtime.ts": canonicalTeamRuntimeSendKeysFixture.replace(
+				'return platform === "win32" || path.basename(tmuxCommand).toLowerCase() === "psmux";',
+				'return platform === "win32" || path.basename(tmuxCommand).toLowerCase() === "psmux" || tmuxCommand === "tmux";',
+			),
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/skc-runtime/team-runtime.ts": `${canonicalTeamRuntimeSendKeysFixture}\nBun.spawnSync([config.tmux_command, "send-keys", "-t", paneId, "prompt"]);\n`,
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/skc-runtime/team-runtime.ts": canonicalTeamRuntimeSendKeysFixture.replaceAll(
+				"worker.pane_id",
+				'"%99"',
+			),
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/skc-runtime/team-runtime.ts": canonicalTeamRuntimeSendKeysFixture.replace(
+				'SKC_TEAM_CONTINUATION_PROMPT,\n\t";",',
+				"`$" + "{SKC_TEAM_CONTINUATION_PROMPT}" + '`,\n\t";",',
+			),
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/skc-runtime/team-runtime.ts": canonicalTeamRuntimeSendKeysFixture.replace(
+				'"send-keys",\n\t"-l",\n\t"-t",\n\tworker.pane_id,\n\tSKC_TEAM_CONTINUATION_PROMPT,\n\t";",\n\t"send-keys",\n\t"-t",\n\tworker.pane_id,\n\t"Enter",',
+				'"send-keys", "-t", worker.pane_id, "Enter", ";", "send-keys", "-l", "-t", worker.pane_id, SKC_TEAM_CONTINUATION_PROMPT,',
+			),
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/skc-runtime/team-runtime.ts": canonicalTeamRuntimeSendKeysFixture.replace(
+				"Bun.spawnSync([config.tmux_command, ...args]",
+				'Bun.spawnSync([config.tmux_command, "run-shell", ...args]',
+			),
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/coordinator-mcp/server.ts":
+				'import { SdkClient } from "../sdk/client/client";\nBun.spawnSync(["tmux", "paste-buffer", "-t", "pane"]);\nvoid SdkClient;\n',
+			"packages/coding-agent/src/sdk/client/client.ts": "export class SdkClient {}\n",
+		},
+		1,
+		"tmux paste-buffer content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/coordinator-mcp/server.ts":
+				'import { SdkClient } from "../sdk/client/client";\nBun.spawnSync(["tmux", "set-buffer", "prompt"]);\nvoid SdkClient;\n',
+			"packages/coding-agent/src/sdk/client/client.ts": "export class SdkClient {}\n",
+		},
+		1,
+		"tmux set-buffer content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/coordinator-mcp/server.ts":
+				'import { SdkClient } from "../sdk/client/client";\nBun.spawnSync(["tmux", "capture-pane", "-p"]);\nvoid SdkClient;\n',
+			"packages/coding-agent/src/sdk/client/client.ts": "export class SdkClient {}\n",
+		},
+		1,
+		"coordinator MCP reads tmux pane content outside SDK queries",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/unsanctioned-pane.ts": 'Bun.spawnSync(["tmux", "capture-pane", "-p"]);\n',
+		},
+		1,
+		"tmux capture-pane pane access is outside sanctioned test fixtures",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/unsanctioned-pane.ts": 'Bun.spawnSync("$TMUX_BIN capture-pane -p -t pane");\n',
+		},
+		1,
+		"tmux capture-pane pane access is outside sanctioned test fixtures",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/unsanctioned-pane.ts":
+				'const paneViewer = ["capture", "pane"].join("-");\nBun.spawnSync(["tmux", paneViewer, "-p"]);\n',
+		},
+		1,
+		"tmux capture-pane pane access is outside sanctioned test fixtures",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/unsanctioned-pane.js":
+				'const paneViewer = ["pipe", "pane"].join("-");\nBun.spawnSync(["tmux", paneViewer, "sink"]);\n',
+		},
+		1,
+		"tmux pipe-pane pane access is outside sanctioned test fixtures",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/unsanctioned-pane.js": 'Bun.spawnSync(["tmux", "pipe-pane", "sink"]);\n',
+		},
+		1,
+		"tmux pipe-pane pane access is outside sanctioned test fixtures",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/unsanctioned-pane.ts":
+				"const paneAction = `capture-$" +
+				'{"pane"}`;\nconst executable = ["tm", "ux"].join("");\nconst argv = [executable, paneAction, "-p"];\nconst invoke = Bun.spawnSync;\ninvoke(argv);\n',
+		},
+		1,
+		"tmux capture-pane pane access is outside sanctioned test fixtures",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/unsanctioned-pane.ts":
+				'const paneAction = "pipe" + "-pane";\nfunction runTmux(argv: string[]) { return Bun.spawnSync(["tmux", ...argv]); }\nrunTmux([paneAction, "sink"]);\n',
+		},
+		1,
+		"tmux pipe-pane pane access is outside sanctioned test fixtures",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/unsanctioned-input.ts":
+				'const executable = ["tm", "ux"].join("");\nconst primitive = ["send", "keys"].join("-");\nconst argv = [executable, primitive, "-t", "pane", "prompt"];\nconst invoke = Bun.spawnSync;\ninvoke(argv);\n',
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/unsanctioned-input.ts":
+				'const primitive = "paste" + "-buffer";\nfunction runTmux(argv: string[]) { return Bun.spawnSync(["tmux", ...argv]); }\nrunTmux([primitive, "-t", "pane"]);\n',
+		},
+		1,
+		"tmux paste-buffer content injection is outside sanctioned process lifecycle",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/test/fixtures/sanctioned-tmux-pane.ts":
+				'Bun.spawnSync(["tmux", "capture-pane", "-p"]);\nBun.spawnSync(["tmux", "pipe-pane", "sink"]);\n',
+		},
+		0,
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/coordinator-mcp/server.ts":
+				'import { SdkClient } from "../sdk/client/client";\nimport { AgentSession } from "../session/agent-session";\nconst session = {} as AgentSession;\nsession.prompt("bypass");\nvoid SdkClient;\n',
+			"packages/coding-agent/src/sdk/client/client.ts": "export class SdkClient {}\n",
+			"packages/coding-agent/src/session/agent-session.ts": "export class AgentSession {}\n",
+		},
+		1,
+		"coordinator MCP directly mutates AgentSession or control internals",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/coordinator-mcp/server.ts":
+				'import { SdkClient } from "../sdk/client/client";\nimport { control } from "../sdk/host/control";\ncontrol({ operation: "turn.prompt" });\nvoid SdkClient;\n',
+			"packages/coding-agent/src/sdk/client/client.ts": "export class SdkClient {}\n",
+			"packages/coding-agent/src/sdk/host/control.ts": "export function control(): void {}\n",
+		},
+		1,
+		"coordinator MCP directly mutates AgentSession or control internals",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/coordinator-mcp/server.ts":
+				'import { SdkClient } from "../sdk/client/client";\nasync function writeSessionState() { await fs.writeFile("metadata.json", "{}\\n"); }\nvoid SdkClient;\n',
+			"packages/coding-agent/src/sdk/client/client.ts": "export class SdkClient {}\n",
+		},
+		0,
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/coordinator-mcp/server.ts": "export const server = true;\n",
+			"packages/coding-agent/src/sdk/client/client.ts": "export class SdkClient {}\n",
+		},
+		1,
+		"coordinator MCP does not reach the canonical SDK client through its import graph",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/coordinator-mcp/server.ts":
+				'import { SdkClient } from "../sdk/client/client";\nexport async function startProcessLifecycle() { Bun.spawn(["tmux", "new-session", "-d"]); return SdkClient; }\n',
+			"packages/coding-agent/src/sdk/client/client.ts": "export class SdkClient {}\n",
+		},
+		0,
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/bridge-env.ts":
+				"const endpoint = process.env.SKC_BRIDGE_ENDPOINT;\nvoid endpoint;\n",
+		},
+		1,
+		"forbidden bridge environment reference SKC_BRIDGE_ENDPOINT",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/cli.ts":
+				'const flags = { mode: Flags.string({ options: ["interactive", "rpc"] }) };\nvoid flags;\n',
+		},
+		1,
+		"--mode option retains rpc, rpc-ui, or bridge",
+	);
+	await runSelfTestFixture(
+		{ "python/skc-rpc/src/skc_rpc/client.py": "class RpcClient: pass\n" },
+		1,
+		"retired Python skc-rpc package source survived",
+	);
+	await runSelfTestFixture(
+		{ "python/roboskc/src/controller.py": "from skc_rpc import RpcClient\n" },
+		1,
+		"imports removed skc_rpc Python client",
+	);
+	await runSelfTestFixture(
+		{ "scripts/legacy-controller.py": 'subprocess.run(["skc", "--mode", "rpc"])\n' },
+		1,
+		"invokes removed --mode rpc",
+	);
+	await runSelfTestFixture(
+		{ "python/roboskc/pyproject.toml": '[project]\ndependencies = ["skc-rpc>=0.1.0"]\n' },
+		1,
+		"declares removed skc-rpc distribution metadata",
+	);
+	await runSelfTestFixture(
+		{ "python/roboskc/src/controller.py": 'client.negotiate_unattended(actor="legacy")\n' },
+		1,
+		"uses removed Python unattended protocol client negotiate_unattended",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/test/sdk-downgrade-rollback.test.ts":
+				'const legacy = "skc --mode rpc";\nvoid legacy;\n',
+		},
+		0,
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/test/sdk-removed-ingresses.test.ts":
+				'const rejected = ["--mode", "rpc"];\nvoid rejected;\n',
+		},
+		0,
+	);
+	await runSelfTestFixture({ "docs/sdk-migration.md": "`--mode rpc` has been removed; use the SDK instead.\n" }, 0);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/internal-urls/docs-index.generated.ts":
+				'export const docs = "--mode rpc has been removed";\n',
+		},
+		0,
+	);
+	await runSelfTestFixture({ "artifacts/closure-report.json": '{"legacy":"skc --mode rpc"}\n' }, 0);
+	await runSelfTestFixture(
+		{ "packages/coding-agent/src/consumer.ts": 'import { legacyRpc } from "./modes/rpc/legacy";\nvoid legacyRpc;\n' },
+		1,
+		"imports removed modes/rpc or modes/bridge",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/unsanctioned-listener.ts":
+				'import { AgentSession } from "./agent-session";\nBun.serve({ fetch() { return new Response("ok"); } });\nvoid AgentSession;\n',
+		},
+		1,
+		"listener imports AgentSession or dispatch internals outside a sanctioned host",
+	);
+	await runSelfTestFixture(
+		{ "packages/coding-agent/src/modes/rpc/zombie.ts": "export const zombie = true;\n" },
+		1,
+		"retired RPC/bridge/unattended ingress source survived",
+	);
+	await runSelfTestFixture(
+		{ "packages/coding-agent/src/modes/unattended/zombie.ts": "export const zombie = true;\n" },
+		1,
+		"retired RPC/bridge/unattended ingress source survived",
+	);
+	await runSelfTestFixture(
+		{ "packages/coding-agent/src/bridge/zombie.ts": "export const zombie = true;\n" },
+		1,
+		"retired RPC/bridge/unattended ingress source survived",
+	);
+	await runSelfTestFixture(
+		{ "packages/coding-agent/src/unattended/zombie.ts": "export const zombie = true;\n" },
+		1,
+		"retired RPC/bridge/unattended ingress source survived",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/modes/acp/acp-agent.ts":
+				'import { AgentSession } from "../../core/agent-session";\nconst record = {} as { session: AgentSession };\nrecord.session.prompt("bypass");\n',
+		},
+		1,
+		"shipped ACP entrypoint does not import the SDK ACP adapter",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/commands/mcp-serve.ts":
+				'import { runCoordinatorMcpServer } from "../coordinator-mcp/server";\nvoid runCoordinatorMcpServer;\n',
+		},
+		1,
+		"shipped MCP command does not dispatch the SDK MCP server",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/modes/acp/acp-agent.ts":
+				'import { AcpSdkAdapter } from "../../sdk/acp";\nimport "./harmless-wrapper";\nvoid AcpSdkAdapter;\n',
+			"packages/coding-agent/src/modes/acp/harmless-wrapper.ts":
+				'import { AgentSession } from "../../session/agent-session";\nvoid AgentSession;\n',
+			"packages/coding-agent/src/session/agent-session.ts": "export class AgentSession {}\n",
+		},
+		1,
+		"ACP machine entrypoint reaches forbidden AgentSession",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/commands/mcp-serve.ts":
+				'import { runSdkMcpStdio } from "../sdk/mcp/server";\nimport "../harmless-wrapper";\nvoid runSdkMcpStdio;\n',
+			"packages/coding-agent/src/harmless-wrapper.ts":
+				'import { ClientBridge } from "./session/client-bridge";\nvoid ClientBridge;\n',
+			"packages/coding-agent/src/session/client-bridge.ts": "export class ClientBridge {}\n",
+		},
+		1,
+		"MCP machine entrypoint reaches forbidden direct client bridge",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/commands/mcp-serve.ts":
+				'import { runSdkMcpStdio } from "../sdk/mcp/server.js";\nimport "../wrapper.js";\nvoid runSdkMcpStdio;\n',
+			"packages/coding-agent/src/wrapper.ts":
+				'import { ClientBridge } from "./session/client-bridge.js";\nvoid ClientBridge;\n',
+			"packages/coding-agent/src/session/client-bridge.ts": "export class ClientBridge {}\n",
+		},
+		1,
+		"MCP machine entrypoint reaches forbidden direct client bridge",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/modes/acp/acp-agent.ts":
+				'import { AcpSdkAdapter } from "../../sdk/acp";\nimport "./adapter-wrapper";\nvoid AcpSdkAdapter;\n',
+			"packages/coding-agent/src/modes/acp/adapter-wrapper.ts":
+				'import { SdkClient } from "../../sdk/client";\nvoid SdkClient;\n',
+			"packages/coding-agent/src/sdk/client.ts": "export class SdkClient {}\n",
+		},
+		0,
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/commands/acp.ts":
+				'import { AgentSession } from "../session/agent-session";\nvoid AgentSession;\n',
+		},
+		1,
+		"ACP command wrapper bypasses SDK/ACP/Coordinator through direct session, RPC, or tmux routing",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/commands/daemon.ts": 'Bun.spawn(["tmux", "new-session", "-d"]);\n',
+		},
+		1,
+		"daemon command wrapper bypasses SDK/ACP/Coordinator through direct session, RPC, or tmux routing",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/commands/mcp-serve.ts": 'import { RpcClient } from "../rpc";\nvoid RpcClient;\n',
+		},
+		1,
+		"MCP command wrapper bypasses SDK/ACP/Coordinator through direct session, RPC, or tmux routing",
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/main.ts":
+				'const mode = "acp";\nif (mode === "acp") {\n const session = new AgentSession();\n session.prompt("bypass");\n} else {\n void 0;\n}\n',
+		},
+		1,
+		"root --mode acp bypasses SDK ACP through direct session, RPC, or tmux routing",
+	);
+}
+
+if (process.argv.includes("--self-test")) await selfTest();
+try {
+	const violations = await scan();
+	if (violations.length > 0) {
+		process.stderr.write(`SKC SDK canonicalization violations found:\n${violations.join("\n")}\n`);
+		process.exit(1);
+	}
+	process.stdout.write(
+		`SKC SDK canonicalization verification passed (${sanctionedServerHosts.size} sanctioned server hosts).\n`,
+	);
+} catch (error) {
+	process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+	process.exit(2);
+}