delimit-cli 4.1.49 → 4.1.50

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [4.1.50] - 2026-04-09
+
+### Fixed (CRITICAL — CLAUDE.md in-prose marker clobber)
+- **`upsertDelimitSection` regex was unanchored** — `bin/delimit-setup.js` used `/<!-- delimit:start[^>]*-->/` (no line anchors) to detect the managed-section markers. If a user *quoted* the markers inside backticks in a documentation bullet (e.g. `Use managed-section markers (\`<!-- delimit:start -->\` / \`<!-- delimit:end -->\`)`), the regex matched the prose mention. On the next `delimit setup` run the upsert sliced everything between the prose start and prose end markers and replaced it with a fresh stock template — the exact "never clobber user-customized files" failure mode 4.1.48 / 4.1.49 were written to prevent. Reproduced on `/root/CLAUDE.md` 2026-04-09.
+- Both markers are now anchored to start-of-line with the multiline flag, allow optional leading horizontal whitespace (`/^[ \t]*<!-- delimit:start[^>]*-->[ \t]*$/m`), and the file is BOM-stripped before matching. Result: documentation prose that quotes the markers inside backticks, blockquotes (`> `), or bullets (`- `, `* `) is never matched, while genuine markers — flush-left, indented, or BOM-prefixed — still are. Same fix applied to the test mirror in `tests/setup-onboarding.test.js`.
+
+### Added
+- **Regression tests** in `tests/setup-onboarding.test.js` covering five failure modes the v4.1.49 regex would have matched incorrectly:
+  - Markers quoted in a bullet via inline backticks (the exact /root/CLAUDE.md 2026-04-09 incident)
+  - Markers with a CRLF (`\r\n`) line ending
+  - File starting with a UTF-8 BOM
+  - Tab- and space-indented real markers (must still be recognized)
+  - Bullet- and blockquote-prefixed markers (must NOT be recognized)
+  Each test asserts both the first-run behavior (`appended` vs `updated`) and that user content survives a subsequent version-bump upgrade verbatim.
+
+### Scope
+- Single-purpose patch: CLAUDE.md preservation only. Unrelated gateway fixes (e.g. `loop_engine` LED-814) deferred to 4.1.51 per multi-model deliberation, since 4.1.48 and 4.1.49 both shipped with the regression bug undetected and 4.1.50 must stay laser-focused.
+
+### Tests
+- 134/134 npm CLI tests passing (was 129). New regression suite (`does not match markers quoted in prose`, CRLF, BOM, indented, bullet/blockquote-prefixed) covers every edge case the multi-model deliberation surfaced.
+
 ## [4.1.49] - 2026-04-09
 
 ### Fixed (full preservation audit follow-up to 4.1.48)

package/bin/delimit-setup.js

@@ -1362,24 +1362,38 @@ function upsertDelimitSection(filePath) {
         return { action: 'created' };
     }
 
-    const existing = fs.readFileSync(filePath, 'utf-8');
-
-    // Check if managed markers already exist
-    const startMarkerRe = /<!-- delimit:start[^>]*-->/;
-    const endMarker = '<!-- delimit:end -->';
-    const hasStart = startMarkerRe.test(existing);
-    const hasEnd = existing.includes(endMarker);
+    const rawExisting = fs.readFileSync(filePath, 'utf-8');
+    // Strip a UTF-8 BOM if present so the start-of-line anchor still matches
+    // the very first line of the file. We write back the stripped form to keep
+    // serialization deterministic.
+    const existing = rawExisting.replace(/^\uFEFF/, '');
+
+    // Check if managed markers already exist.
+    // Markers MUST be on their own line — anchored with the multiline flag — so
+    // that documentation prose that quotes the markers (e.g. inside backticks,
+    // bullets, or blockquotes) does NOT get mistaken for a real managed section.
+    // The v4.1.49 unanchored regex caused exactly this clobber on /root/CLAUDE.md.
+    // We allow optional leading horizontal whitespace ([ \t]*) so genuinely
+    // indented markers still match, but NOT a leading "- ", "> ", "`", "*", etc.
+    const startMarkerRe = /^[ \t]*<!-- delimit:start[^>]*-->[ \t]*$/m;
+    const endMarkerRe = /^[ \t]*<!-- delimit:end -->[ \t]*$/m;
+    const startMatch = existing.match(startMarkerRe);
+    const endMatch = existing.match(endMarkerRe);
+    const hasStart = !!startMatch;
+    const hasEnd = !!endMatch;
 
     if (hasStart && hasEnd) {
-        // Extract current version from the marker
-        const versionMatch = existing.match(/<!-- delimit:start v([^ ]+) -->/);
+        // Extract current version from the marker (also anchored, allows indent)
+        const versionMatch = existing.match(/^[ \t]*<!-- delimit:start v([^ ]+) -->[ \t]*$/m);
         const currentVersion = versionMatch ? versionMatch[1] : '';
         if (currentVersion === version) {
             return { action: 'unchanged' };
         }
         // Replace only the managed region — preserve content above/below
-        const before = existing.substring(0, existing.search(startMarkerRe));
-        const after = existing.substring(existing.indexOf(endMarker) + endMarker.length);
+        const startIdx = startMatch.index;
+        const endIdx = endMatch.index + endMatch[0].length;
+        const before = existing.substring(0, startIdx);
+        const after = existing.substring(endIdx);
         fs.writeFileSync(filePath, before + newSection + after);
         return { action: 'updated' };
     }

package/gateway/ai/backends/gateway_core.py

@@ -23,11 +23,10 @@ if str(GATEWAY_ROOT) not in sys.path:
 
 
 def _load_specs(spec_path: str) -> Dict[str, Any]:
-    """Load an API spec (OpenAPI or JSON Schema) from a file path.
+    """Load an OpenAPI spec from a file path.
 
     Performs a non-fatal version compatibility check (LED-290) so that
     unknown OpenAPI versions log a warning instead of silently parsing.
