@cosmicdrift/kumiko-guards 0.1.0 → 0.3.0

package/src/guard-table-ddl.ts

@@ -0,0 +1,159 @@
+#!/usr/bin/env bun
+/**
+ * Table-DDL Guard (WARNUNG, kein Fail).
+ *
+ * Findet Aufrufe von `unsafePushTables` / `unsafeCreateEntityTable` /
+ * `unsafeEnsureEntityTable` außerhalb der erlaubten Pfade. Apps
+ * deklarieren Tabellen via `r.entity()` (event-sourced) oder
+ * `r.rawTable()` (deklarativer Bypass mit Audit-Marker) — direkte
+ * `unsafe*`-Aufrufe umgehen das Event-Sourcing-System komplett.
+ *
+ * Plan: kumiko-platform/docs/plans/architecture/table-ddl-guard.md
+ * (Stufe 2). Stufe 1 hat die Symbole umbenannt damit jeder Aufruf
+ * grep-bar ist; Stufe 3 hat `r.rawTable()` als saubere Alternative
+ * eingeführt; Stufe 2 (dieser Check) erzwingt Konsistenz.
+ *
+ * Allowlist (Pfad-Regex, OR-verknüpft):
+ *   - packages/framework/src/event-store/**          ES-Meta-Tabellen
+ *   - packages/framework/src/pipeline/event-consumer-state.ts
+ *   - packages/framework/src/pipeline/projection-state.ts
+ *   - packages/framework/src/stack/**                Test-Stack-Helper, pushEntityProjectionTables, Helper-Definitionen
+ *   - **\/__tests__/**                               Test-Setup
+ *   - **\/drizzle/**                                 drizzle-kit-Konfiguration
+ *   - **\/bin/migrate.ts                             App-eigener Migrate-CLI
+ *   - packages/guards/src/guard-table-ddl.ts          der Guard selbst
+ *   - kumiko-framework/scripts/migrate-rename-table-ddl.ts  ts-morph-Rename
+ *
+ * Output: Warnung + Datei:Zeile + Code-Snippet. Blockt nie.
+ */
+
+import path from "node:path";
+import { type SourceFile, SyntaxKind } from "ts-morph";
+import { type AstGuard, runStandalone, type ScanSpec } from "./_lib/guard-kit";
+
+const ROOT = process.cwd();
+
+const SCAN: ScanSpec = { scope: "source", extensions: ["ts"] };
+
+export const UNSAFE_NAMES: ReadonlySet<string> = new Set([
+  "unsafePushTables",
+  "unsafeCreateEntityTable",
+  "unsafeEnsureEntityTable",
+]);
+
+export const ALLOWLIST_PATTERNS: ReadonlyArray<RegExp> = [
+  /\/packages\/framework\/src\/event-store\//,
+  /\/packages\/framework\/src\/pipeline\/event-consumer-state\.ts$/,
+  /\/packages\/framework\/src\/pipeline\/projection-state\.ts$/,
+  /\/packages\/framework\/src\/stack\//,
+  /\/__tests__\//,
+  /\/drizzle\//,
+  /\/bin\/migrate\.ts$/,
+  // Guards + Rename-Script dürfen die Symbole im Code nennen — beide
+  // sind Tooling, kein Runtime-Pfad.
+  /\/packages\/guards\/src\/guard-table-ddl\.ts$/,
+  /\/scripts\/migrate-rename-table-ddl\.ts$/,
+];
+
+export function isAllowed(absPath: string): boolean {
+  return ALLOWLIST_PATTERNS.some((re) => re.test(absPath));
+}
+
+export interface Finding {
+  readonly file: string;
+  readonly line: number;
+  readonly symbol: string;
+  readonly snippet: string;
+}
+
+export function collectFindings(sf: SourceFile, repoRoot: string): Finding[] {
+  const absPath = sf.getFilePath();
+  if (isAllowed(absPath)) return [];
+
+  const findings: Finding[] = [];
+  const lines = sf.getFullText().split("\n");
+
+  for (const id of sf.getDescendantsOfKind(SyntaxKind.Identifier)) {
+    const name = id.getText();
+    if (!UNSAFE_NAMES.has(name)) continue;
+
+    // Skip the import/export specifier itself — the violation is the
+    // call-site, not "having the name in scope". An app that imports
+    // unsafe* without calling it is weird but not the bypass we care
+    // about (and the `as` alias case still flags the call below).
+    const parent = id.getParent();
+    if (!parent) continue;
+    const pk = parent.getKind();
+    if (pk === SyntaxKind.ImportSpecifier) continue;
+    if (pk === SyntaxKind.ExportSpecifier) continue;
+
+    // Skip property-access right-hand-side (`obj.unsafePushTables`):
+    // a method on some unrelated type that happens to share the name.
+    if (pk === SyntaxKind.PropertyAccessExpression) {
+      const pae = parent.asKindOrThrow(SyntaxKind.PropertyAccessExpression);
+      if (pae.getNameNode() === id) continue;
+    }
+    if (pk === SyntaxKind.PropertyAssignment) continue;
+    if (pk === SyntaxKind.ShorthandPropertyAssignment) continue;
+    // Type-level shadows: `interface { unsafePushTables(): void }` or
+    // `type T = { unsafePushTables: () => void }`. Different namespace,
+    // not the runtime call.
+    if (pk === SyntaxKind.PropertySignature) {
+      const ps = parent.asKindOrThrow(SyntaxKind.PropertySignature);
+      if (ps.getNameNode() === id) continue;
+    }
+    if (pk === SyntaxKind.MethodSignature) {
+      const ms = parent.asKindOrThrow(SyntaxKind.MethodSignature);
+      if (ms.getNameNode() === id) continue;
+    }
+
+    const line = id.getStartLineNumber();
+    const raw = (lines[line - 1] ?? "").trim();
+    const snippet = raw.length > 100 ? `${raw.slice(0, 97)}...` : raw;
+    findings.push({
+      file: path.relative(repoRoot, absPath),
+      line,
+      symbol: name,
+      snippet,
+    });
+  }
+  return findings;
+}
+
+function report(findings: readonly Finding[], scanned: number): void {
+  console.log(`Table-DDL Guard: ${scanned} files checked.`);
+  if (findings.length === 0) {
+    console.log("  No bypass calls outside the allowlist.");
+    return;
+  }
+  console.log(`  ${findings.length} bypass call(s) outside the allowlist:`);
+  for (const f of findings) {
+    console.log(`    ${f.file}:${f.line}  ${f.symbol}`);
+    console.log(`      ${f.snippet}`);
+  }
+  console.log("");
+  console.log("  Rule: unsafe* calls are reserved for framework-internal code (event-store,");
+  console.log("  pipeline-state, stack), test setup (__tests__, drizzle/), app migrate CLIs");
+  console.log("  (bin/migrate.ts). Apps declare tables via r.entity() or r.rawTable().");
+  console.log("  Plan: kumiko-platform/docs/plans/architecture/table-ddl-guard.md");
+  console.log("  Warning, no fail.");
+}
+
+export const guard: AstGuard = {
+  name: "Table-DDL Guard",
+  scan: SCAN,
+  run(files) {
+    const findings: Finding[] = [];
+    let scanned = 0;
+    for (const sf of files) {
+      scanned++;
+      findings.push(...collectFindings(sf, ROOT));
+    }
+    report(findings, scanned);
+    // Warnung, kein Fail (siehe Modul-Header): Bypass-Aufrufe werden
+    // gemeldet, blocken den Guard-Run aber nie.
+    return { violations: [] };
+  },
+};
+
+if (import.meta.main) runStandalone(guard);

