loki-mode 8.0.3 → 8.2.0

package/mcp/__init__.py

@@ -25,17 +25,35 @@ import logging as _logging
 
 _logger = _logging.getLogger('loki-mcp')
 
-# Gracefully handle server import -- requires pip 'mcp' SDK installed
-try:
-    from .server import mcp
-    _SERVER_AVAILABLE = True
-except SystemExit:
-    mcp = None
-    _SERVER_AVAILABLE = False
-    _logger.warning(
-        "MCP server not available: pip 'mcp' SDK not installed. "
-        "Install with: pip install mcp"
-    )
+# LAZY (PEP 562): `from .server import mcp` at package-import time dragged in
+# the whole pip MCP SDK (fastmcp + mcp.types + client.session) -- ~1.4s of the
+# ~1.9s it cost to `import mcp.lsp_proxy`. That is paid by EVERY consumer of
+# the package, including the one-shot `python3 -m mcp.lsp_proxy
+# --write-diagnostics` the lsp_diagnostics quality gate spawns once per
+# iteration, which never starts a server. The autonomous loop spent ~2.7s per
+# iteration on a writer that reported `measured: false`. Resolving `mcp` and
+# `_SERVER_AVAILABLE` through __getattr__ keeps both names working (same
+# values, same SystemExit fallback) while charging the SDK load only to code
+# that actually touches them. Submodule imports (`from mcp import server`,
+# `import mcp.lsp_proxy`) are unaffected -- Python resolves those directly.
+_LAZY_SERVER = ('mcp', '_SERVER_AVAILABLE')
+
+
+def __getattr__(name):
+    if name in _LAZY_SERVER:
+        try:
+            from .server import mcp as _server_mcp
+            values = {'mcp': _server_mcp, '_SERVER_AVAILABLE': True}
+        except SystemExit:
+            values = {'mcp': None, '_SERVER_AVAILABLE': False}
+            _logger.warning(
+                "MCP server not available: pip 'mcp' SDK not installed. "
+                "Install with: pip install mcp"
+            )
+        globals().update(values)
+        return values[name]
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
 
 # Import learning collector if available
 try:
@@ -57,4 +75,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '8.0.3'
+__version__ = '8.2.0'

package/mcp/server.py

@@ -2469,6 +2469,156 @@ async def loki_learnings(limit: int = 50) -> str:
         return json.dumps({"error": str(e)})
 
 