-    JSON Schema documents skip the OpenAPI version assert.
     """
     import yaml
 
@@ -42,146 +41,15 @@ def _load_specs(spec_path: str) -> Dict[str, Any]:
         spec = json.loads(content)
 
     # LED-290: warn (non-fatal) if version is outside the validated set.
-    # Only applies to OpenAPI/Swagger documents — bare JSON Schema files
-    # have no "openapi"/"swagger" key and would otherwise trip the assert.
     try:
-        if isinstance(spec, dict) and ("openapi" in spec or "swagger" in spec):
-            from core.openapi_version import assert_supported
-            assert_supported(spec, strict=False)
+        from core.openapi_version import assert_supported
+        assert_supported(spec, strict=False)
     except Exception as exc:  # pragma: no cover -- defensive only
         logger.debug("openapi version check skipped: %s", exc)
 
     return spec
 
 
-# ---------------------------------------------------------------------------
-# LED-713: JSON Schema spec-type dispatch helpers
-# ---------------------------------------------------------------------------
-
-
-def _spec_type(doc: Any) -> str:
-    """Classify a loaded spec doc. 'openapi' or 'json_schema'."""
-    from core.spec_detector import detect_spec_type
-    t = detect_spec_type(doc)
-    # Fallback to openapi for unknown so we never break existing flows.
-    return "json_schema" if t == "json_schema" else "openapi"
-
-
-def _json_schema_changes_to_dicts(changes: List[Any]) -> List[Dict[str, Any]]:
-    return [
-        {
-            "type": c.type.value,
-            "path": c.path,
-            "message": c.message,
-            "is_breaking": c.is_breaking,
-            "details": c.details,
-        }
-        for c in changes
-    ]
-
-
-def _json_schema_semver(changes: List[Any]) -> Dict[str, Any]:
-    """Build an OpenAPI-compatible semver result from JSON Schema changes.
-
-    Mirrors core.semver_classifier.classify_detailed shape so downstream
-    consumers (PR comment, CI formatter, ledger) don't need to branch.
-    """
-    breaking = [c for c in changes if c.is_breaking]
-    non_breaking = [c for c in changes if not c.is_breaking]
-    if breaking:
-        bump = "major"
-    elif non_breaking:
-        bump = "minor"
-    else:
-        bump = "none"
-    return {
-        "bump": bump,
-        "is_breaking": bool(breaking),
-        "counts": {
-            "breaking": len(breaking),
-            "non_breaking": len(non_breaking),
-            "total": len(changes),
-        },
-    }
-
-
-def _bump_semver_version(current: str, bump: str) -> Optional[str]:
-    """Minimal semver bump for JSON Schema path (core.semver_classifier
-    only understands OpenAPI ChangeType enums)."""
-    if not current:
-        return None
-    try:
-        parts = current.lstrip("v").split(".")
-        major, minor, patch = (int(parts[0]), int(parts[1]), int(parts[2]))
-    except Exception:
-        return None
-    if bump == "major":
-        return f"{major + 1}.0.0"
-    if bump == "minor":
-        return f"{major}.{minor + 1}.0"
-    if bump == "patch":
-        return f"{major}.{minor}.{patch + 1}"
-    return current
-
-
-def _run_json_schema_lint(
-    old_doc: Dict[str, Any],
-    new_doc: Dict[str, Any],
-    current_version: Optional[str] = None,
-    api_name: Optional[str] = None,
-) -> Dict[str, Any]:
-    """Build an evaluate_with_policy-compatible result for JSON Schema.
-
-    Policy rules in Delimit are defined against OpenAPI ChangeType values,
-    so they do not apply here. We return zero violations and rely on the
-    breaking-change count + semver bump to drive the governance gate.
-    """
-    from core.json_schema_diff import JSONSchemaDiffEngine
-
-    engine = JSONSchemaDiffEngine()
-    changes = engine.compare(old_doc, new_doc)
-    semver = _json_schema_semver(changes)
-
-    if current_version:
-        semver["current_version"] = current_version
-        semver["next_version"] = _bump_semver_version(current_version, semver["bump"])
-
-    breaking_count = semver["counts"]["breaking"]
-    total = semver["counts"]["total"]
-
-    decision = "pass"
-    exit_code = 0
-    # No policy rules apply to JSON Schema, but breaking changes still
-    # flag MAJOR semver and the downstream gate uses that to block.
-    # Mirror the shape of evaluate_with_policy so the action/CLI renderers
-    # need no JSON Schema-specific branch.
-    result: Dict[str, Any] = {
-        "spec_type": "json_schema",
-        "api_name": api_name or new_doc.get("title") or old_doc.get("title") or "JSON Schema",
-        "decision": decision,
-        "exit_code": exit_code,
-        "violations": [],
-        "summary": {
-            "total_changes": total,
-            "breaking_changes": breaking_count,
-            "violations": 0,
-            "errors": 0,
-            "warnings": 0,
-        },
-        "all_changes": [
-            {
-                "type": c.type.value,
-                "path": c.path,
-                "message": c.message,
-                "is_breaking": c.is_breaking,
-            }
-            for c in changes
-        ],
-        "semver": semver,
-    }
-    return result
-
-
 def _read_jsonl(path: Path) -> List[Dict[str, Any]]:
     """Read JSONL entries from a file, skipping malformed lines."""
     items: List[Dict[str, Any]] = []
@@ -247,51 +115,29 @@ def run_lint(old_spec: str, new_spec: str, policy_file: Optional[str] = None) ->
     """Run the full lint pipeline: diff + policy evaluation.
 
     This is the Tier 1 primary tool — combines diff detection with
-    policy enforcement into a single pass/fail decision. Auto-detects
-    spec type (OpenAPI vs JSON Schema, LED-713) and dispatches to the
-    matching engine.
+    policy enforcement into a single pass/fail decision.
     """
     from core.policy_engine import evaluate_with_policy
 
     old = _load_specs(old_spec)
     new = _load_specs(new_spec)
 
-    # LED-713: JSON Schema dispatch. Policy rules are OpenAPI-specific,
-    # so JSON Schema takes the no-policy (breaking-count + semver) path.
-    if _spec_type(new) == "json_schema" or _spec_type(old) == "json_schema":
-        return _run_json_schema_lint(old, new)
-
     return evaluate_with_policy(old, new, policy_file)
 
 
 def run_diff(old_spec: str, new_spec: str) -> Dict[str, Any]:
-    """Run diff engine only — no policy evaluation.
+    """Run diff engine only — no policy evaluation."""
+    from core.diff_engine_v2 import OpenAPIDiffEngine
 