package/src/guard-tailwind-scan-surface.ts

@@ -145,7 +145,7 @@ function scan(files: readonly SourceFile[]): {
         if (token.length === 0 || allowed.has(token)) continue;
         findings.push({ file, line, token });
         console.warn(
-          `  [tailwind-scan-surface WARN] ${file}:${line}  Klasse "${token}" liegt außerhalb des Tailwind-Scan-Bereichs (renderer-web/src, renderer/src, samples/**/src)`,
+          `  [tailwind-scan-surface WARN] ${file}:${line}  class "${token}" is outside the Tailwind scan surface (renderer-web/src, renderer/src, samples/**/src)`,
         );
       }
     }
@@ -163,7 +163,7 @@ const BASELINE_FILE = ".kumiko-tailwind-scan-surface-baseline.json";
 const tailwindScanSurfaceBaseline = baselineRatchet({
   file: path.join(BASELINE_ROOT, BASELINE_FILE),
   formatVersion: 1,
-  unit: "Klassen-Token(s)",
+  unit: "class token(s)",
 });
 
 // Second, independent rule: a consuming app repo (studio,
@@ -489,7 +489,7 @@ const SOURCE_COVERAGE_BASELINE_FILE = ".kumiko-tailwind-source-coverage-baseline
 const sourceCoverageBaseline = baselineRatchet({
   file: path.join(BASELINE_ROOT, SOURCE_COVERAGE_BASELINE_FILE),
   formatVersion: 1,
-  unit: "fehlende(r) @source-Eintrag/Einträge",
+  unit: "missing @source entry/entries",
 });
 
 export function sourceCoverageBaselineCounts(
@@ -504,10 +504,10 @@ function checkSourceCoverageBaseline(findings: readonly SourceCoverageFinding[])
   const resolveLine = (file: string): number => findings.find((f) => f.file === file)?.line ?? 1;
   return sourceCoverageBaseline.check(
     sourceCoverageBaselineCounts(findings),
-    "Paket liefert Tailwind-Klassen ohne @source-Abdeckung in dieser App — @source-Eintrag für beide Install-Layouts ergänzen (Muster: bestehende bundled-features-Einträge).",
+    "Package delivers Tailwind classes without @source coverage in this app — add an @source entry for both install layouts (pattern: existing bundled-features entries).",
     {
       formatDriftRemediation:
-        "Einmalig `bun guards/guard-tailwind-scan-surface.ts --write-baseline` aufrufen.",
+        "Run `bun guards/guard-tailwind-scan-surface.ts --write-baseline` once.",
       resolveLine,
     },
   );
@@ -523,10 +523,10 @@ function checkBaseline(findings: readonly Finding[]): GuardViolation[] {
   const resolveLine = (file: string): number => findings.find((f) => f.file === file)?.line ?? 1;
   return tailwindScanSurfaceBaseline.check(
     baselineCounts(findings),
-    "Klasse außerhalb des @source-Scan-Bereichs (renderer-web/src, renderer/src, samples/**/src) — eine dort bereits emittierte Klasse wiederverwenden, oder das Styling nach renderer-web ziehen.",
+    "Class outside the @source scan surface (renderer-web/src, renderer/src, samples/**/src) — reuse a class already emitted there, or move the styling into renderer-web.",
     {
       formatDriftRemediation:
-        "Einmalig `bun guards/guard-tailwind-scan-surface.ts --write-baseline` aufrufen.",
+        "Run `bun guards/guard-tailwind-scan-surface.ts --write-baseline` once.",
       resolveLine,
     },
   );
@@ -542,7 +542,7 @@ export function analyse(
   const publishedSurfaceFindings = scanPublishedScanSurface(roots);
   reportPublishedScanSurfaceFindings(publishedSurfaceFindings);
   if (!compareBaseline) {
-    console.log("  Baseline-Vergleich uebersprungen (--no-baseline).");
+    console.log("  Baseline comparison skipped (--no-baseline).");
     return { violations: [] };
   }
   return {
@@ -558,10 +558,10 @@ export const guard: AstGuard = {
   name: "Tailwind-Scan-Surface Guard",
   scan: SCAN,
   hint:
-    "Tailwind-Klasse in bundled-features außerhalb des @source-Scan-Bereichs (renderer-web/src, renderer/src, samples/**/src) " +
-    `— reuse a class already emitted there, or move the styling into renderer-web. Begründete Ausnahme: // ${IGNORE_TAG} <Grund>. ` +
-    "Paket ohne @source-Abdeckung in einer App: @source-Eintrag für beide Install-Layouts ergänzen. " +
-    "@source mit node_modules/<pkg>/<segment>-Pfad: prüfen ob <pkg> dieses Segment überhaupt publiziert (package.json files).",
+    "Tailwind class in bundled-features outside the @source scan surface (renderer-web/src, renderer/src, samples/**/src) " +
+    `— reuse a class already emitted there, or move the styling into renderer-web. Justified exception: // ${IGNORE_TAG} <reason>. ` +
+    "Package without @source coverage in an app: add an @source entry for both install layouts. " +
+    "@source with a node_modules/<pkg>/<segment> path: check whether <pkg> even publishes that segment (package.json files).",
   run: (files) => analyse(files, true),
 };
 

package/src/guard-test-stack-drift.ts

@@ -0,0 +1,147 @@
+#!/usr/bin/env bun
+/**
+ * Guard: *.integration.ts / *.integration.test.ts files must not construct
+ * a parallel server stack. Concretely: if the test calls neither
+ * `buildServer(...)` nor `setupTestStack(...)`, but still instantiates
+ * pipeline internals like `createDispatcher`, `createOutboxPoller`, or
+ * `createLifecycleHooks` directly, it builds its own test reality next to
+ * the production wiring — exactly the drift source that produces green
+ * tests over a broken prod path.
+ *
+ * Allowed opt-out: `// @no-server-stack: <reason>` anywhere in the file.
+ * Meant for pure adapter integration tests (DB, Redis, Meilisearch) that
+ * deliberately don't spin up a server.
+ *
+ * Usage:
+ *   bun guards/guard-test-stack-drift.ts
+ */
+
+import * as path from "node:path";
+import { Project, type SourceFile, SyntaxKind } from "ts-morph";
+import {
+  type GuardViolation,
+  type RepoCheck,
+  reportResults,
+  runRepoChecks,
+} from "./_lib/guard-kit";
+import { frameworkTsConfigPath } from "./_lib/roots";
+import { type ScanSpec, scanFiles } from "./_lib/scan-scope";
+
+const ROOT = process.cwd();
+
+// Beide Suffixe: `.integration.ts` (legacy) + `.integration.test.ts` (canonical
+// nach bun-test-cutover). Transition-safe — matcht main (legacy) und migrierte
+// Branches gleichermaßen.
+const SCAN: ScanSpec = {
+  scope: "tests",
+  extensions: ["ts"],
+  kinds: ["framework"],
+  frameworkWithin: [
+    "packages/framework/src/**/*.integration.ts",
+    "packages/framework/src/**/*.integration.test.ts",
+    "packages/bundled-features/src/**/*.integration.ts",
+    "packages/bundled-features/src/**/*.integration.test.ts",
+  ],
+};
+
+// Functions whose call in an integration test signals "I build the server".
+// If any of these are called, the file is considered "properly wired".
+const SERVER_ENTRYPOINTS = new Set(["buildServer", "setupTestStack"]);
+
+// Pipeline-internal factories. Calling any of these WITHOUT also calling a
+// server entrypoint means the test is assembling its own parallel stack.
+const FORBIDDEN_WITHOUT_SERVER = new Set([
+  "createDispatcher",
+  "createOutboxPoller",
+  "createLifecycleHooks",
+]);
+
+const OPT_OUT_MARKER = /\/\/\s*@no-server-stack:/i;
+
+const INTEGRATION_FILE = /\.integration(\.test)?\.ts$/;
+
+export function isIntegrationTestFile(filePath: string): boolean {
+  return INTEGRATION_FILE.test(filePath);
+}
+
+export interface Violation {
+  file: string;
+  reason: string;
+  forbiddenCalls: Array<{ name: string; line: number }>;
+}
+
+function collectCallNames(sf: SourceFile): Map<string, number[]> {
+  const calls = new Map<string, number[]>();
+  for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+    const name = call.getExpression().getText();
+    const arr = calls.get(name) ?? [];
+    arr.push(call.getStartLineNumber());
+    calls.set(name, arr);
+  }
+  return calls;
+}
+
+function hasOptOutMarker(sf: SourceFile): boolean {
+  return OPT_OUT_MARKER.test(sf.getFullText());
+}
+
+export function scanFile(sf: SourceFile): Violation | null {
+  if (hasOptOutMarker(sf)) return null;
+
+  const calls = collectCallNames(sf);
+
+  const hasServerEntrypoint = [...SERVER_ENTRYPOINTS].some((name) => calls.has(name));
+  if (hasServerEntrypoint) return null;
+
+  const forbiddenHits: Array<{ name: string; line: number }> = [];
+  for (const [name, lines] of calls) {
+    if (FORBIDDEN_WITHOUT_SERVER.has(name)) {
+      for (const line of lines) forbiddenHits.push({ name, line });
+    }
+  }
+
+  if (forbiddenHits.length === 0) return null;
+
+  return {
+    file: path.relative(ROOT, sf.getFilePath()),
+    reason: "calls pipeline internals without buildServer/setupTestStack",
+    forbiddenCalls: forbiddenHits,
+  };
+}
+
+export const check: RepoCheck = {
+  name: "Test-Stack-Drift Guard",
+  hint:
+    "Integration tests must call buildServer or setupTestStack — otherwise they test a different " +
+    "reality than prod. Pure adapter tests without a server stack: // @no-server-stack: <reason>.",
+  run(roots) {
+    if (!roots.some((r) => r.kind === "framework")) {
+      return { violations: [], matchedFiles: 0, notApplicable: true };
+    }
+
+    const project = new Project({
+      tsConfigFilePath: frameworkTsConfigPath(),
+      skipAddingFilesFromTsConfig: true,
+      skipFileDependencyResolution: true,
+    });
+    const paths = scanFiles(SCAN, roots);
+    for (const p of paths) project.addSourceFileAtPath(p);
+
+    const violations: GuardViolation[] = [];
+    for (const sf of project.getSourceFiles()) {
+      if (!isIntegrationTestFile(sf.getFilePath())) continue;
+      const v = scanFile(sf);
+      if (v === null) continue;
+      for (const c of v.forbiddenCalls) {
+        violations.push({ file: v.file, line: c.line, message: `${v.reason}: ${c.name}(...)` });
+      }
+    }
+
+    return { violations, matchedFiles: paths.length, notApplicable: false };
+  },
+};
+
+if (import.meta.main) {
+  const failed = reportResults(await runRepoChecks([check]));
+  process.exit(failed > 0 ? 1 : 0);
+}

package/src/guard-text-field-stance.ts

@@ -0,0 +1,222 @@
+#!/usr/bin/env bun
+/**
+ * Guard: `createTextField`/`createLongTextField`-Aufrufe ohne `personal`-
+ * Haltung, mit Baseline-Regression-Guard wie guard-pii-annotations.ts.
+ *
+ * kumiko-framework#2810: `createTextField`/`createLongTextField` sollen
+ * fail-closed werfen, wenn kein `personal` (Muster #2558) deklariert ist.
+ * Workspace-weit fehlt `personal` an hunderten Call-Sites — ein Throw würde
+ * den Build sofort brechen. Dieser Guard deckt die Vollmenge (jeder Aufruf)
+ * ab, `guard-pii-annotations.ts` nur die Namens-Heuristik (PII-verdächtige
+ * Feldnamen) — die beiden Baselines sind bewusst getrennt.
+ *
+ * `.kumiko-text-field-stance-baseline.json` im Repo-Root pinnt pro File die
+ * eingefrorene Fund-Anzahl:
+ *   - aktuell <= baseline pro File: PASS
+ *   - aktuell >  baseline pro File: FAIL (neuer Aufruf ohne personal-Haltung)
+ * Reduktionen updaten die Baseline NICHT automatisch — nach Annotations-
+ * Commits `--write-baseline` aufrufen. Ohne Baseline-Datei bleibt der Guard
+ * warning-only (Bootstrap: einmalig `--write-baseline`).
+ *
+ * Usage:
+ *   bun guards/guard-text-field-stance.ts                  # Vergleich gegen Baseline
+ *   bun guards/guard-text-field-stance.ts --write-baseline # Baseline neu schreiben
+ *   bun guards/guard-text-field-stance.ts --no-baseline    # Vergleich überspringen
+ */
+import * as path from "node:path";
+import {
+  type CallExpression,
+  type Node,
+  type ObjectLiteralExpression,
+  type SourceFile,
+  SyntaxKind,
+} from "ts-morph";
+import {
+  type AstGuard,
+  baselineRatchet,
+  buildSharedProject,
+  filesForGuard,
+  type GuardOutcome,
+  type GuardViolation,
+  isLocalFinding,
+  runStandalone,
+  type ScanSpec,
+} from "./_lib/guard-kit";
+
+const ROOT = process.cwd();
+
+const SCAN: ScanSpec = {
+  scope: "source",
+  extensions: ["ts"],
+  frameworkWithin: ["packages/*/src/**"],
+};
+// Unlike guard-pii-annotations.ts, tests are IN scope: kumiko-framework#2810's
+// fail-closed throw fires at call time regardless of test vs. production code —
+// a test fixture calling createTextField() without `personal` breaks the same
+// way prod code would once the throw lands.
+const EXCLUDE = /\.d\.ts$/;
+
+const FIELD_FACTORY_CALLEES = new Set(["createTextField", "createLongTextField"]);
+
+const VALID_PERSONAL_HINT =
+  '{ personal: "self" | "tenant" | "ref" | { of: "<ownerField>" } | false } ("false" additionally needs { reason: "..." })';
+
+function relFile(sf: SourceFile): string {
+  return path.relative(ROOT, sf.getFilePath());
+}
+
+function fieldFactoryOptions(call: CallExpression): ObjectLiteralExpression | undefined {
+  const first = call.getArguments()[0];
+  return first?.isKind(SyntaxKind.ObjectLiteralExpression) ? first : undefined;
+}
+
+// A spread's source (e.g. `{ ...base, maxLength: 5 }`) may supply `personal`
+// without a literal property here — statically undecidable like a non-object
+// argument, so treat it the same way (not countable).
+function hasSpreadProperty(obj: ObjectLiteralExpression): boolean {
+  return obj.getProperties().some((prop) => prop.isKind(SyntaxKind.SpreadAssignment));
+}
+
+// Mirrors guard-pii-annotations.ts's `personal` branch: every value counts as
+// answered, including `personal: false` (the framework requires a `reason`
+// for it) — except `undefined`/`null`, which never answered the question.
+function hasPersonalStance(obj: ObjectLiteralExpression): boolean {
+  const prop = obj.getProperty("personal");
+  if (!prop || !prop.isKind(SyntaxKind.PropertyAssignment)) return false;
+  const init: Node | undefined = prop.getInitializer();
+  return (
+    init !== undefined &&
+    init.getKind() !== SyntaxKind.UndefinedKeyword &&
+    !(init.isKind(SyntaxKind.Identifier) && init.getText() === "undefined") &&
+    init.getKind() !== SyntaxKind.NullKeyword
+  );
+}
+
+function enclosingFieldName(call: CallExpression): string | null {
+  let node = call.getParent();
+  while (node) {
+    if (node.isKind(SyntaxKind.PropertyAssignment)) {
+      return node.getName();
+    }
+    node = node.getParent();
+  }
+  return null;
+}
+
+export interface Finding {
+  file: string;
+  line: number;
+  place: string;
+  callee: string;
+}
+
+function scanFieldFactories(sf: SourceFile): Finding[] {
+  const findings: Finding[] = [];
+  for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+    const callee = call.getExpression().getText();
+    if (!FIELD_FACTORY_CALLEES.has(callee)) continue;
+
+    const args = call.getArguments();
+    if (args.length > 0) {
+      const options = fieldFactoryOptions(call);
+      if (!options) continue; // non-literal argument (variable/spread) — not statically decidable
+      if (hasSpreadProperty(options)) continue;
+      if (hasPersonalStance(options)) continue;
+    }
+
+    const place = enclosingFieldName(call) ?? `${callee}(...)`;
+    const line = call.getStartLineNumber();
+    findings.push({ file: relFile(sf), line, place, callee });
+    console.warn(
+      `  [text-field-stance WARN] ${relFile(sf)}:${line}  ${callee}(...) at "${place}" has no personal stance — mark ${VALID_PERSONAL_HINT}`,
+    );
+  }
+  return findings;
+}
+
+function scan(files: readonly SourceFile[]): {
+  findings: Finding[];
+  scanned: number;
+} {
+  const findings: Finding[] = [];
+  let scanned = 0;
+  for (const sf of files) {
+    if (EXCLUDE.test(sf.getFilePath())) continue;
+    scanned++;
+    findings.push(...scanFieldFactories(sf));
+  }
+  return { findings, scanned };
+}
+
+function localFindings(findings: readonly Finding[]): readonly Finding[] {
+  return findings.filter(isLocalFinding);
+}
+
+function countByFile(findings: readonly Finding[]): Record<string, number> {
+  const counts: Record<string, number> = {};
+  for (const f of findings) counts[f.file] = (counts[f.file] ?? 0) + 1;
+  return counts;
+}
+
+const BASELINE_FILE = ".kumiko-text-field-stance-baseline.json";
+const textFieldStanceBaseline = baselineRatchet({
+  file: path.join(ROOT, BASELINE_FILE),
+  formatVersion: 1,
+  unit: "finding(s) without personal stance",
+});
+
+// One place for "what goes into the baseline", used by both the compare and
+// the write path — a sibling finding leaking into the written file would turn
+// a foreign checkout's code into a local, unfixable red.
+export function baselineCounts(findings: readonly Finding[]): Record<string, number> {
+  return countByFile(localFindings(findings));
+}
+
+function checkBaseline(findings: readonly Finding[]): GuardViolation[] {
+  const local = localFindings(findings);
+  const resolveLine = (file: string): number => local.find((f) => f.file === file)?.line ?? 1;
+  return textFieldStanceBaseline.check(
+    baselineCounts(findings),
+    `Annotate the call (${VALID_PERSONAL_HINT}).`,
+    {
+      formatDriftRemediation: `Run \`bun guards/guard-text-field-stance.ts --write-baseline\` once.`,
+      resolveLine,
+    },
+  );
+}
+
+function analyse(files: readonly SourceFile[], compareBaseline: boolean): GuardOutcome {
+  const { findings } = scan(files);
+  if (!compareBaseline) {
+    console.log("  Baseline comparison skipped (--no-baseline).");
+    return { violations: [] };
+  }
+  return { violations: checkBaseline(findings) };
+}
+
+export const guard: AstGuard = {
+  name: "Text-Field Personal-Stance Guard",
+  scan: SCAN,
+  hint: "after a deliberate annotation: `bun guards/guard-text-field-stance.ts --write-baseline`",
+  run: (files) => analyse(files, true),
+};
+
+// Flags werden NUR hier gelesen, nicht in run() — der Shared-Runner
+// (run-guards.ts) faehrt alle Guards mit derselben argv, ein
+// --write-baseline dort duerfte die Baseline nicht stillschweigend
+// neu schreiben.
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  if (args.includes("--write-baseline")) {
+    const project = buildSharedProject([guard]);
+    const { findings } = scan(filesForGuard(project, guard));
+    textFieldStanceBaseline.write(baselineCounts(findings));
+    process.exit(0);
+  }
+  if (args.includes("--no-baseline")) {
+    const project = buildSharedProject([guard]);
+    analyse(filesForGuard(project, guard), false);
+    process.exit(0);
+  }
+  runStandalone(guard);
+}

package/src/guard-thin-wrappers.ts

@@ -299,7 +299,12 @@ function extractCalleeName(callNode: ReturnType<FnNode["getBody"]> | undefined):
   const expr = callNode.isKind(SyntaxKind.CallExpression) ? callNode.getExpression() : null;
   if (!expr) return null;
   if (expr.isKind(SyntaxKind.Identifier)) return expr.getText();
-  if (expr.isKind(SyntaxKind.PropertyAccessExpression)) return expr.getName();
+  if (expr.isKind(SyntaxKind.PropertyAccessExpression)) {
+    // `/re/.test(x)` is a RegExp method call, not a call to a function named
+    // "test" — a regex-literal receiver is never a wrapper callee.
+    if (expr.getExpression().isKind(SyntaxKind.RegularExpressionLiteral)) return null;
+    return expr.getName();
+  }
   return null;
 }
 

package/src/guard-unsafe-json-parse.ts

@@ -66,7 +66,7 @@ function scanFile(sf: SourceFile): UnsafeSite[] {
 export const guard: AstGuard = {
   name: "Unsafe-JSON-Parse Guard",
   scan: SCAN,
-  hint: "Nutze parseJsonSafe (Cache-Semantik) oder parseJsonOrThrow (Boundary-Semantik) aus utils/safe-json.",
+  hint: "Use parseJsonSafe (cache semantics) or parseJsonOrThrow (boundary semantics) from utils/safe-json.",
   run(files) {
     const violations: Array<{ file: string; line: number; message: string }> = [];
     for (const sf of files) {