delimit-cli 4.1.50 → 4.1.51

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [4.1.51] - 2026-04-09
+
+### Fixed (gateway loop engine — LED-814)
+- **`ai/loop_engine.run_governed_iteration` mishandled swarm dispatch statuses.** Only `status=='completed'` was treated as success. The swarm dispatcher returns `'dispatched'` for async handoff, so every build-loop tick fell into the failure branch and logged "Dispatch failed" even though the underlying work shipped. Session `build-loop-2026-04-09` accumulated 6 spurious failures (LED-787 / 788 / 755 / 762 / 799 / 807) for tasks that all actually shipped. Now:
+  - `'completed'` → close ledger + notify deploy loop (unchanged)
+  - `'dispatched'` → mark ledger `in_progress` with the swarm `task_id`, NOT a failure
+  - `'blocked'` → record a founder-approval gate without tripping the circuit breaker
+  - anything else → genuine failure, error message includes the unexpected status string for debuggability
+- Verified live against the running MCP session before this release: `iterations 6→7`, `errors 0`, `LED-814` recorded as `dispatched` with `swarm_task_id task-449ecdf9`.
+- Picked up via the standard `npm run sync-gateway` step in `prepublishOnly` (gateway commit `ce802cd` is now on `delimit-ai/delimit-gateway` main).
+
+### Added
+- **`tests/test_loop_engine_dispatch_status.py`** in the gateway — covers all four dispatch status branches (`completed` / `dispatched` / `blocked` / unknown), 154 lines, ships with the bundled gateway.
+
+### Scope
+- Single-purpose patch: gateway loop engine only. This is the deferred half of the multi-model deliberation that produced 4.1.50 — the deliberation explicitly required splitting the gateway fix from the CLAUDE.md regex fix so each ship has a clean rollback story.
+
+### Tests
+- npm CLI: 134/134 still passing (no CLI changes — bundled gateway only).
+- Gateway: new `test_loop_engine_dispatch_status.py` suite passing.
+
 ## [4.1.50] - 2026-04-09
 
 ### Fixed (CRITICAL — CLAUDE.md in-prose marker clobber)

package/gateway/ai/backends/gateway_core.py

@@ -23,10 +23,11 @@ if str(GATEWAY_ROOT) not in sys.path:
 
 
 def _load_specs(spec_path: str) -> Dict[str, Any]:
-    """Load an OpenAPI spec from a file path.
+    """Load an API spec (OpenAPI or JSON Schema) 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
 
@@ -41,15 +42,146 @@ 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:
-        from core.openapi_version import assert_supported
-        assert_supported(spec, strict=False)
+        if isinstance(spec, dict) and ("openapi" in spec or "swagger" in spec):
+            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]] = []
@@ -115,29 +247,51 @@ 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.
+    policy enforcement into a single pass/fail decision. Auto-detects
+    spec type (OpenAPI vs JSON Schema, LED-713) and dispatches to the
+    matching engine.
     """
     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."""
-    from core.diff_engine_v2 import OpenAPIDiffEngine
+    """Run diff engine only — no policy evaluation.
 
+    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": [
@@ -164,13 +318,20 @@ 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)
 
-    engine = OpenAPIDiffEngine()
+    # 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()
+
     changes = engine.compare(old, new)
 
     # Categorize changes
@@ -808,14 +969,26 @@ 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.
+    and optionally the bumped version string. Auto-detects OpenAPI vs
+    JSON Schema (LED-713).
     """
-    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)
 
+    # 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
+
     engine = OpenAPIDiffEngine()
     changes = engine.compare(old, new)
     result = classify_detailed(changes)
@@ -946,7 +1119,6 @@ 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
@@ -955,6 +1127,43 @@ 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,21 +158,80 @@ 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."""
-    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:
+    """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"
         evidence["git_log"] = []
-    # 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("."))]
+        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"] = []
+
     # Save bundle
     ev_dir = Path(os.environ.get("DELIMIT_HOME", str(Path.home() / ".delimit"))) / "evidence"
     ev_dir.mkdir(parents=True, exist_ok=True)
@@ -180,8 +239,13 @@ 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/ai/loop_engine.py

@@ -941,7 +941,12 @@ def run_governed_iteration(session_id: str, hardening: Optional[Any] = None) ->
         session["cost_incurred"] += cost
 
         from ai.ledger_manager import update_item
-        if dispatch_result.get("status") == "completed":
+        dispatch_status = dispatch_result.get("status")
+        # "completed" = synchronous success (loop engine closes the ledger).
+        # "dispatched" = swarm handed the task to an agent; the ledger stays
+        # in_progress until the agent reports back via delimit_agent_complete.
+        # Both are success outcomes from the loop's perspective.
+        if dispatch_status == "completed":
             update_item(
                 item_id=task["id"],
                 status="done",
@@ -964,6 +969,35 @@ def run_governed_iteration(session_id: str, hardening: Optional[Any] = None) ->
                 )
             except Exception as e:
                 logger.warning("Failed to notify deploy loop for %s: %s", task.get("id"), e)
+        elif dispatch_status == "dispatched":
+            # Async handoff: mark ledger in_progress, leave closure to the agent.
+            dispatched_task_id = dispatch_result.get("task_id", "")
+            try:
+                update_item(
+                    item_id=task["id"],
+                    status="in_progress",
+                    note=(
+                        f"Dispatched to swarm agent via governed build loop "
+                        f"(swarm task_id={dispatched_task_id}). Awaiting agent completion."
+                    ),
+                    project_path=str(ROOT_LEDGER_PATH),
+                )
+            except Exception as e:
+                logger.warning("Failed to mark %s in_progress after dispatch: %s", task.get("id"), e)
+            session["tasks_completed"].append({
+                "id": task["id"],
+                "status": "dispatched",
+                "swarm_task_id": dispatched_task_id,
+                "duration": duration,
+                "cost": cost,
+            })
+        elif dispatch_status == "blocked":
+            # Founder-approval gate — not a failure, don't trip the breaker.
+            session["tasks_completed"].append({
+                "id": task["id"],
+                "status": "blocked",
+                "reason": dispatch_result.get("reason", "Requires founder approval"),
+            })
         else:
             session["errors"] += 1
             if session["errors"] >= session["error_threshold"]:
@@ -971,7 +1005,7 @@ def run_governed_iteration(session_id: str, hardening: Optional[Any] = None) ->
             session["tasks_completed"].append({
                 "id": task["id"],
                 "status": "failed",
-                "error": dispatch_result.get("error", "Dispatch failed")
+                "error": dispatch_result.get("error", f"Dispatch failed (status={dispatch_status!r})"),
             })
 
         _save_session(session)

package/gateway/core/generator_drift.py

@@ -0,0 +1,242 @@
+"""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

@@ -0,0 +1,375 @@
+"""
+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

package/gateway/core/spec_detector.py

@@ -3,7 +3,7 @@ Automatic OpenAPI specification detector for zero-config installation.
 """
 
 import os
-from typing import List, Optional, Tuple
+from typing import Any, 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,26 +86,66 @@ 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.50",
+  "version": "4.1.51",
   "description": "Unify Claude Code, Codex, Cursor, and Gemini CLI with persistent context, governance, and multi-model debate.",
   "main": "index.js",
   "files": [