-    Auto-detects OpenAPI vs JSON Schema and dispatches (LED-713).
-    """
     old = _load_specs(old_spec)
     new = _load_specs(new_spec)
 
-    if _spec_type(new) == "json_schema" or _spec_type(old) == "json_schema":
-        from core.json_schema_diff import JSONSchemaDiffEngine
-        engine = JSONSchemaDiffEngine()
-        changes = engine.compare(old, new)
-        breaking = [c for c in changes if c.is_breaking]
-        return {
-            "spec_type": "json_schema",
-            "total_changes": len(changes),
-            "breaking_changes": len(breaking),
-            "changes": _json_schema_changes_to_dicts(changes),
-        }
-
-    from core.diff_engine_v2 import OpenAPIDiffEngine
     engine = OpenAPIDiffEngine()
     changes = engine.compare(old, new)
 
     breaking = [c for c in changes if c.is_breaking]
 
     return {
-        "spec_type": "openapi",
         "total_changes": len(changes),
         "breaking_changes": len(breaking),
         "changes": [
@@ -318,20 +164,13 @@ def run_changelog(
     Uses the diff engine to detect changes, then formats them into
     a human-readable changelog grouped by category.
     """
+    from core.diff_engine_v2 import OpenAPIDiffEngine
     from datetime import datetime, timezone
 
     old = _load_specs(old_spec)
     new = _load_specs(new_spec)
 
-    # LED-713: dispatch on spec type. JSONSchemaChange / Change share the
-    # (.type.value, .path, .message, .is_breaking) duck type.
-    if _spec_type(new) == "json_schema" or _spec_type(old) == "json_schema":
-        from core.json_schema_diff import JSONSchemaDiffEngine
-        engine = JSONSchemaDiffEngine()
-    else:
-        from core.diff_engine_v2 import OpenAPIDiffEngine
-        engine = OpenAPIDiffEngine()
-
+    engine = OpenAPIDiffEngine()
     changes = engine.compare(old, new)
 
     # Categorize changes