+@mcp.tool()
+async def loki_graph_query(question: str, budget: int = 1500, path: str = ".") -> str:
+    """Answer a codebase question from a knowledge graph instead of reading files.
+
+    WHY THIS EXISTS
+        Loading a large repo into context is the dominant token cost of working
+        on it, and on a big codebase it is simply impossible. Measured on this
+        repo: `autonomy/` alone is 85 files / 3,194,940 bytes, roughly 798,735
+        tokens if naively read. No context window holds that.
+
+        MEASURED on this repo, same question, same subtree:
+            naive file load   101,739 bytes  ~= 25,434 tokens
+            graph query         3,335 bytes  ~=    833 tokens
+        A ~30x reduction, and the answer arrives with exact file:line citations
+        plus a provenance label on every edge (EXTRACTED / INFERRED /
+        AMBIGUOUS) -- the same facts-vs-inference split the Evidence Receipt
+        uses, which is why it composes cleanly with the rest of this server.
+
+        This is the brownfield unlock: a ten-year-old enterprise repo is
+        unreachable by reading, and reachable by querying.
+
+    REQUIRES a graph built by graphify (`graphify <path>`), which is
+    deterministic AST parsing with no LLM and no network. If no graph exists
+    this returns a structured hint rather than silently degrading to a guess.
+
+    Args:
+        question: natural-language question about the codebase
+        budget: cap the answer at roughly this many tokens (default 1500)
+        path: repo root containing graphify-out/ (default: current directory)
+
+    Returns:
+        JSON: {ok, answer, tokens_estimate, budget, source} or {ok:false, hint}
+    """
+    _emit_tool_event_async('loki_graph_query', 'start',
+                           parameters={'question': question, 'budget': budget})
+    try:
+        graph = os.path.join(path or '.', 'graphify-out', 'graph.json')
+        if not os.path.exists(graph):
+            _emit_tool_event_async('loki_graph_query', 'complete',
+                                   result_status='error')
+            return json.dumps({
+                'ok': False,
+                'hint': ('no knowledge graph found at %s. Build one first: '
+                         '`graphify %s` (deterministic AST parse, no LLM, no '
+                         'network).' % (graph, path or '.')),
+            }, indent=2)
+
+        proc = subprocess.run(
+            ['graphify', 'query', question, '--budget', str(budget)],
+            cwd=path or '.', capture_output=True, text=True, timeout=120)
+        out = (proc.stdout or '').strip()
+        if proc.returncode != 0 or not out:
+            _emit_tool_event_async('loki_graph_query', 'complete',
+                                   result_status='error')
+            return json.dumps({
+                'ok': False,
+                'hint': (proc.stderr or 'graphify query returned nothing').strip()[:400],
+            }, indent=2)
+
+        _emit_tool_event_async('loki_graph_query', 'complete',
+                               result_status='success')
+        return json.dumps({
+            'ok': True,
+            'answer': out,
+            # Deliberately an ESTIMATE, labelled as one: this is bytes/4, not a
+            # tokenizer count. Reporting it as exact would be the kind of
+            # precise-sounding wrong number this project argues against.
+            'tokens_estimate': len(out) // 4,
+            'budget': budget,
+            'source': 'graphify knowledge graph (deterministic AST, no LLM)',
+        }, indent=2)
+    except FileNotFoundError:
+        _emit_tool_event_async('loki_graph_query', 'complete', result_status='error')
+        return json.dumps({'ok': False, 'hint': 'graphify is not installed on PATH'})
+    except Exception as exc:
+        _emit_tool_event_async('loki_graph_query', 'complete',
+                               result_status='error', error=str(exc))
+        return json.dumps({'ok': False, 'error': str(exc)})
+
+
+@mcp.tool()
+async def loki_verify_fast(path: str = ".", diff_base: str = "") -> str:
+    """Verify code deterministically in milliseconds. No model call, no network.
+
+    This is the embeddable verification primitive: an IDE, another agent, a CI
+    step, or a third-party tool can call it and get a structured verdict back
+    faster than a keystroke round-trip.
+
+    MEASURED on loki-mode itself (1,932 tracked source files):
+        full repo, cold   298 ms
+        full repo, warm    87 ms
+        diff-scoped        19 ms
+    against an 11,040 ms shell-based baseline. The speedup came from
+    architecture, not micro-optimization: walk the tree ONCE via the git index,
+    run every detector as a pure function in ONE process, and cache findings by
+    file CONTENT hash so an unchanged file is never re-read.
+
+    WHY THERE IS NO LLM HERE, AND WHY THAT IS THE POINT
+        Everything this returns is reproducible by anyone with the same commit.
+        A verdict you can re-derive is a FACT; a verdict a model produced is an
+        OPINION. Keeping this path purely deterministic is what makes it both
+        fast and safe to embed in someone else's product -- they do not have to
+        trust our model choices, only our arithmetic.
+
+    Args:
+        path: repository or directory to verify (default: current directory)
+        diff_base: optional git ref. When given, only files changed against it
+            are verified, which is the normal case for a pull request and the
+            fastest path.
+
+    Returns:
+        JSON: verdict (PASS | FAIL | INCONCLUSIVE), findings[] with
+        rule/path/line/message/severity, files_scanned, files_from_cache,
+        elapsed_ms, and exogenous=true.
+    """
+    _emit_tool_event_async('loki_verify_fast', 'start',
+                           parameters={'path': path, 'diff_base': diff_base})
+    try:
+        import importlib.util as _ilu
+        _fv_path = os.path.join(os.path.dirname(os.path.dirname(
+            os.path.abspath(__file__))), 'autonomy', 'lib', 'fast_verify.py')
+        if not os.path.exists(_fv_path):
+            result = json.dumps({'error': 'fast_verify not found', 'path': _fv_path})
+            _emit_tool_event_async('loki_verify_fast', 'complete',
+                                   result_status='error')
+            return result
+        _spec = _ilu.spec_from_file_location('loki_fast_verify', _fv_path)
+        _mod = _ilu.module_from_spec(_spec)
+        # Register BEFORE exec: @dataclass resolves its own module via
+        # sys.modules[cls.__module__], and on Python 3.12+ that lookup raises
+        # AttributeError on None if the module is absent. Loading by file path
+        # without this line crashes the tool -- found by actually calling it
+        # through the embedding path rather than importing it normally.
+        sys.modules.setdefault('loki_fast_verify', _mod)
+        _spec.loader.exec_module(_mod)
+
+        res = _mod.verify(path or '.', diff_base or '', True)
+        # dataclasses.asdict keeps this in lockstep with the engine's own shape,
+        # so a field added there reaches every consumer without an edit here.
+        from dataclasses import asdict as _asdict
+        payload = _asdict(res)
+        _emit_tool_event_async('loki_verify_fast', 'complete',
+                               result_status='success')
+        return json.dumps(payload, indent=2)
+    except Exception as exc:  # never let verification crash the caller
+        _emit_tool_event_async('loki_verify_fast', 'complete',
+                               result_status='error', error=str(exc))
+        return json.dumps({'error': str(exc), 'verdict': 'INCONCLUSIVE'})
+
+
 @mcp.tool()
 async def loki_counter_evidence_template(iteration: int) -> str:
     """Generate a counter-evidence file template for the given iteration.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "loki-mode",
   "mcpName": "io.github.asklokesh/loki-mode",
-  "version": "8.0.3",
+  "version": "8.2.0",
   "description": "Loki Mode by Autonomi. Autonomous spec-to-product system: takes a PRD, GitHub issue, OpenAPI/JSON/YAML, or one-line brief to a deployed app via the RARV-C closure loop with 8 quality gates. Provider-agnostic (Claude Code, OpenAI Codex, Cline, Aider).",
   "keywords": [
     "agent",

package/plugins/loki-mode/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "loki-mode",
   "displayName": "Loki Mode",
-  "version": "8.0.3",
+  "version": "8.2.0",
   "description": "Autonomous spec-to-product build system with a built-in trust layer (RARV-C closure loop, 8 quality gates, completion council). Ships Loki's spec-hardening, drift-detection, and deterministic PR verification commands plus the Loki MCP server.",
   "author": {
     "name": "Autonomi",

package/providers/claude.sh

@@ -122,6 +122,33 @@ if [ -f "$_loki_claude_flags_helper" ]; then
     . "$_loki_claude_flags_helper"
 fi
 
+# Absolute path to the curated design archetype library appended to the
+# iteration-1 system prompt by _loki_autonomy_override_text below. Resolved via
+# the same LOKI_SKILL_DIR / PROJECT_DIR precedence run.sh uses (run.sh:1311)
+# rather than BASH_SOURCE: this file is sourced, and under a plain
+# `. providers/claude.sh` BASH_SOURCE[0] can be EMPTY, which silently resolves a
+# dirname-based path one level above the repo root. The two helper paths above
+# still carry that latent defect; they survive it only because each is guarded by
+# a `[ -f ]` that quietly fails open.
+# Resolved FILE-RELATIVE first, matching how the Bun route resolves it from
+# import.meta.url. Deliberately no $PWD anywhere in this chain: at source time
+# $PWD is the TARGET PROJECT's directory during a real build, so a project that
+# happened to contain references/design-archetypes.md would have its own file
+# read straight into the autonomy system prompt (arbitrary user-controlled text,
+# and silent drift from the Bun route, which can never pick up a project file).
+# The env vars are the fallback only for the empty-BASH_SOURCE case.
+_loki_design_archetypes_path=""
+for _loki_dap_root in \
+    "$([ -n "${BASH_SOURCE[0]:-}" ] && cd "$(dirname "${BASH_SOURCE[0]}")" 2>/dev/null && cd .. 2>/dev/null && pwd)" \
+    "${LOKI_SKILL_DIR:-}" \
+    "${PROJECT_DIR:-}"; do
+    if [ -n "$_loki_dap_root" ] && [ -f "$_loki_dap_root/references/design-archetypes.md" ]; then
+        _loki_design_archetypes_path="$_loki_dap_root/references/design-archetypes.md"
+        break
+    fi
+done
+unset _loki_dap_root
+
 # Source the v7.5.22 Phase D mcp-config helper (idempotent).
 # shellcheck source=../autonomy/lib/mcp-config.sh
 _loki_mcp_config_helper="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)/autonomy/lib/mcp-config.sh"
@@ -302,6 +329,15 @@ LOKI_AUTONOMY_EOF
 4. DESIGN: commit to ONE named aesthetic direction up front (editorial, brutalist, luxury, retro-futuristic, soft/pastel, industrial, etc. -- chosen from the product domain) and hold it on every surface. Use real content (never lorem). AVOID the AI-slop tells that instantly read as machine-generated: NO indigo/blue-to-purple gradient (the #1 tell), NO Inter/Roboto/system-font headlines (pick a real display+body pairing), NO three-equal-rounded-cards-in-a-row skeleton, NO flat 1px gray card borders or colored left-border strips, NO untouched shadcn defaults, NO reflexive dark mode. Cap the palette at ~3 hues (60/30/10), tinted not pure #fff/#000, separate sections by whitespace then a slight background shift before any border. Aim for Linear/Stripe/Duolingo-tier taste: "this does not look AI-generated".
 Deliver the finished, self-verified, genuinely-designed result in THIS pass. Additional iterations should be the exception, not the plan.
 LOKI_FIRSTPASS_EOF
+
+        # Positive half of the DESIGN directive. Item 4 above only says what NOT
+        # to do, which leaves the model on the priors that ARE the slop. This
+        # appends a curated archetype library (real Radix hexes, real OFL fonts)
+        # so it has something concrete to commit to. Emitted VERBATIM on both
+        # routes -- no interpolation, no selection logic -- so the byte-parity
+        # surface stays a plain file compare and the MODEL picks the archetype.
+        # Fails open: a missing file degrades to the negative-only directive.
+        [ -f "$_loki_design_archetypes_path" ] && cat "$_loki_design_archetypes_path"
     fi
 }
 
@@ -318,6 +354,42 @@ provider_invoke() {
     claude --dangerously-skip-permissions "${_LOKI_CLAUDE_AUTO_FLAGS[@]+"${_LOKI_CLAUDE_AUTO_FLAGS[@]}"}" -p "$prompt" "$@"
 }
 
+# provider_invoke_argv <tier> <prompt> -- populate _LOKI_INVOKE_ARGV with the
+# exact command line, WITHOUT executing it.
+#
+# WHY THIS EXISTS (the timeout seam)
+#   Eight auxiliary judge sites bypass provider_invoke entirely and shell out to
+#   `claude ... -p` directly. The reason is documented in the source
+#   (done-recognition.sh:49, prd-enrich.sh:40): "`timeout` needs a real command,
+#   not a shell function." That is true -- `timeout provider_invoke ...` cannot
+#   work, because timeout(1) execs a binary.
+#
+#   So the naive fix ("route the judges through provider_invoke") would have to
+#   drop the timeout, reintroducing exactly the hang class that left 59 orphaned
+#   emit.sh processes alive for 21 hours (v8.1.0). Never trade a hang guard for
+#   an abstraction.
+#
+#   The seam that satisfies both: a builder that PRINTS argv into an array the
+#   caller can hand to `timeout`:
+#
+#       provider_invoke_argv development "$prompt"
+#       timeout 120 "${_LOKI_INVOKE_ARGV[@]}"
+#
+#   Now the judges get provider-agnostic dispatch AND keep their timeout.
+provider_invoke_argv() {
+    local tier="${1:-development}"
+    local prompt="${2:-}"
+    _loki_build_claude_auto_flags "$tier" "${LOKI_COMPLEXITY:-standard}" ""
+    local model
+    model="$(loki_tier_route_model "$tier" 2>/dev/null || provider_get_tier_param "$tier")"
+    _LOKI_INVOKE_ARGV=(
+        claude --dangerously-skip-permissions
+        "${_LOKI_CLAUDE_AUTO_FLAGS[@]+"${_LOKI_CLAUDE_AUTO_FLAGS[@]}"}"
+    )
+    [ -n "$model" ] && _LOKI_INVOKE_ARGV+=(--model "$model")
+    _LOKI_INVOKE_ARGV+=(-p "$prompt")
+}
+
 # Model tier to Task tool model parameter value
 # Respects LOKI_ALLOW_HAIKU flag for tier mapping
 provider_get_tier_param() {

package/providers/codex.sh

@@ -335,3 +335,16 @@ provider_invoke_with_tier() {
         "${extra_flags[@]+"${extra_flags[@]}"}" \
         "$prompt" "$@"
 }
+
+# provider_invoke_argv <tier> <prompt> -- see providers/claude.sh for the full
+# rationale. Prints argv into _LOKI_INVOKE_ARGV so a caller can wrap it in
+# `timeout`, which cannot wrap a shell function.
+provider_invoke_argv() {
+    local tier="${1:-development}"
+    local prompt="${2:-}"
+    local model
+    model="$(provider_get_tier_param "$tier" 2>/dev/null || printf '%s' "${CODEX_DEFAULT_MODEL:-}")"
+    _LOKI_INVOKE_ARGV=(codex exec --sandbox workspace-write)
+    [ -n "$model" ] && _LOKI_INVOKE_ARGV+=(--model "$model")
+    _LOKI_INVOKE_ARGV+=("$prompt")
+}

package/providers/loader.sh

@@ -5,7 +5,7 @@
 PROVIDERS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 # List of supported providers
-SUPPORTED_PROVIDERS=("claude" "codex" "cline" "aider")
+SUPPORTED_PROVIDERS=("claude" "codex" "cline" "aider" "opencode")
 
 # Default provider
 DEFAULT_PROVIDER="claude"
@@ -67,16 +67,22 @@ validate_provider_config() {
         PROVIDER_NAME
         PROVIDER_DISPLAY_NAME
         PROVIDER_CLI
-        PROVIDER_AUTONOMOUS_FLAG
         PROVIDER_PROMPT_POSITIONAL
         PROVIDER_HAS_SUBAGENTS
         PROVIDER_HAS_PARALLEL
         PROVIDER_DEGRADED
     )
 
-    # Variables that must be defined but can be empty string
+    # Variables that must be defined but can be empty string.
+    #
+    # PROVIDER_AUTONOMOUS_FLAG moved here in v8.2.0: not every CLI needs a flag
+    # to run non-interactively. `opencode run <prompt>` is already autonomous, so
+    # requiring a non-empty value rejected a perfectly valid provider as
+    # "incomplete". The variable must still be DEFINED -- an author who forgets
+    # it entirely is still caught -- but an intentional empty value is legal.
     local allow_empty_vars=(
         PROVIDER_PROMPT_FLAG
+        PROVIDER_AUTONOMOUS_FLAG
     )
 
     for var in "${required_vars[@]}"; do
@@ -174,7 +180,7 @@ print_capability_matrix() {
 # BUG-PROV-007 fix: includes all 4 supported providers in priority order
 # Priority: Claude (Tier 1, full) > Cline (Tier 2, near-full) > Codex/Aider (Tier 3, degraded)
 auto_detect_provider() {
-    for p in claude cline codex aider; do
+    for p in claude cline codex aider opencode; do
         if check_provider_installed "$p"; then
             echo "$p"
             return 0

package/providers/model_catalog.json

@@ -1,7 +1,7 @@
 {
   "_comment": "Canonical model catalog. Update this single file when a provider ships a new model. Providers/web-app/docs read from here.",
   "schema_version": 1,
-  "updated": "2026-06-30",
+  "updated": "2026-07-29",
   "providers": {
     "claude": {
       "latest_planning": "claude-opus-4-8",
@@ -52,31 +52,128 @@
       "latest_development": "gpt-5.3-codex",
       "latest_fast": "gpt-5.3-codex",
       "models": [
-        { "id": "gpt-5.3-codex", "tier": "planning" },
-        { "id": "o3", "tier": "planning" },
-        { "id": "o4-mini", "tier": "fast" }
+        {
+          "id": "gpt-5.3-codex",
+          "tier": "planning"
+        },
+        {
+          "id": "o3",
+          "tier": "planning"
+        },
+        {
+          "id": "o4-mini",
+          "tier": "fast"
+        }
       ],
       "notes": "Codex uses a single model with effort level (xhigh/high/low) for tier differentiation"
     },
     "cline": {
-      "latest_planning": "claude-opus-4-8",
-      "latest_development": "claude-sonnet-5",
-      "latest_fast": "claude-sonnet-5",
+      "latest_planning": "openrouter/deepseek/deepseek-v3.2",
+      "latest_development": "openrouter/deepseek/deepseek-v3.2",
+      "latest_fast": "openrouter/deepseek/deepseek-chat",
       "models": [
-        { "id": "claude-opus-4-8", "tier": "planning" },
-        { "id": "claude-sonnet-5", "tier": "development" },
-        { "id": "gpt-4.1", "tier": "development" }
+        {
+          "id": "openrouter/deepseek/deepseek-v3.2",
+          "tier": "planning",
+          "open_weights": true
+        },
+        {
+          "id": "openrouter/deepseek/deepseek-v3.2",
+          "tier": "development",
+          "open_weights": true
+        },
+        {
+          "id": "openrouter/deepseek/deepseek-chat",
+          "tier": "fast",
+          "open_weights": true
+        },
+        {
+          "id": "openrouter/z-ai/glm-4.6",
+          "tier": "development",
+          "open_weights": true
+        }
       ]
     },
     "aider": {
-      "latest_planning": "claude-opus-4-8",
-      "latest_development": "claude-sonnet-5",
-      "latest_fast": "claude-sonnet-5",
+      "latest_planning": "openrouter/deepseek/deepseek-v3.2",
+      "latest_development": "openrouter/deepseek/deepseek-v3.2",
+      "latest_fast": "openrouter/deepseek/deepseek-chat",
+      "models": [
+        {
+          "id": "openrouter/deepseek/deepseek-v3.2",
+          "tier": "planning",
+          "open_weights": true
+        },
+        {
+          "id": "openrouter/deepseek/deepseek-v3.2",
+          "tier": "development",
+          "open_weights": true
+        },
+        {
+          "id": "openrouter/deepseek/deepseek-chat",
+          "tier": "fast",
+          "open_weights": true
+        },
+        {
+          "id": "openrouter/minimax/minimax-m2.1",
+          "tier": "development",
+          "open_weights": true
+        },
+        {
+          "id": "ollama_chat/deepseek-coder",
+          "tier": "fast",
+          "open_weights": true
+        }
+      ]
+    },
+    "opencode": {
+      "latest_planning": "openrouter/deepseek/deepseek-v3.2",
+      "latest_development": "openrouter/deepseek/deepseek-v3.2",
+      "latest_fast": "openrouter/deepseek/deepseek-chat",
       "models": [
-        { "id": "claude-opus-4-8", "tier": "planning" },
-        { "id": "claude-sonnet-5", "tier": "development" },
-        { "id": "gpt-4.1", "tier": "development" },
-        { "id": "ollama_chat/deepseek-coder", "tier": "fast" }
+        {
+          "id": "openrouter/deepseek/deepseek-v3.2",
+          "tier": "planning",
+          "open_weights": true
+        },
+        {
+          "id": "openrouter/deepseek/deepseek-v3.2",
+          "tier": "development",
+          "open_weights": true
+        },
+        {
+          "id": "openrouter/deepseek/deepseek-chat",
+          "tier": "fast",
+          "open_weights": true
+        },
+        {
+          "id": "openrouter/z-ai/glm-4.6",
+          "tier": "development",
+          "open_weights": true
+        },
+        {
+          "id": "openrouter/minimax/minimax-m2.1",
+          "tier": "development",
+          "open_weights": true
+        },
+        {
+          "id": "ollama/qwen2.5-coder",
+          "tier": "fast",
+          "open_weights": true
+        }
+      ]
+    },
+    "generic": {
+      "_comment": "Fallback for ANY provider not named above (bring-your-own endpoint). All three tiers collapse to one open model, the same shape codex uses. Override per tier with LOKI_<PROVIDER>_MODEL_<TIER> or wholesale with LOKI_<PROVIDER>_MODEL.",
+      "latest_planning": "openrouter/deepseek/deepseek-v3.2",
+      "latest_development": "openrouter/deepseek/deepseek-v3.2",
+      "latest_fast": "openrouter/deepseek/deepseek-chat",
+      "models": [
+        {
+          "id": "openrouter/deepseek/deepseek-v3.2",
+          "tier": "development",
+          "open_weights": true
+        }
       ]
     }
   }

package/providers/models.sh

@@ -25,7 +25,15 @@ loki_latest_model() {
     local tier_upper
     tier_upper=$(printf '%s' "$tier" | tr '[:lower:]' '[:upper:]')
     local provider_upper
-    provider_upper=$(printf '%s' "$provider" | tr '[:lower:]' '[:upper:]')
+    # Uppercase AND normalize to a legal shell identifier. A provider named with
+    # a hyphen (e.g. "some-new-vendor") would otherwise build
+    # LOKI_SOME-NEW-VENDOR_MODEL_DEVELOPMENT, which is not a valid variable name;
+    # the indirect expansion below then fails and takes the whole lookup with it,
+    # so the provider silently resolves to nothing. Found when adding the generic
+    # registry fallback: "notaprovider" worked and "some-new-vendor" did not.
+    provider_upper=$(printf '%s' "$provider" \
+        | tr '[:lower:]' '[:upper:]' \
+        | tr -c 'A-Z0-9_' '_' )
 
     # Env override chain
     local override="LOKI_${provider_upper}_MODEL_${tier_upper}"
@@ -48,9 +56,24 @@ import json, sys
 catalog_path, provider, tier = sys.argv[1], sys.argv[2], sys.argv[3]
 with open(catalog_path) as fh:
     data = json.load(fh)
-p = data.get("providers", {}).get(provider)
+providers = data.get("providers", {})
+p = providers.get(provider)
 if not p:
-    sys.exit(1)
+    # REGISTRY FALLBACK (v8.2.0). A fixed table of provider keys means every
+    # unknown provider is a fallthrough that resolves to NOTHING -- verified
+    # before this change: `loki_latest_model notaprovider development` returned
+    # empty with rc=1. That makes "bring your own endpoint" a dead end, which is
+    # the opposite of model-agnostic.
+    #
+    # A "generic" key turns the unknown case into a first-class one. It is the
+    # same shape codex already uses (all three tiers collapsed onto one model),
+    # so this generalizes an accepted pattern rather than inventing a mechanism.
+    #
+    # The env-override chain above still wins, so an operator naming a specific
+    # model per tier is never overridden by this default.
+    p = providers.get("generic")
+    if not p:
+        sys.exit(1)
 model = p.get(f"latest_{tier}")
 if not model:
     sys.exit(1)