@cometchat/skills 4.4.1 → 5.0.0

package/test-suite/scripts/typecheck-fences-kotlin.mjs

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+/**
+ * typecheck-fences-kotlin.mjs — Tier-2 compile gate for NATIVE (Kotlin/Android) skill
+ * families: compile the skills' Kotlin code fences against the REAL pinned UI Kit +
+ * Chat SDK, catching signature/import drift that the Tier-1 name-only catalog can't
+ * see (a wrong arg count, a member that moved, a symbol that exists but isn't public).
+ *
+ * The Kotlin sibling of typecheck-fences.mjs (which does the same for TS/React). Same
+ * contract: extract import-bearing fences → stage them into a project that has the kit
+ * installed → compile → report ONLY kit-API errors.
+ *
+ * Strategy: extract every ```kotlin fence that imports `com.cometchat.…` (real recipe
+ * blocks, not prose fragments), wrap each in its own package/file inside the Gradle
+ * probe project, run `:fences:compileDebugKotlin`, and classify the diagnostics:
+ *   • KIT-API errors  → the fence references a CometChat symbol/signature that does not
+ *                       exist as written. This FAILS the gate (exit 1).
+ *   • FRAGMENT noise  → unresolved placeholder identifiers the recipes legitimately use
+ *                       (`uid`, `binding`, `R`, a screen the reader supplies). Fences that
+ *                       only produce these are stripped and counted, like the TS gate's
+ *                       non-parseable-fragment pass.
+ *
+ * Usage:
+ *   node test-suite/scripts/typecheck-fences-kotlin.mjs \
+ *     --project test-suite/typecheck/android-v6 --discover android-v6 [--keep]
+ * Exit: 0 no kit-API errors · 1 kit-API drift · 2 BLOCKED(setup) — toolchain/SDK/kit
+ *       unavailable (honest, never fake-green).
+ */
+import { readFileSync, writeFileSync, mkdirSync, rmSync, existsSync, readdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const args = process.argv.slice(2);
+const opt = (name, def) => { const i = args.indexOf(`--${name}`); return i >= 0 ? args[i + 1] : def; };
+const KEEP = args.includes("--keep");
+
+// ── derive family metadata from families.json (RULES.md §22) ─────────────────
+const FAMILIES_PATH = join(ROOT, ".claude/skills/cometchat-skill-reviewer/tools/families.json");
+const { families: FAM_DATA, default: DEFAULT_FAMILY } = JSON.parse(readFileSync(FAMILIES_PATH, "utf8"));
+
+const PROJECT = opt("project", null);
+const DISCOVER = opt("discover", DEFAULT_FAMILY);
+const projectAbs = PROJECT ? join(ROOT, PROJECT) : null;
+
+// ── families: skill-dir globs derived from families.json ─────────────────────
+// --discover accepts a catalog-basename prefix (e.g. the part before "-v<N>").
+// All non-parked, non-template families whose platform matches contribute their
+// reviewsSkills globs — so adding a new Android family requires no edit here.
+const discoverPlatform = DISCOVER.replace(/-v\d+$/, "");
+const discoverGlobs = Object.values(FAM_DATA)
+  .filter((f) => f.platform === discoverPlatform && !f.parked && !/^template/i.test(f._status || ""))
+  .flatMap((f) => (f.reviewsSkills || []).map((p) =>
+    p.endsWith("-") ? new RegExp("^" + p) : new RegExp("^" + p + "$")));
+
+// ── BLOCKED(setup) preflight — fail honestly, with the fix ───────────────────
+function blocked(msg, fix) {
+  console.error(`\n⛔ BLOCKED(setup): ${msg}`);
+  if (fix) console.error(`   → ${fix}`);
+  console.error(`   The gate did NOT run — this is not a pass.`);
+  process.exit(2);
+}
+if (!projectAbs) blocked(`--project is required`, `pass --project test-suite/typecheck/<family>`);
+if (!existsSync(projectAbs)) blocked(`probe project not found: ${PROJECT}`);
+const gradlew = join(projectAbs, "gradlew");
+if (!existsSync(gradlew)) blocked(`no Gradle wrapper in ${PROJECT}`, `copy gradle/wrapper + gradlew from an Android project`);
+const localProps = join(projectAbs, "local.properties");
+if (!existsSync(localProps) || !/sdk\.dir=/.test(readFileSync(localProps, "utf8"))) {
+  blocked(`Android SDK location unknown (${PROJECT}/local.properties has no sdk.dir)`,
+    `write sdk.dir=/path/to/Android/sdk into ${PROJECT}/local.properties (git-ignored)`);
+}
+
+// ── discover skill files whose fences import the kit ─────────────────────────
+const globs = discoverGlobs;
+if (!globs.length) blocked(`unknown --discover platform "${DISCOVER}" — no matching families found in families.json`);
+const NEEDLE = "import com.cometchat.";
+const files = [];
+const collect = (dir) => {
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    const p = join(dir, e.name);
+    if (e.isDirectory()) collect(p);
+    else if (e.name.endsWith(".md") && readFileSync(p, "utf8").includes(NEEDLE)) files.push(p);
+  }
+};
+const skillsRoot = join(ROOT, "skills");
+for (const d of readdirSync(skillsRoot, { withFileTypes: true })) {
+  if (d.isDirectory() && globs.some((g) => g.test(d.name))) collect(join(skillsRoot, d.name));
+}
+
+// ── extract + stage fences ───────────────────────────────────────────────────
+const FENCE_RE = /```kotlin[^\n]*\n([\s\S]*?)```/g;
+// Placeholders the recipes legitimately reference without defining. Provided as
+// function parameters so the fence body compiles; anything ELSE unresolved is real.
+const PLACEHOLDERS = [
+  ["context", "android.content.Context"],
+  ["uid", "String"],
+  ["authToken", "String"],
+  ["user", "com.cometchat.chat.models.User"],
+  ["group", "com.cometchat.chat.models.Group"],
+  ["message", "com.cometchat.chat.models.BaseMessage"],
+  ["conversation", "com.cometchat.chat.models.Conversation"],
+  ["lifecycleScope", "kotlinx.coroutines.CoroutineScope"],
+];
+
+function extractFences(file) {
+  const src = readFileSync(file, "utf8");
+  const out = [];
+  let m, idx = 0;
+  while ((m = FENCE_RE.exec(src))) {
+    const body = m[1];
+    if (!body.includes(NEEDLE)) continue;               // real recipe, not a fragment
+    if (/gate-skip/.test(body)) continue;               // explicitly excluded
+    out.push({ idx: idx++, body });
+  }
+  return out;
+}
+
+const FENCE_DIR = join(projectAbs, "fences", "src", "main", "kotlin", "__fences__");
+rmSync(FENCE_DIR, { recursive: true, force: true });
+mkdirSync(FENCE_DIR, { recursive: true });
+
+const manifest = [];
+let n = 0;
+for (const file of files) {
+  const rel = file.replace(ROOT + "/", "");
+  for (const f of extractFences(file)) {
+    const id = `f${n++}`;
+    const lines = f.body.split("\n");
+    const imports = lines.filter((l) => /^\s*import\s+/.test(l)).map((l) => l.trim());
+    const rest = lines.filter((l) => !/^\s*import\s+/.test(l) && !/^\s*package\s+/.test(l)).join("\n");
+    // How to stage the body so it compiles in the SAME context the recipe assumes —
+    // otherwise the compiler reports context errors (Compose/coroutine) that look like
+    // kit drift but are staging artifacts:
+    //   • declares a class/object/interface or an annotated (@Composable) function → it is
+    //     already top-level Kotlin; emit as-is.
+    //   • calls Compose APIs (Modifier/remember/Scaffold/a composable kit call) → wrap in a
+    //     @Composable function (composable invocations are only legal from one).
+    //   • otherwise → wrap in a suspend function (covers `collect`/`await` style snippets)
+    //     that supplies the placeholder identifiers the recipe assumes.
+    const declaresTopLevel = /^\s*(?:@[A-Za-z]|(?:private |internal |public |abstract |sealed |open |data )*(?:class|object|interface)\s)/m.test(rest);
+    const usesCompose = /\bModifier\b|\bremember\b|\bScaffold\b|\bLaunchedEffect\b|\bComposable\b|\bColumn\(|\bBox\(|CometChatTheme\(/.test(rest);
+    const used = PLACEHOLDERS.filter(([nme]) => new RegExp(`\\b${nme}\\b`).test(rest));
+    const params = used.map(([nme, type]) => `${nme}: ${type}`).join(", ");
+    // Non-Compose recipes are written from inside an Activity (`init(this, …)`), so stage
+    // them as an Activity EXTENSION function — otherwise `this` doesn't resolve and the
+    // compiler reports a context error that looks like drift.
+    const wrapper = usesCompose
+      ? [`@androidx.compose.runtime.Composable`, `private fun fence(${params}) {`]
+      : [`private suspend fun androidx.activity.ComponentActivity.fence(${params}) {`];
+    const src = [
+      `@file:Suppress("unused", "UNUSED_VARIABLE", "UNUSED_PARAMETER", "UNUSED_EXPRESSION")`,
+      `package __fences__.${id}`,
+      ``,
+      ...imports,
+      ``,
+      `// @fence ${rel} #${f.idx}`,
+      declaresTopLevel ? rest : [...wrapper, rest, `}`].join("\n"),
+      ``,
+    ].join("\n");
+    writeFileSync(join(FENCE_DIR, `${id}.kt`), src);
+    manifest.push({ id, file: rel, idx: f.idx });
+  }
+}
+console.log(`Extracted ${manifest.length} import-bearing kotlin fence(s) from ${files.length} skill file(s) into ${PROJECT}/fences/src/main/kotlin/__fences__`);
+if (!manifest.length) { console.log("nothing to compile."); process.exit(0); }
+
+// ── compile ──────────────────────────────────────────────────────────────────
+// Kotlin 2.x diagnostic line shape (VERIFIED against the real compiler output, not
+// assumed — the message text follows the position directly, with NO literal "error:"):
+//   e: file:///abs/path/__fences__/f3.kt:9:1 Syntax error: Expecting a top level declaration.
+//   e: file:///abs/path/__fences__/f7.kt:12:5 Unresolved reference: foo
+const DIAG_RE = /^e:\s+\S*__fences__\/(f\d+)\.kt:(\d+):(\d+)\s+(.*)$/;
+function runGradle() {
+  try {
+    execFileSync(gradlew, [":fences:compileDebugKotlin", "--console=plain", "-q"],
+      { cwd: projectAbs, stdio: ["ignore", "pipe", "pipe"], timeout: 15 * 60 * 1000 });
+    return { ok: true, out: "" };
+  } catch (e) {
+    const out = `${e.stdout || ""}${e.stderr || ""}`;
+    if (/Could not (resolve|find)\s+com\.cometchat/i.test(out))
+      blocked("the pinned CometChat kit could not be resolved from Cloudsmith",
+        "check network access to dl.cloudsmith.io and the pinned version in fences/build.gradle.kts");
+    if (/SDK location not found|Failed to install the following Android SDK|No version of NDK/i.test(out))
+      blocked("Android SDK/toolchain incomplete", "install the required compileSdk platform via Android Studio / sdkmanager");
+    if (/Unsupported class file major version|Could not determine java version|JAVA_HOME/i.test(out))
+      blocked("JDK mismatch for AGP", "use JDK 17+ (AGP 8.x); set JAVA_HOME accordingly");
+    return { ok: false, out };
+  }
+}
+
+const diagsByFence = (text) => {
+  const per = new Map();
+  for (const line of text.split("\n")) {
+    const m = line.trim().match(DIAG_RE);
+    if (!m) continue;
+    const [, id, ln, , msg] = m;
+    if (!per.has(id)) per.set(id, []);
+    per.get(id).push({ line: ln, msg });
+  }
+  return per;
+};
+// A diagnostic is KIT-API drift only when it implicates a CometChat symbol. Kotlin
+// reports an unresolved kit symbol as "Unresolved reference: CometChatFoo" and a bad
+// signature as "None of the following candidates is applicable…" / argument errors on
+// a line that names the symbol — so match the message OR the staged source line.
+const fenceSrc = (id) => { try { return readFileSync(join(FENCE_DIR, `${id}.kt`), "utf8").split("\n"); } catch { return []; } };
+const isKitDiag = (id, d) => {
+  const srcLine = fenceSrc(id)[Number(d.line) - 1] || "";
+  const unresolved = d.msg.match(/Unresolved reference:?\s*'?([A-Za-z_][\w]*)'?/i);
+  if (unresolved) {
+    const sym = unresolved[1];
+    if (/^CometChat/.test(sym)) return true;                       // a kit type that doesn't exist
+    // A MEMBER access on a kit receiver that doesn't resolve IS drift
+    // (`CometChatUIKit.totallyBogusMethod(…)`, `CometChatEvents.nonexistentProperty`).
+    // A BARE identifier is a placeholder the recipe expects the reader to supply.
+    const isMemberOfKit = new RegExp(`CometChat[\\w.]*\\s*\\.\\s*${sym}\\b`).test(srcLine) ||
+      new RegExp(`\\.\\s*${sym}\\b`).test(srcLine) && /CometChat/.test(srcLine);
+    return isMemberOfKit;
+  }
+  // Everything else counts as drift when it implicates the kit — by message, or by the
+  // staged source line (argument/overload errors name the callee on that line).
+  return /CometChat|com\.cometchat/i.test(d.msg) || /CometChat/i.test(srcLine);
+};
+
+let { ok, out } = runGradle();
+const stripped = new Set();
+// Fragment pass (the Kotlin analogue of the TS gate's non-parseable pass): a fence whose
+// errors are ALL non-kit — a syntax error from an illustrative snippet, or an unresolved
+// placeholder the reader supplies — is a fragment, not drift. Drop it and recompile so it
+// cannot mask real errors in the OTHER fences (a syntax error aborts the whole module).
+for (let pass = 0; !ok && pass < 6; pass++) {
+  const per = diagsByFence(out);
+  if (!per.size) break;
+  const dropping = [...per.entries()].filter(([id, ds]) => ds.every((d) => !isKitDiag(id, d)));
+  if (!dropping.length) break;
+  for (const [id] of dropping) { rmSync(join(FENCE_DIR, `${id}.kt`), { force: true }); stripped.add(id); }
+  ({ ok, out } = runGradle());
+}
+
+// ── classify what remains ────────────────────────────────────────────────────
+const kitErrors = [];
+if (!ok) {
+  for (const [id, ds] of diagsByFence(out)) {
+    for (const d of ds) {
+      if (!isKitDiag(id, d)) continue;
+      const src = manifest.find((x) => x.id === id);
+      kitErrors.push({ id, where: src ? `${src.file} #${src.idx}` : id, line: d.line, msg: d.msg });
+    }
+  }
+  // Compile failed but nothing was attributable to a fence: a project/toolchain problem,
+  // NOT a green result. Fail as BLOCKED(setup) rather than silently passing.
+  if (!kitErrors.length && !diagsByFence(out).size) {
+    console.error(out.split("\n").filter((l) => /error|FAILURE|Caused by/i.test(l)).slice(0, 12).join("\n"));
+    blocked("the probe project failed to compile for a non-fence reason",
+      `run: (cd ${PROJECT} && ./gradlew :fences:compileDebugKotlin) and fix the project`);
+  }
+}
+
+if (!KEEP) rmSync(FENCE_DIR, { recursive: true, force: true });
+const checked = manifest.length - stripped.size;
+const note = stripped.size ? ` (${stripped.size} illustrative fragment fence(s) skipped)` : "";
+
+if (ok || kitErrors.length === 0) {
+  console.log(`\n✅ Tier-2 (kotlin): no kit-API errors across ${checked} compiled fence(s)${note}.`);
+  process.exit(0);
+}
+console.log(`\n❌ ${kitErrors.length} kit-API error(s) — real signature/import drift vs the pinned kit:`);
+for (const e of kitErrors) console.log(`  [${e.where}] line ${e.line}: ${e.msg}`);
+process.exit(1);

package/test-suite/scripts/typecheck-fences.mjs

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+/**
+ * typecheck-fences.mjs — Tier-2 compile gate: type-check the skills' code fences
+ * against the REAL pinned kit (catches method/signature/importability drift that
+ * the Tier-1 name-only catalog can't see — a wrong arg count, a member that moved,
+ * a symbol that exists but isn't barrel-exported).
+ *
+ * Ported from the legacy pack's battle-tested engine, adapted for the v5 layout:
+ *   • scans SKILL.md AND references/*.md for each react-v7 skill (v5 puts real code
+ *     in references/), where legacy only scanned SKILL.md;
+ *   • --discover web-v7 routes fences by the kit they import.
+ *
+ * Strategy: extract every ```ts/```tsx fence that imports from "@cometchat/…"
+ * (real recipe blocks, not prose fragments), drop each into a throwaway dir inside
+ * a project that has the kit installed, run `tsc --noEmit`, report only KIT-API
+ * errors. Placeholder identifiers the recipes use (selectedUser, myHandler, …)
+ * surface as TS2304/implicit-any — expected fragment noise, filtered out. What
+ * remains is real API drift:
+ *   TS2305/2307/2724 (no exported member / cannot find module)
+ *   TS2339/2551       (property does not exist on type)
+ *   TS2345/2554/2769  (argument type / arg count / overload mismatch)
+ *   TS2353            (unknown property in object literal)
+ *
+ * Usage:
+ *   node test-suite/scripts/typecheck-fences.mjs \
+ *     --project test-suite/typecheck/web-v7 --tsconfig tsconfig.json --discover web-v7
+ * The --project dir must have the kit installed (CI: `npm ci` it first).
+ * Exit: 0 no kit-API errors · 1 kit-API drift · 2 bad invocation / project not installed.
+ */
+import { readFileSync, writeFileSync, mkdirSync, rmSync, existsSync, readdirSync } from "node:fs";
+import { join, basename, dirname } from "node:path";
+import { execSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(HERE, "..", "..");
+const args = process.argv.slice(2);
+const opt = (name, def) => { const i = args.indexOf(`--${name}`); return i >= 0 ? args[i + 1] : def; };
+
+const PROJECT = opt("project");
+const TSCONFIG = opt("tsconfig", "tsconfig.json");
+const DISCOVER = opt("discover"); // web-v7
+
+if (!PROJECT) { console.error("ERROR: --project <kit-installed-dir> is required"); process.exit(2); }
+const projectAbs = join(ROOT, PROJECT);
+if (!existsSync(join(projectAbs, "node_modules", "@cometchat"))) {
+  console.error(`ERROR: pinned kit not installed in ${PROJECT}.\n` +
+    `       Run:  npm --prefix ${PROJECT} ci   (or  npm --prefix ${PROJECT} install)`);
+  process.exit(2);
+}
+
+// --discover <family>: auto-find every react-v7 skill file whose fences import
+// that family's kit (self-maintaining — the skill list can't rot). The trailing
+// quote keeps chat-uikit-react" from matching chat-uikit-react-native".
+// Per family: the import needle that identifies its fences, AND the skill-directory prefix to
+// scan. BOTH must be family-driven — a hardcoded directory prefix silently discovers 0 files for
+// every other family, which reads as "all fences pass". (AUDIT: RN Phase C.)
+const FAMILIES_JSON = join(ROOT, ".claude/skills/cometchat-skill-reviewer/tools/families.json");
+// Needles + skill-dir pattern are declared per family in families.json (RULES.md §22),
+// so onboarding a family needs no edit here.
+const DISCOVER_FAMILY = Object.fromEntries(
+  Object.values(JSON.parse(readFileSync(FAMILIES_JSON, "utf8")).families)
+    .filter((f) => f.fenceNeedles && f.skillDirPattern)
+    .map((f) => [basename(f.catalog || "", ".json"),
+                 { needles: f.fenceNeedles, dir: new RegExp(f.skillDirPattern) }]),
+);
+const files = [];
+if (DISCOVER) {
+  const fam = DISCOVER_FAMILY[DISCOVER];
+  if (!fam) { console.error(`unknown --discover family: ${DISCOVER}`); process.exit(2); }
+  const { needles, dir: dirRe } = fam;
+  const skillsRoot = join(ROOT, "skills");
+  const collect = (dir) => {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      const p = join(dir, e.name);
+      if (e.isDirectory()) collect(p);
+      else if (e.name.endsWith(".md")) {
+        const body = readFileSync(p, "utf8");
+        if (needles.some((n) => body.includes(n))) files.push(p);
+      }
+    }
+  };
+  for (const d of readdirSync(skillsRoot, { withFileTypes: true })) {
+    if (d.isDirectory() && dirRe.test(d.name)) collect(join(skillsRoot, d.name));
+  }
+  if (files.length === 0) {
+    console.error(`ERROR: --discover ${DISCOVER} matched 0 files (dir ${dirRe}, needles ${needles.join(" | ")}).\n` +
+      `A family that discovers nothing is a WIRING bug — it would otherwise report "all fences pass".`);
+    process.exit(2);
+  }
+} else {
+  // explicit file/dir args
+  for (const a of args.filter((x, i) => !x.startsWith("--") && !["--project", "--tsconfig", "--discover"].includes(args[i - 1]))) {
+    const p = join(ROOT, a);
+    if (existsSync(p)) files.push(p);
+  }
+}
+
+const KIT_ERROR_CODES = new Set([
+  "TS2305", "TS2307", "TS2724", // module / exported member
+  "TS2614",                     // no exported member (import-kind mismatch, e.g. default vs named)
+  "TS2339", "TS2551",           // property does not exist
+  "TS2345", "TS2554", "TS2769", // argument / arg-count / overload
+  "TS2353",                     // unknown object-literal property
+  "TS2322", "TS2741",           // type not assignable / missing required property (real API-shape drift)
+  "TS2882",                     // side-effect import with no type declaration (e.g. the CSS "/styles" entry)
+]);
+
+// TS2304 (cannot find name) is placeholder noise in illustrative fragments (APP_ID, uid, guid…),
+// so it only counts for WHOLE-FILE fences — a first line naming the file (`// src/main.ts`) says
+// "paste this as the file", and an undeclared helper there fails the user's build. A fence that
+// extends a file shown earlier says so: `// src/app/x.ts — continued …` is exempt.
+const WHOLE_FILE_RE = /^\/\/\s*[\w@./\[\]()-]+\.(?:ts|tsx|mts)\b/;
+function isWholeFile(body) {
+  const first = (body.split("\n").find((l) => l.trim()) || "").trim();
+  return WHOLE_FILE_RE.test(first) && !/\bcontinued\b/i.test(first);
+}
+
+function extractFences(file) {
+  const src = readFileSync(file, "utf8");
+  const out = [];
+  const re = /```(?:tsx?|typescript|ts)\n([\s\S]*?)```/g;
+  let m, idx = 0;
+  while ((m = re.exec(src))) {
+    const body = m[1];
+    if (!/from\s+["']@cometchat\//.test(body)) continue;      // real recipe, not a fragment
+    if (/tier2-version-gated/.test(body)) continue;           // API newer than the pinned kit
+    out.push({ idx: idx++, body, wholeFile: isWholeFile(body) });
+  }
+  return out;
+}
+
+const FENCE_DIR = join(projectAbs, "src", "__fences__");
+rmSync(FENCE_DIR, { recursive: true, force: true });
+mkdirSync(FENCE_DIR, { recursive: true });
+
+// Ambient decls for framework globals the fences legitimately use (Vite env, CSS,
+// ?url/?raw asset imports) — not kit APIs; without them tsc emits env noise.
+writeFileSync(join(FENCE_DIR, "__ambient.d.ts"),
+  [
+    "interface ImportMeta { env: Record<string, string>; }",
+    'declare module "*.css" { const s: string; export default s; }',
+    'declare module "*.css?url" { const s: string; export default s; }',
+    'declare module "*?url" { const s: string; export default s; }',
+    'declare module "*?raw" { const s: string; export default s; }',
+  ].join("\n") + "\n");
+
+const manifest = [];
+for (const file of files) {
+  if (!existsSync(file)) { console.error(`skip (not found): ${file}`); continue; }
+  const rel = file.replace(ROOT + "/", "");
+  const name = rel.replace(/[^A-Za-z0-9_-]/g, "_");
+  for (const f of extractFences(file)) {
+    const fenceFile = join(FENCE_DIR, `${name}__${f.idx}.tsx`);
+    writeFileSync(fenceFile, `// @fence ${rel} #${f.idx}\n${f.body}\n`);
+    manifest.push({ fenceFile, skill: name, idx: f.idx, wholeFile: f.wholeFile });
+  }
+}
+console.log(`Extracted ${manifest.length} import-bearing fence(s) from ${files.length} file(s) into ${PROJECT}/src/__fences__`);
+
+// tsc --noEmit, TWO-PASS: tsc suppresses ALL semantic diagnostics if any file has
+// a syntactic (TS1xxx) error. Illustrative fragments often don't parse standalone
+// and would mask real drift in every other fence — so strip the non-parseable ones
+// (reported as a count) and re-run until the set parses cleanly.
+const ERR_RE = /__fences__\/(.+)\.tsx\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.*)/;
+function runTsc() {
+  try {
+    execSync(`npx tsc --noEmit -p ${TSCONFIG}`, { cwd: projectAbs, stdio: ["ignore", "pipe", "pipe"] });
+    return "";
+  } catch (e) { return `${e.stdout || ""}${e.stderr || ""}`; }
+}
+let raw = runTsc();
+const stripped = new Set();
+for (let pass = 0; pass < 10; pass++) {
+  const syntactic = new Set();
+  for (const line of raw.split("\n")) {
+    const m = line.match(ERR_RE);
+    if (m && /^TS1\d{3}$/.test(m[4])) syntactic.add(m[1]);
+  }
+  if (syntactic.size === 0) break;
+  for (const nm of syntactic) { rmSync(join(FENCE_DIR, `${nm}.tsx`), { force: true }); stripped.add(nm); }
+  raw = runTsc();
+}
+
+const wholeFileFences = new Set(manifest.filter((f) => f.wholeFile).map((f) => `${f.skill}__${f.idx}`));
+const kitErrors = [];
+for (const line of raw.split("\n")) {
+  const m = line.match(ERR_RE);
+  if (!m) continue;
+  const [, fenceName, , , code, msg] = m;
+  if (code === "TS2304" && wholeFileFences.has(fenceName)) { kitErrors.push({ fenceName, code, msg }); continue; }
+  if (!KIT_ERROR_CODES.has(code)) continue;
+  if (code === "TS2307" && !/@cometchat\//.test(msg)) continue; // app-relative/CSS imports = env noise
+  kitErrors.push({ fenceName, code, msg });
+}
+
+rmSync(FENCE_DIR, { recursive: true, force: true });
+const checked = manifest.length - stripped.size;
+const strippedNote = stripped.size ? ` (${stripped.size} non-parseable fragment fence(s) skipped)` : "";
+if (kitErrors.length === 0) {
+  console.log(`\n✅ Tier-2: no kit-API errors across ${checked} semantically-checked fence(s)${strippedNote}.`);
+  process.exit(0);
+}
+console.log(`\n❌ ${kitErrors.length} kit-API error(s) — real method/signature/import drift:`);
+for (const e of kitErrors) console.log(`  [${e.fenceName}] ${e.code}: ${e.msg}`);
+process.exit(1);