@@ -969,26 +808,14 @@ def run_semver(
     """Classify the semver bump for a spec change.
 
     Returns detailed breakdown: bump level, per-category counts,
-    and optionally the bumped version string. Auto-detects OpenAPI vs
-    JSON Schema (LED-713).
+    and optionally the bumped version string.
     """
-    old = _load_specs(old_spec)
-    new = _load_specs(new_spec)
-
-    # LED-713: JSON Schema path
-    if _spec_type(new) == "json_schema" or _spec_type(old) == "json_schema":
-        from core.json_schema_diff import JSONSchemaDiffEngine
-        engine = JSONSchemaDiffEngine()
-        changes = engine.compare(old, new)
-        result = _json_schema_semver(changes)
-        if current_version:
-            result["current_version"] = current_version
-            result["next_version"] = _bump_semver_version(current_version, result["bump"])
-        return result
-
     from core.diff_engine_v2 import OpenAPIDiffEngine
     from core.semver_classifier import classify_detailed, bump_version, classify
 
+    old = _load_specs(old_spec)
+    new = _load_specs(new_spec)
+
     engine = OpenAPIDiffEngine()
     changes = engine.compare(old, new)
     result = classify_detailed(changes)
@@ -1119,6 +946,7 @@ def run_diff_report(
     """
     from datetime import datetime, timezone
 
+    from core.diff_engine_v2 import OpenAPIDiffEngine
     from core.policy_engine import PolicyEngine
     from core.semver_classifier import classify_detailed, classify
     from core.spec_health import score_spec
@@ -1127,43 +955,6 @@ def run_diff_report(
     old = _load_specs(old_spec)
     new = _load_specs(new_spec)
 
-    # LED-713: JSON Schema dispatch — short-circuit to a minimal report
-    # shape compatible with the JSON renderer (HTML renderer remains
-    # OpenAPI-only; JSON Schema callers should use fmt="json").
-    if _spec_type(new) == "json_schema" or _spec_type(old) == "json_schema":
-        from core.json_schema_diff import JSONSchemaDiffEngine
-        js_engine = JSONSchemaDiffEngine()
-        js_changes = js_engine.compare(old, new)
-        js_breaking = [c for c in js_changes if c.is_breaking]
-        js_semver = _json_schema_semver(js_changes)
-        now_js = datetime.now(timezone.utc)
-        return {
-            "format": fmt,
-            "spec_type": "json_schema",
-            "generated_at": now_js.isoformat(),
-            "old_spec": old_spec,
-            "new_spec": new_spec,
-            "old_title": old.get("title", "") if isinstance(old, dict) else "",
-            "new_title": new.get("title", "") if isinstance(new, dict) else "",
-            "semver": js_semver,
-            "changes": _json_schema_changes_to_dicts(js_changes),
-            "breaking_count": len(js_breaking),
-            "non_breaking_count": len(js_changes) - len(js_breaking),
-            "total_changes": len(js_changes),
-            "policy": {
-                "decision": "pass",
-                "violations": [],
-                "errors": 0,
-                "warnings": 0,
-            },
-            "health": None,
-            "migration": "",
-            "output_file": output_file,
-            "note": "JSON Schema report (policy rules and HTML report are OpenAPI-only in v1)",
-        }
-
-    from core.diff_engine_v2 import OpenAPIDiffEngine
-
     # -- Diff --
     engine = OpenAPIDiffEngine()
     changes = engine.compare(old, new)

package/gateway/ai/backends/repo_bridge.py

@@ -158,80 +158,21 @@ def config_audit(target: str = ".", options: Optional[Dict] = None) -> Dict[str,
 # ─── EvidencePack ───────────────────────────────────────────────────────
 
 def evidence_collect(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
-    """Collect project evidence: git log, test files, configs, governance data.
-
-    Accepts either a local filesystem path (repo directory) or a remote
-    reference (GitHub URL, owner/repo#N, or any non-filesystem string).
-    Remote targets skip the filesystem walk and store reference metadata.
-    """
-    import re
-    import subprocess
-    import time as _time
-
-    opts = options or {}
-    evidence_type = opts.get("evidence_type", "")
-
-    # Detect non-filesystem targets: URLs, owner/repo#N, bare issue refs, etc.
-    is_remote = (
-        "://" in target
-        or target.startswith("http")
-        or re.match(r"^[\w.-]+/[\w.-]+#\d+$", target) is not None
-        or "#" in target
-    )
-
-    evidence: Dict[str, Any] = {"collected_at": _time.time(), "target": target}
-    if evidence_type:
-        evidence["evidence_type"] = evidence_type
-
-    if is_remote:
-        # Remote/reference target — no filesystem walk, just record metadata.
-        evidence["target_type"] = "remote"
+    """Collect project evidence: git log, test files, configs, governance data."""
+    import subprocess, time as _time
+    root = Path(target).resolve()
+    evidence: Dict[str, Any] = {"collected_at": _time.time(), "target": str(root)}
+    # Git log
+    try:
+        r = subprocess.run(["git", "-C", str(root), "log", "--oneline", "-10"], capture_output=True, text=True, timeout=10)
+        evidence["git_log"] = r.stdout.strip().splitlines() if r.returncode == 0 else []
+    except Exception:
         evidence["git_log"] = []
-        evidence["test_directories"] = []
-        evidence["configs"] = []
-        m = re.match(r"^([\w.-]+)/([\w.-]+)#(\d+)$", target)
-        if m:
-            evidence["repo"] = f"{m.group(1)}/{m.group(2)}"
-            evidence["issue_number"] = int(m.group(3))
-    else:
-        root = Path(target).resolve()
-        evidence["target"] = str(root)
-        evidence["target_type"] = "local"
-
-        if not root.exists():
-            return {
-                "tool": "evidence.collect",
-                "status": "error",
-                "error": "target_not_found",
-                "message": f"Path {root} does not exist. For remote targets, pass a URL or owner/repo#N.",
-                "target": target,
-            }
-
-        # Git log (safe for non-git dirs)
-        try:
-            r = subprocess.run(
-                ["git", "-C", str(root), "log", "--oneline", "-10"],
-                capture_output=True, text=True, timeout=10,
-            )
-            evidence["git_log"] = r.stdout.strip().splitlines() if r.returncode == 0 else []
-        except Exception:
-            evidence["git_log"] = []
-
-        # Test dirs + configs (only if target is a directory)
-        if root.is_dir():
-            test_dirs = [d for d in ["tests", "test", "__tests__", "spec"] if (root / d).exists()]
-            evidence["test_directories"] = test_dirs
-            try:
-                evidence["configs"] = [
-                    f.name for f in root.iterdir()
-                    if f.is_file() and (f.suffix in [".json", ".yaml", ".yml", ".toml"] or f.name.startswith("."))
-                ]
-            except (PermissionError, OSError):
-                evidence["configs"] = []
-        else:
-            evidence["test_directories"] = []
-            evidence["configs"] = []
-
+    # Test files
+    test_dirs = [d for d in ["tests", "test", "__tests__", "spec"] if (root / d).exists()]
+    evidence["test_directories"] = test_dirs
+    # Configs
+    evidence["configs"] = [f.name for f in root.iterdir() if f.is_file() and (f.suffix in [".json", ".yaml", ".yml", ".toml"] or f.name.startswith("."))]
     # Save bundle
     ev_dir = Path(os.environ.get("DELIMIT_HOME", str(Path.home() / ".delimit"))) / "evidence"
     ev_dir.mkdir(parents=True, exist_ok=True)
@@ -239,13 +180,8 @@ def evidence_collect(target: str = ".", options: Optional[Dict] = None) -> Dict[
     bundle_path = ev_dir / f"{bundle_id}.json"
     evidence["bundle_id"] = bundle_id
     bundle_path.write_text(json.dumps(evidence, indent=2))
-    return {
-        "tool": "evidence.collect",
-        "status": "ok",
-        "bundle_id": bundle_id,
-        "bundle_path": str(bundle_path),
-        "summary": {k: len(v) if isinstance(v, list) else v for k, v in evidence.items()},
-    }
+    return {"tool": "evidence.collect", "status": "ok", "bundle_id": bundle_id,
+            "bundle_path": str(bundle_path), "summary": {k: len(v) if isinstance(v, list) else v for k, v in evidence.items()}}
 
 
 def evidence_verify(bundle_id: Optional[str] = None, bundle_path: Optional[str] = None, options: Optional[Dict] = None) -> Dict[str, Any]:

package/gateway/core/spec_detector.py

@@ -3,7 +3,7 @@ Automatic OpenAPI specification detector for zero-config installation.
 """
 
 import os
-from typing import Any, List, Optional, Tuple
+from typing import List, Optional, Tuple
 from pathlib import Path
 import yaml
 
@@ -77,7 +77,7 @@ class SpecDetector:
         """Check if file is a valid OpenAPI specification."""
         if not file_path.is_file():
             return False
-
+        
         try:
             with open(file_path, 'r') as f:
                 data = yaml.safe_load(f)
@@ -86,66 +86,26 @@ class SpecDetector:
                     return 'openapi' in data or 'swagger' in data
         except:
             return False
-
+        
         return False
-
+    
     def get_default_specs(self) -> Tuple[Optional[str], Optional[str]]:
         """
         Get default old_spec and new_spec for auto-detection.
-
+        
         Returns:
             (old_spec, new_spec): Paths or None if not found
         """
         specs, _ = self.detect_specs()
-
+        
         if len(specs) == 0:
             return None, None
-
+        
         # Use the first found spec as both old and new (baseline mode)
         default_spec = specs[0]
         return default_spec, default_spec
 
 
-def detect_spec_type(doc: Any) -> str:
-    """Classify a parsed spec document for engine dispatch (LED-713).
-
-    Returns:
-        "openapi"      — OpenAPI 3.x / Swagger 2.x (route to OpenAPIDiffEngine)
-        "json_schema"  — bare JSON Schema Draft 4+ (route to JSONSchemaDiffEngine)
-        "unknown"      — no recognized markers
-    """
-    if not isinstance(doc, dict):
-        return "unknown"
-    if "openapi" in doc or "swagger" in doc or "paths" in doc:
-        return "openapi"
-    # JSON Schema markers: $schema URL, top-level definitions, or ref-shim root
-    schema_url = doc.get("$schema")
-    if isinstance(schema_url, str) and "json-schema.org" in schema_url:
-        return "json_schema"
-    if isinstance(doc.get("definitions"), dict):
-        return "json_schema"
-    ref = doc.get("$ref")
-    if isinstance(ref, str) and ref.startswith("#/definitions/"):
-        return "json_schema"
-    return "unknown"
-
-
-def get_diff_engine(doc: Any):
-    """Factory: return the right diff engine instance for a parsed doc.
-
-    Callers: action.yml inline Python, policy_engine, npm-delimit api-engine.
-    The returned engine exposes .compare(old, new) -> List[Change].
-    """
-    spec_type = detect_spec_type(doc)
-    if spec_type == "json_schema":
-        from .json_schema_diff import JSONSchemaDiffEngine
-        return JSONSchemaDiffEngine()
-    # Default to OpenAPI for "openapi" and "unknown" (back-compat: existing
-    # specs without explicit markers still hit the OpenAPI engine)
-    from .diff_engine_v2 import OpenAPIDiffEngine
-    return OpenAPIDiffEngine()
-
-
 def auto_detect_specs(root_path: str = ".") -> dict:
     """
     Main entry point for spec auto-detection.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "delimit-cli",
   "mcpName": "io.github.delimit-ai/delimit-mcp-server",
-  "version": "4.1.49",
+  "version": "4.1.50",
   "description": "Unify Claude Code, Codex, Cursor, and Gemini CLI with persistent context, governance, and multi-model debate.",
   "main": "index.js",
   "files": [

package/gateway/core/generator_drift.py

@@ -1,242 +0,0 @@
-"""Generator drift detection (LED-713).
-
-Detects when a committed generated artifact (e.g. agentspec's
-schemas/v1/agent.schema.json regenerated from a Zod source) has drifted
-from what its generator script would produce today.
-
-Use case: a maintainer changes the source of truth (Zod schema, OpenAPI
-generator, protobuf, etc.) but forgets to regenerate and commit the
-artifact. CI catches the drift before the stale generated file ships.
-
-Generic over generators — caller supplies the regen command and the
-artifact path. Returns a structured drift report that can be merged into
-the standard delimit-action PR comment.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import shlex
-import shutil
-import subprocess
-import tempfile
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-
-@dataclass
-class DriftResult:
-    drifted: bool
-    artifact_path: str
-    regen_command: str
-    changes: List[Any] = field(default_factory=list)  # JSONSchemaChange list when drift detected
-    error: Optional[str] = None
-    runtime_seconds: float = 0.0
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "drifted": self.drifted,
-            "artifact_path": self.artifact_path,
-            "regen_command": self.regen_command,
-            "change_count": len(self.changes),
-            "changes": [
-                {
-                    "type": c.type.value,
-                    "path": c.path,
-                    "message": c.message,
-                    "is_breaking": c.is_breaking,
-                }
-                for c in self.changes
-            ],
-            "error": self.error,
-            "runtime_seconds": round(self.runtime_seconds, 3),
-        }
-
-
-def detect_drift(
-    repo_root: str,
-    artifact_path: str,
-    regen_command: str,
-    timeout_seconds: int = 60,
-) -> DriftResult:
-    """Check whether the committed artifact matches its generator output.
-
-    Args:
-        repo_root: Absolute path to the repo checkout.
-        artifact_path: Path to the generated artifact, relative to repo_root.
-        regen_command: Shell command that regenerates the artifact in place.
-            Example: "pnpm -r run build" or "node packages/sdk/dist/scripts/export-schema.js"
-        timeout_seconds: Hard timeout for the generator (default 60).
-
-    Returns:
-        DriftResult with drift status, classified changes, and runtime.
-    """
-    import time
-
-    repo_root_p = Path(repo_root).resolve()
-    artifact_p = (repo_root_p / artifact_path).resolve()
-
-    if not artifact_p.exists():
-        return DriftResult(
-            drifted=False,
-            artifact_path=artifact_path,
-            regen_command=regen_command,
-            error=f"Artifact not found: {artifact_path}",
-        )
-
-    # Snapshot the committed artifact before regen
-    try:
-        committed_text = artifact_p.read_text()
-        committed_doc = json.loads(committed_text)
-    except (OSError, json.JSONDecodeError) as e:
-        return DriftResult(
-            drifted=False,
-            artifact_path=artifact_path,
-            regen_command=regen_command,
-            error=f"Failed to read committed artifact: {e}",
-        )
-
-    # Parse the command safely — shell=False to avoid command injection.
-    # Users needing shell features (&&, |, env vars, etc.) should point
-    # generator_command at a script file instead of an inline chain.
-    try:
-        argv = shlex.split(regen_command)
-    except ValueError as e:
-        return DriftResult(
-            drifted=False,
-            artifact_path=artifact_path,
-            regen_command=regen_command,
-            error=f"Could not parse generator_command: {e}",
-        )
-    if not argv:
-        return DriftResult(
-            drifted=False,
-            artifact_path=artifact_path,
-            regen_command=regen_command,
-            error="generator_command is empty",
-        )
-    # Reject obvious shell metacharacters — force users to use a script
-    # file if they need chaining or redirection.
-    SHELL_META = set("&|;><`$")
-    if any(ch in token for token in argv for ch in SHELL_META):
-        return DriftResult(
-            drifted=False,
-            artifact_path=artifact_path,
-            regen_command=regen_command,
-            error="generator_command contains shell metacharacters (&|;><`$). Point it at a script file instead of chaining inline.",
-        )
-
-    # Run the regenerator
-    start = time.time()
-    try:
-        result = subprocess.run(
-            argv,
-            shell=False,
-            cwd=str(repo_root_p),
-            capture_output=True,
-            text=True,
-            timeout=timeout_seconds,
-        )
-    except subprocess.TimeoutExpired:
-        return DriftResult(
-            drifted=False,
-            artifact_path=artifact_path,
-            regen_command=regen_command,
-            error=f"Generator timed out after {timeout_seconds}s",
-            runtime_seconds=time.time() - start,
-        )
-    except FileNotFoundError as e:
-        return DriftResult(
-            drifted=False,
-            artifact_path=artifact_path,
-            regen_command=regen_command,
-            error=f"Generator executable not found: {e}",
-            runtime_seconds=time.time() - start,
-        )
-
-    runtime = time.time() - start
-
-    if result.returncode != 0:
-        return DriftResult(
-            drifted=False,
-            artifact_path=artifact_path,
-            regen_command=regen_command,
-            error=f"Generator exited {result.returncode}: {result.stderr.strip()[:500]}",
-            runtime_seconds=runtime,
-        )
-
-    # Read the regenerated artifact
-    try:
-        regen_text = artifact_p.read_text()
-        regen_doc = json.loads(regen_text)
-    except (OSError, json.JSONDecodeError) as e:
-        # Restore committed version so we don't leave the workspace dirty
-        artifact_p.write_text(committed_text)
-        return DriftResult(
-            drifted=False,
-            artifact_path=artifact_path,
-            regen_command=regen_command,
-            error=f"Failed to read regenerated artifact: {e}",
-            runtime_seconds=runtime,
-        )
-
-    # Restore the committed file before diffing — leave the workspace clean
-    artifact_p.write_text(committed_text)
-
-    # Quick equality check first
-    if committed_doc == regen_doc:
-        return DriftResult(
-            drifted=False,
-            artifact_path=artifact_path,
-            regen_command=regen_command,
-            runtime_seconds=runtime,
-        )
-
-    # Drift detected — classify the changes via the JSON Schema diff engine
-    from .json_schema_diff import JSONSchemaDiffEngine
-
-    engine = JSONSchemaDiffEngine()
-    changes = engine.compare(committed_doc, regen_doc)
-    return DriftResult(
-        drifted=True,
-        artifact_path=artifact_path,
-        regen_command=regen_command,
-        changes=changes,
-        runtime_seconds=runtime,
-    )
-
-
-def format_drift_report(result: DriftResult) -> str:
-    """Render a drift report as a markdown block for PR comments."""
-    if result.error:
-        return (
-            f"### Generator drift check\n\n"
-            f"Artifact: `{result.artifact_path}`  \n"
-            f"Status: error  \n"
-            f"Detail: {result.error}\n"
-        )
-    if not result.drifted:
-        return (
-            f"### Generator drift check\n\n"
-            f"Artifact: `{result.artifact_path}`  \n"
-            f"Status: clean (committed artifact matches generator output)  \n"
-            f"Generator runtime: {result.runtime_seconds:.2f}s\n"
-        )
-    breaking = sum(1 for c in result.changes if c.is_breaking)
-    non_breaking = len(result.changes) - breaking
-    lines = [
-        "### Generator drift check",
-        "",
-        f"Artifact: `{result.artifact_path}`  ",
-        f"Status: drifted ({len(result.changes)} change(s) — {breaking} breaking, {non_breaking} non-breaking)  ",
-        f"Generator runtime: {result.runtime_seconds:.2f}s  ",
-        "",
-        "The committed artifact does not match what the generator produces today. Re-run the generator and commit the result, or revert the source change.",
-        "",
-    ]
-    for c in result.changes:
-        marker = "breaking" if c.is_breaking else "ok"
-        lines.append(f"- [{marker}] {c.type.value} at `{c.path}` — {c.message}")
-    return "\n".join(lines) + "\n"

package/gateway/core/json_schema_diff.py

@@ -1,375 +0,0 @@
-"""
-JSON Schema diff engine (LED-713).
-
-Sibling to core/diff_engine_v2.py. Handles bare JSON Schema files
-(Draft 4+), resolving internal $ref to #/definitions. Deliberately
-excludes anyOf/oneOf/allOf composition, external refs, discriminators,
-and if/then/else — those are deferred past v1.
-
-Dispatched from spec_detector when a file contains a top-level
-"$schema" key or a top-level "definitions" key without OpenAPI markers.
-
-Designed for the agents-oss/agentspec integration (issue #21) but
-general across any single-file JSON Schema.
-"""
-
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any, Dict, List, Optional
-
-
-class JSONSchemaChangeType(Enum):
-    # Breaking
-    PROPERTY_REMOVED = "property_removed"
-    REQUIRED_ADDED = "required_added"
-    TYPE_NARROWED = "type_narrowed"
-    ENUM_VALUE_REMOVED = "enum_value_removed"
-    CONST_CHANGED = "const_changed"
-    ADDITIONAL_PROPERTIES_TIGHTENED = "additional_properties_tightened"
-    PATTERN_TIGHTENED = "pattern_tightened"
-    MIN_LENGTH_INCREASED = "min_length_increased"
-    MAX_LENGTH_DECREASED = "max_length_decreased"
-    MINIMUM_INCREASED = "minimum_increased"
-    MAXIMUM_DECREASED = "maximum_decreased"
-    ITEMS_TYPE_NARROWED = "items_type_narrowed"
-
-    # Non-breaking
-    PROPERTY_ADDED = "property_added"
-    REQUIRED_REMOVED = "required_removed"
-    TYPE_WIDENED = "type_widened"
-    ENUM_VALUE_ADDED = "enum_value_added"
-    ADDITIONAL_PROPERTIES_LOOSENED = "additional_properties_loosened"
-    PATTERN_LOOSENED = "pattern_loosened"
-    MIN_LENGTH_DECREASED = "min_length_decreased"
-    MAX_LENGTH_INCREASED = "max_length_increased"
-    MINIMUM_DECREASED = "minimum_decreased"
-    MAXIMUM_INCREASED = "maximum_increased"
-    ITEMS_TYPE_WIDENED = "items_type_widened"
-    DESCRIPTION_CHANGED = "description_changed"
-
-
-_BREAKING_TYPES = {
-    JSONSchemaChangeType.PROPERTY_REMOVED,
-    JSONSchemaChangeType.REQUIRED_ADDED,
-    JSONSchemaChangeType.TYPE_NARROWED,
-    JSONSchemaChangeType.ENUM_VALUE_REMOVED,
-    JSONSchemaChangeType.CONST_CHANGED,
-    JSONSchemaChangeType.ADDITIONAL_PROPERTIES_TIGHTENED,
-    JSONSchemaChangeType.PATTERN_TIGHTENED,
-    JSONSchemaChangeType.MIN_LENGTH_INCREASED,
-    JSONSchemaChangeType.MAX_LENGTH_DECREASED,
-    JSONSchemaChangeType.MINIMUM_INCREASED,
-    JSONSchemaChangeType.MAXIMUM_DECREASED,
-    JSONSchemaChangeType.ITEMS_TYPE_NARROWED,
-}
-
-
-@dataclass
-class JSONSchemaChange:
-    type: JSONSchemaChangeType
-    path: str
-    details: Dict[str, Any] = field(default_factory=dict)
-    message: str = ""
-
-    @property
-    def is_breaking(self) -> bool:
-        return self.type in _BREAKING_TYPES
-
-    @property
-    def severity(self) -> str:
-        return "high" if self.is_breaking else "low"
-
-
-# Type widening hierarchy: a change from "integer" to "number" is widening
-# (non-breaking for consumers). The reverse narrows and is breaking.
-_TYPE_SUPERSETS = {
-    "number": {"integer"},
-}
-
-
-def _is_type_widening(old: str, new: str) -> bool:
-    return old in _TYPE_SUPERSETS.get(new, set())
-
-
-def _is_type_narrowing(old: str, new: str) -> bool:
-    return new in _TYPE_SUPERSETS.get(old, set())
-
-
-class JSONSchemaDiffEngine:
-    """Compare two JSON Schema documents.
-
-    Handles internal $ref to #/definitions by resolving refs against the
-    document's own definitions block during traversal. External refs
-    (http://, file://) are out of scope for v1.
-    """
-
-    def __init__(self) -> None:
-        self.changes: List[JSONSchemaChange] = []
-        self._old_defs: Dict[str, Any] = {}
-        self._new_defs: Dict[str, Any] = {}
-
-    # ------------------------------------------------------------------
-    # public API
-    # ------------------------------------------------------------------
-
-    def compare(self, old_schema: Dict[str, Any], new_schema: Dict[str, Any]) -> List[JSONSchemaChange]:
-        self.changes = []
-        old_schema = old_schema or {}
-        new_schema = new_schema or {}
-        self._old_defs = old_schema.get("definitions", {}) or {}
-        self._new_defs = new_schema.get("definitions", {}) or {}
-
-        # If the root is a $ref shim (common pattern: {"$ref": "#/definitions/Foo", "definitions": {...}})
-        # unwrap both sides so we diff the actual shape.
-        old_root = self._resolve(old_schema, self._old_defs)
-        new_root = self._resolve(new_schema, self._new_defs)
-
-        self._compare_schema(old_root, new_root, path="")
-        return self.changes
-
-    # ------------------------------------------------------------------
-    # $ref resolution
-    # ------------------------------------------------------------------
-
-    def _resolve(self, node: Any, defs: Dict[str, Any]) -> Any:
-        """Resolve internal $ref to #/definitions. Returns node unchanged otherwise."""
-        if not isinstance(node, dict):
-            return node
-        ref = node.get("$ref")
-        if not ref or not isinstance(ref, str) or not ref.startswith("#/definitions/"):
-            return node
-        key = ref[len("#/definitions/"):]
-        resolved = defs.get(key)
-        if resolved is None:
-            return node
-        # Merge sibling keys from the ref node (e.g. description) onto the resolved.
-        merged = dict(resolved)
-        for k, v in node.items():
-            if k != "$ref":
-                merged.setdefault(k, v)
-        return merged
-
-    # ------------------------------------------------------------------
-    # recursive traversal
-    # ------------------------------------------------------------------
-
-    def _compare_schema(self, old: Any, new: Any, path: str) -> None:
-        if not isinstance(old, dict) or not isinstance(new, dict):
-            return
-        old = self._resolve(old, self._old_defs)
-        new = self._resolve(new, self._new_defs)
-
-        self._compare_type(old, new, path)
-        self._compare_const(old, new, path)
-        self._compare_enum(old, new, path)
-        self._compare_pattern(old, new, path)
-        self._compare_numeric_bounds(old, new, path)
-        self._compare_string_length(old, new, path)
-        self._compare_additional_properties(old, new, path)
-        self._compare_required(old, new, path)
-        self._compare_properties(old, new, path)
-        self._compare_items(old, new, path)
-
-    # ------------------------------------------------------------------
-    # individual comparisons
-    # ------------------------------------------------------------------
-
-    def _compare_type(self, old: Dict, new: Dict, path: str) -> None:
-        old_t = old.get("type")
-        new_t = new.get("type")
-        if old_t == new_t or old_t is None or new_t is None:
-            return
-        if isinstance(old_t, str) and isinstance(new_t, str):
-            if _is_type_widening(old_t, new_t):
-                self._add(JSONSchemaChangeType.TYPE_WIDENED, path,
-                          {"old": old_t, "new": new_t},
-                          f"Type widened at {path or '/'}: {old_t} → {new_t}")
-                return
-            if _is_type_narrowing(old_t, new_t):
-                self._add(JSONSchemaChangeType.TYPE_NARROWED, path,
-                          {"old": old_t, "new": new_t},
-                          f"Type narrowed at {path or '/'}: {old_t} → {new_t}")
-                return
-            # Unrelated type change — treat as narrowing (breaking)
-            self._add(JSONSchemaChangeType.TYPE_NARROWED, path,
-                      {"old": old_t, "new": new_t},
-                      f"Type changed at {path or '/'}: {old_t} → {new_t}")
-
-    def _compare_const(self, old: Dict, new: Dict, path: str) -> None:
-        if "const" in old and "const" in new and old["const"] != new["const"]:
-            self._add(JSONSchemaChangeType.CONST_CHANGED, path,
-                      {"old": old["const"], "new": new["const"]},
-                      f"const value changed at {path or '/'}: {old['const']!r} → {new['const']!r}")
-
-    def _compare_enum(self, old: Dict, new: Dict, path: str) -> None:
-        old_enum = old.get("enum")
-        new_enum = new.get("enum")
-        if not isinstance(old_enum, list) or not isinstance(new_enum, list):
-            return
-        old_set = {repr(v) for v in old_enum}
-        new_set = {repr(v) for v in new_enum}
-        for removed in old_set - new_set:
-            self._add(JSONSchemaChangeType.ENUM_VALUE_REMOVED, path,
-                      {"value": removed},
-                      f"enum value removed at {path or '/'}: {removed}")
-        for added in new_set - old_set:
-            self._add(JSONSchemaChangeType.ENUM_VALUE_ADDED, path,
-                      {"value": added},
-                      f"enum value added at {path or '/'}: {added}")
-
-    def _compare_pattern(self, old: Dict, new: Dict, path: str) -> None:
-        old_p = old.get("pattern")
-        new_p = new.get("pattern")
-        if old_p == new_p or (old_p is None and new_p is None):
-            return
-        # We can't prove regex subset relationships, so any pattern change
-        # on an existing constraint is conservatively breaking; adding a
-        # brand-new pattern is breaking; removing a pattern is non-breaking.
-        if old_p and not new_p:
-            self._add(JSONSchemaChangeType.PATTERN_LOOSENED, path,
-                      {"old": old_p},
-                      f"pattern removed at {path or '/'}: {old_p}")
-        elif not old_p and new_p:
-            self._add(JSONSchemaChangeType.PATTERN_TIGHTENED, path,
-                      {"new": new_p},
-                      f"pattern added at {path or '/'}: {new_p}")
-        else:
-            self._add(JSONSchemaChangeType.PATTERN_TIGHTENED, path,
-                      {"old": old_p, "new": new_p},
-                      f"pattern changed at {path or '/'}: {old_p} → {new_p}")
-
-    def _compare_numeric_bounds(self, old: Dict, new: Dict, path: str) -> None:
-        for key, tight_type, loose_type in (
-            ("minimum", JSONSchemaChangeType.MINIMUM_INCREASED, JSONSchemaChangeType.MINIMUM_DECREASED),
-            ("maximum", JSONSchemaChangeType.MAXIMUM_DECREASED, JSONSchemaChangeType.MAXIMUM_INCREASED),
-        ):
-            old_v = old.get(key)
-            new_v = new.get(key)
-            if old_v is None or new_v is None or old_v == new_v:
-                continue
-            try:
-                delta = float(new_v) - float(old_v)
-            except (TypeError, ValueError):
-                continue
-            if key == "minimum":
-                if delta > 0:
-                    self._add(tight_type, path, {"old": old_v, "new": new_v},
-                              f"minimum increased at {path or '/'}: {old_v} → {new_v}")
-                else:
-                    self._add(loose_type, path, {"old": old_v, "new": new_v},
-                              f"minimum decreased at {path or '/'}: {old_v} → {new_v}")
-            else:  # maximum
-                if delta < 0:
-                    self._add(tight_type, path, {"old": old_v, "new": new_v},
-                              f"maximum decreased at {path or '/'}: {old_v} → {new_v}")
-                else:
-                    self._add(loose_type, path, {"old": old_v, "new": new_v},
-                              f"maximum increased at {path or '/'}: {old_v} → {new_v}")
-
-    def _compare_string_length(self, old: Dict, new: Dict, path: str) -> None:
-        for key, tight_type, loose_type in (
-            ("minLength", JSONSchemaChangeType.MIN_LENGTH_INCREASED, JSONSchemaChangeType.MIN_LENGTH_DECREASED),
-            ("maxLength", JSONSchemaChangeType.MAX_LENGTH_DECREASED, JSONSchemaChangeType.MAX_LENGTH_INCREASED),
-        ):
-            old_v = old.get(key)
-            new_v = new.get(key)
-            if old_v is None or new_v is None or old_v == new_v:
-                continue
-            if key == "minLength":
-                if new_v > old_v:
-                    self._add(tight_type, path, {"old": old_v, "new": new_v},
-                              f"minLength increased at {path or '/'}: {old_v} → {new_v}")
-                else:
-                    self._add(loose_type, path, {"old": old_v, "new": new_v},
-                              f"minLength decreased at {path or '/'}: {old_v} → {new_v}")
-            else:  # maxLength
-                if new_v < old_v:
-                    self._add(tight_type, path, {"old": old_v, "new": new_v},
-                              f"maxLength decreased at {path or '/'}: {old_v} → {new_v}")
-                else:
-                    self._add(loose_type, path, {"old": old_v, "new": new_v},
-                              f"maxLength increased at {path or '/'}: {old_v} → {new_v}")
-
-    def _compare_additional_properties(self, old: Dict, new: Dict, path: str) -> None:
-        old_ap = old.get("additionalProperties")
-        new_ap = new.get("additionalProperties")
-        # Default in JSON Schema is True (additional allowed). Only flag
-        # explicit transitions that change the answer.
-        if old_ap is None and new_ap is None:
-            return
-        old_allows = True if old_ap is None else bool(old_ap)
-        new_allows = True if new_ap is None else bool(new_ap)
-        if old_allows and not new_allows:
-            self._add(JSONSchemaChangeType.ADDITIONAL_PROPERTIES_TIGHTENED, path,
-                      {"old": old_ap, "new": new_ap},
-                      f"additionalProperties tightened at {path or '/'}: {old_ap} → {new_ap}")
-        elif not old_allows and new_allows:
-            self._add(JSONSchemaChangeType.ADDITIONAL_PROPERTIES_LOOSENED, path,
-                      {"old": old_ap, "new": new_ap},
-                      f"additionalProperties loosened at {path or '/'}: {old_ap} → {new_ap}")
-
-    def _compare_required(self, old: Dict, new: Dict, path: str) -> None:
-        old_req = set(old.get("required", []) or [])
-        new_req = set(new.get("required", []) or [])
-        for added in new_req - old_req:
-            self._add(JSONSchemaChangeType.REQUIRED_ADDED, f"{path}/required/{added}",
-                      {"field": added},
-                      f"required field added at {path or '/'}: {added}")
-        for removed in old_req - new_req:
-            self._add(JSONSchemaChangeType.REQUIRED_REMOVED, f"{path}/required/{removed}",
-                      {"field": removed},
-                      f"required field removed at {path or '/'}: {removed}")
-
-    def _compare_properties(self, old: Dict, new: Dict, path: str) -> None:
-        old_props = old.get("properties", {}) or {}
-        new_props = new.get("properties", {}) or {}
-        if not isinstance(old_props, dict) or not isinstance(new_props, dict):
-            return
-        for removed in set(old_props) - set(new_props):
-            self._add(JSONSchemaChangeType.PROPERTY_REMOVED, f"{path}/properties/{removed}",
-                      {"field": removed},
-                      f"property removed: {path or '/'}.{removed}")
-        for added in set(new_props) - set(old_props):
-            self._add(JSONSchemaChangeType.PROPERTY_ADDED, f"{path}/properties/{added}",
-                      {"field": added},
-                      f"property added: {path or '/'}.{added}")
-        for name in set(old_props) & set(new_props):
-            self._compare_schema(old_props[name], new_props[name], f"{path}/properties/{name}")
-
-    def _compare_items(self, old: Dict, new: Dict, path: str) -> None:
-        old_items = old.get("items")
-        new_items = new.get("items")
-        if not isinstance(old_items, dict) or not isinstance(new_items, dict):
-            return
-        self._compare_schema(old_items, new_items, f"{path}/items")
-
-    # ------------------------------------------------------------------
-    # helpers
-    # ------------------------------------------------------------------
-
-    def _add(self, change_type: JSONSchemaChangeType, path: str,
-             details: Dict[str, Any], message: str) -> None:
-        self.changes.append(JSONSchemaChange(
-            type=change_type, path=path or "/", details=details, message=message))
-
-
-def is_json_schema(doc: Dict[str, Any]) -> bool:
-    """Detect whether a parsed document should be routed to this engine.
-
-    Heuristic: top-level "$schema" key referencing json-schema.org, OR a
-    top-level "definitions" block without OpenAPI markers (paths, components,
-    openapi, swagger).
-    """
-    if not isinstance(doc, dict):
-        return False
-    if any(marker in doc for marker in ("openapi", "swagger", "paths")):
-        return False
-    schema_url = doc.get("$schema")
-    if isinstance(schema_url, str) and "json-schema.org" in schema_url:
-        return True
-    if "definitions" in doc and isinstance(doc["definitions"], dict):
-        return True
-    # Agentspec pattern: {"$ref": "#/definitions/...", "definitions": {...}}
-    if doc.get("$ref", "").startswith("#/definitions/"):
-        return True
-    return False