arkaos 4.2.0 → 4.3.1

package/core/runtime/model_router.py

@@ -33,6 +33,23 @@ USER_CONFIG_PATH = Path.home() / ".arkaos" / "models.yaml"
 QUALITY_ROLES = frozenset({
     "design", "review", "architecture", "strategy", "quality_gate",
 })
+
+# Plain-language explanation of each role, surfaced in the dashboard and
+# `npx arkaos models` so the operator knows what "execution" etc. drive.
+ROLE_DESCRIPTIONS: dict[str, str] = {
+    "design": "UI/UX and visual design — layout, typography, aesthetics.",
+    "review": "Code review, Quality Gate reviewers, adversarial verification.",
+    "architecture": "System design, API contracts, ADRs, technical decisions.",
+    "strategy": "Business and product strategy, market analysis, planning.",
+    "quality_gate": "The mandatory Quality Gate (Marta, Eduardo, Francisca).",
+    "execution": "Implementation — specialists writing code and running build tasks.",
+    "mechanical": "Rote work — commit messages, changelog, formatting, data fetch.",
+}
+
+
+def role_description(role: str) -> str:
+    """Human-readable description of a role, or empty if unknown."""
+    return ROLE_DESCRIPTIONS.get(role, "")
 KNOWN_EFFORTS = ("low", "medium", "high", "max")
 
 _ALIAS_NAMES = frozenset({"best", "default", "fast"})

package/core/runtime/model_router_cli.py

@@ -6,6 +6,7 @@ Usage::
     python -m core.runtime.model_router_cli --json        # machine-readable
     python -m core.runtime.model_router_cli init          # create user file
     python -m core.runtime.model_router_cli set review anthropic/best --effort max
+    python -m core.runtime.model_router_cli usage --period week
 """
 
 from __future__ import annotations
@@ -14,6 +15,7 @@ import argparse
 import json
 import sys
 
+from core.runtime.llm_cost_telemetry import VALID_PERIODS, summarise
 from core.runtime.model_router import (
     USER_CONFIG_PATH,
     ensure_user_config,
@@ -21,6 +23,7 @@ from core.runtime.model_router import (
     resolve_all,
     set_role,
 )
+from core.runtime.ollama_discovery import discover
 
 
 def _print_table() -> None:
@@ -37,7 +40,52 @@ def _print_table() -> None:
         model = item.model or "(unset — configure alias)"
         print(f"  {item.role:<14} {item.provider:<12} {model:<34} {item.effort}")
     print()
+    _print_ollama_line()
     print("  Change: npx arkaos models set <role> <provider>/<model> [--effort max]")
+    print("  Usage:  npx arkaos models usage [--period today|week|month|all]")
+    print()
+
+
+def _print_ollama_line() -> None:
+    status = discover()
+    if status.running and status.models:
+        names = ", ".join(m.name for m in status.models[:5])
+        extra = f" (+{len(status.models) - 5} more)" if len(status.models) > 5 else ""
+        print(f"  Ollama: running — {len(status.models)} local models: {names}{extra}")
+        print("          use them: npx arkaos models set mechanical ollama/<model>")
+    elif status.installed:
+        print("  Ollama: installed but not running — start it to unlock local models")
+    else:
+        print("  Ollama: not detected — https://ollama.com for free local models")
+    print()
+
+
+def _print_usage(period: str) -> None:
+    summary = summarise(period=period)
+    total = summary.total_cost_usd
+    total_s = f"${total:.4f}" if total is not None else "—"
+    print()
+    print(f"  Model Fabric — usage ({period})")
+    print(f"  calls: {summary.call_count}  tokens in/out: "
+          f"{summary.total_tokens_in}/{summary.total_tokens_out}  "
+          f"cached: {summary.total_cached_tokens}  est. cost: {total_s}")
+    for title, group in (("BY MODEL", summary.by_model),
+                         ("BY PROVIDER", summary.by_provider)):
+        if not group:
+            continue
+        print()
+        print(f"  {title:<28} {'CALLS':>6} {'IN':>10} {'OUT':>10} {'COST':>10}")
+        print("  " + "─" * 68)
+        ranked = sorted(group.items(),
+                        key=lambda kv: kv[1].get("total_cost_usd") or 0,
+                        reverse=True)
+        for name, bucket in ranked:
+            cost = bucket.get("total_cost_usd")
+            cost_s = f"${cost:.4f}" if cost is not None else "—"
+            print(f"  {(name or '(unknown)'):<28} "
+                  f"{bucket.get('call_count', 0):>6} "
+                  f"{bucket.get('total_tokens_in', 0):>10} "
+                  f"{bucket.get('total_tokens_out', 0):>10} {cost_s:>10}")
     print()
 
 
@@ -49,13 +97,34 @@ def _print_json() -> None:
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(prog="arkaos models")
     parser.add_argument("action", nargs="?", default="list",
-                        choices=["list", "init", "set"])
+                        choices=["list", "init", "set", "usage", "discover"])
     parser.add_argument("role", nargs="?")
     parser.add_argument("target", nargs="?")
     parser.add_argument("--effort", choices=["low", "medium", "high", "max"])
+    parser.add_argument("--period", choices=list(VALID_PERIODS), default="today")
     parser.add_argument("--json", action="store_true", dest="as_json")
     args = parser.parse_args(argv)
 
+    if args.action == "usage":
+        if args.as_json:
+            summary = summarise(period=args.period)
+            print(json.dumps({
+                "period": summary.period,
+                "call_count": summary.call_count,
+                "total_cost_usd": summary.total_cost_usd,
+                "total_tokens_in": summary.total_tokens_in,
+                "total_tokens_out": summary.total_tokens_out,
+                "total_cached_tokens": summary.total_cached_tokens,
+                "by_model": summary.by_model,
+                "by_provider": summary.by_provider,
+                "by_category": summary.by_category,
+            }, indent=2))
+        else:
+            _print_usage(args.period)
+        return 0
+    if args.action == "discover":
+        print(json.dumps(discover().to_dict(), indent=2))
+        return 0
     if args.action == "init":
         path = ensure_user_config()
         print(f"  ✓ Model Fabric config: {path}")

package/core/runtime/model_routing_context.py

@@ -0,0 +1,82 @@
+"""Model Fabric → orchestrator bridge (the consumption layer).
+
+The dashboard and ``npx arkaos models`` write ``~/.arkaos/models.yaml``.
+Until now nothing fed that config back to the Claude Code orchestrator,
+so changing a role's model changed nothing at dispatch time. This module
+turns the config into a compact directive the SessionStart hook injects,
+so the orchestrator resolves an agent's model from the user's config
+instead of only the agent YAML default.
+
+It is context injection — the same control surface ArkaOS uses for the
+constitution, routing, and evidence flow — not a hard rewrite of the Task
+`model` param (Claude Code exposes no hook for that). The PostToolUse
+telemetry already records the model actually requested per dispatch, so
+mismatches are observable (see model_routing_check).
+"""
+
+from __future__ import annotations
+
+# Which Model Fabric role governs each kind of agent work. Agents are a
+# different taxonomy from roles, so we map by what the agent DOES. The
+# orchestrator uses this to pick the role, then resolves the model.
+AGENT_ROLE_HINTS: dict[str, str] = {
+    # quality-critical
+    "architect": "architecture",
+    "cto": "architecture",
+    "strategist": "strategy",
+    "brand-strategist": "strategy",
+    "creative-director": "design",
+    "visual-designer": "design",
+    "frontend-dev": "design",
+    "marta-cqo": "quality_gate",
+    "eduardo-copy": "quality_gate",
+    "francisca-tech": "quality_gate",
+    "code-reviewer": "review",
+    "security": "review",
+    "qa": "review",
+    # execution
+    "senior-dev": "execution",
+    "paulo-tech-lead": "execution",
+    "devops": "execution",
+    # mechanical
+    "analyst": "mechanical",
+}
+
+
+def routing_summary() -> str:
+    """One-line role→provider/model@effort summary, or '' if unavailable."""
+    try:
+        from core.runtime.model_router import resolve_all
+        items = resolve_all()
+    except Exception:
+        return ""
+    parts = [
+        f"{i.role}={i.provider}/{i.model or '?'}@{i.effort}" for i in items
+    ]
+    return " ".join(parts)
+
+
+def routing_directive() -> str:
+    """Full SessionStart block: the config plus how to honor it.
+
+    Returns '' when the config cannot be read, so the hook can skip the
+    block entirely rather than inject an empty directive.
+    """
+    summary = routing_summary()
+    if not summary:
+        return ""
+    # No backticks: this string is embedded in session-start.sh which
+    # passes it through $(echo -e "$MSG") — backticks would trigger shell
+    # command substitution. Use plain quotes.
+    return (
+        "[ARKA:MODEL-FABRIC] The operator's model routing (from "
+        "~/.arkaos/models.yaml — dashboard / npx arkaos models):\n"
+        f"  {summary}\n"
+        "When dispatching a subagent via the Task tool, set its model "
+        "param from this table by the KIND of work it does (design, "
+        "review, architecture, strategy, quality_gate, execution, "
+        "mechanical) — this is the user's explicit choice and OVERRIDES "
+        "the agent YAML default. Quality roles never downgrade below the "
+        "configured model (excellence-mandate). Genuinely mechanical "
+        "dispatches (commit messages, formatting) use the mechanical role."
+    )

package/core/runtime/ollama_discovery.py

@@ -0,0 +1,96 @@
+"""Ollama discovery — is it installed, is it running, which models exist.
+
+Model Fabric PR-C. Feeds three consumers: the `npx arkaos models` CLI
+(show what the machine can actually run), the `/arka-fusion` advisor
+(recommend local models for panel/mechanical roles), and the dashboard
+Models page. Read-only: never starts the daemon, never pulls models.
+
+Detection is two-layered on purpose: the binary can be installed while
+the daemon is stopped (installed=True, running=False lets the advisor
+say "start Ollama to unlock N local models" instead of pretending
+Ollama does not exist).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import urllib.error
+import urllib.request
+from dataclasses import asdict, dataclass, field
+
+_DEFAULT_HOST = "http://localhost:11434"
+_TAGS_TIMEOUT_S = 2.0
+
+
+@dataclass(frozen=True)
+class OllamaModel:
+    """One locally available model as reported by /api/tags."""
+
+    name: str
+    size_gb: float
+    family: str
+    parameter_size: str
+
+
+@dataclass(frozen=True)
+class OllamaStatus:
+    """Discovery result for the local Ollama installation."""
+
+    installed: bool
+    running: bool
+    host: str
+    models: list[OllamaModel] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+def _host() -> str:
+    return os.environ.get("OLLAMA_HOST", _DEFAULT_HOST).rstrip("/")
+
+
+def binary_installed() -> bool:
+    """True when the `ollama` binary is on PATH."""
+    return shutil.which("ollama") is not None
+
+
+def _fetch_tags(host: str) -> list[dict] | None:
+    """GET /api/tags; None when the daemon is unreachable."""
+    try:
+        with urllib.request.urlopen(
+            f"{host}/api/tags", timeout=_TAGS_TIMEOUT_S
+        ) as response:
+            data = json.loads(response.read().decode("utf-8"))
+    except (urllib.error.URLError, TimeoutError, OSError,
+            json.JSONDecodeError):
+        return None
+    models = data.get("models")
+    return models if isinstance(models, list) else []
+
+
+def _parse_model(record: dict) -> OllamaModel:
+    details = record.get("details") or {}
+    size_bytes = int(record.get("size", 0) or 0)
+    return OllamaModel(
+        name=str(record.get("name", "")),
+        size_gb=round(size_bytes / 1_000_000_000, 1),
+        family=str(details.get("family", "") or ""),
+        parameter_size=str(details.get("parameter_size", "") or ""),
+    )
+
+
+def discover() -> OllamaStatus:
+    """Full discovery: binary on PATH, daemon reachable, model list."""
+    host = _host()
+    tags = _fetch_tags(host)
+    if tags is None:
+        return OllamaStatus(
+            installed=binary_installed(), running=False, host=host
+        )
+    models = [_parse_model(r) for r in tags if r.get("name")]
+    models.sort(key=lambda m: m.name)
+    # Daemon answering means Ollama is effectively installed even if the
+    # binary is not on this shell's PATH (e.g. Docker deployment).
+    return OllamaStatus(installed=True, running=True, host=host, models=models)

package/core/runtime/runtime_models.py

@@ -0,0 +1,51 @@
+"""Known models per runtime, for the Model Fabric UI + advisor.
+
+The Model Fabric ``runtime`` provider shells out to the active CLI. This
+module lists the concrete models that CLI accepts, with human labels and
+tier, so the dashboard dropdown and ``/arka-fusion`` can offer real
+choices (Fable 5, Opus, Sonnet, Haiku) instead of only the abstract
+best/default/fast aliases.
+
+Model IDs verified against the Claude API reference (2026-07). This is
+the single place they are hand-listed — update HERE when the runtime
+ships new models; the dashboard and CLI read from this module. Codex /
+Gemini / Cursor models are left empty on purpose: we do not hardcode
+another vendor's catalogue, and the UI falls back to a free-text field
+so the user types the exact id their runtime accepts.
+"""
+
+from __future__ import annotations
+
+
+# Claude Code accepts the short aliases opus/sonnet/haiku and full model
+# IDs. `value` is what gets written to models.yaml as the role's model.
+CLAUDE_CODE_MODELS: list[dict[str, str]] = [
+    {"value": "claude-fable-5", "label": "Fable 5", "tier": "frontier",
+     "note": "most capable"},
+    {"value": "opus", "label": "Opus 4.8", "tier": "frontier",
+     "note": "frontier"},
+    {"value": "sonnet", "label": "Sonnet 5", "tier": "balanced",
+     "note": "balanced speed/quality"},
+    {"value": "haiku", "label": "Haiku 4.5", "tier": "fast",
+     "note": "fast + cheap"},
+]
+
+_MODELS_BY_RUNTIME: dict[str, list[dict[str, str]]] = {
+    "claude-code": CLAUDE_CODE_MODELS,
+    # codex / gemini / cursor intentionally omitted — free-text in the UI.
+}
+
+
+def models_for_runtime(runtime_id: str) -> list[dict[str, str]]:
+    """Return the known runtime models for the given runtime id."""
+    return _MODELS_BY_RUNTIME.get(runtime_id, [])
+
+
+def detect_runtime_models() -> tuple[str, list[dict[str, str]]]:
+    """Best-effort (runtime_id, models) for the active runtime."""
+    try:
+        from core.runtime.registry import detect_runtime
+        runtime_id = detect_runtime()
+    except Exception:
+        runtime_id = "claude-code"
+    return runtime_id, models_for_runtime(runtime_id)

package/core/workflow/flow_authorization.py

@@ -0,0 +1,181 @@
+"""Persistent per-session flow authorization — enforcer resilience.
+
+Claude Code exposes NO hook access to the current assistant message
+(confirmed against the hook docs, 2026-07-05: neither PreToolUse nor
+PostToolUse carries the message text, and the transcript at
+``transcript_path`` does not yet include the in-progress turn). So the
+current turn's ``[arka:routing]`` marker is structurally invisible to
+that turn's own tool calls, and the old PostToolUse marker cache read a
+non-existent ``assistant_message`` field — it was never written, leaving
+the enforcer with only a 20-message transcript window that a long
+session or a context compaction empties (652 false-positive blocks
+observed in one session).
+
+This module rebuilds resilience on what hooks CAN see: markers observed
+in the transcript (past turns) plus persistent ``/tmp`` state that
+survives compaction and window-rolling.
+
+Two tiers:
+
+- **CONFIRMED** — written whenever a flow marker is actually observed in
+  the transcript. Valid for a session TTL, survives compaction. Grants
+  a silent allow. This is the normal steady state: route once, then
+  every subsequent turn is authorised.
+- **TURN GRACE** — the current turn's marker cannot be seen, so the very
+  first turn of a session (before any marker reaches the transcript) has
+  no confirmed auth. Rather than a false-positive block, the turn is
+  allowed WITH A WARNING and a per-turn grace flag so the rest of the
+  turn proceeds. A never-routing session is warned every turn and, after
+  ``GRACE_CAP`` consecutive graced turns with no confirmation, escalates
+  to a hard block — a normally-routing session confirms by turn 2 and
+  never reaches the cap.
+
+State dir: ``/tmp/arkaos-flow-auth`` (override via ``ARKA_FLOW_AUTH_DIR``).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from core.shared import safe_session_id as _safe_session_id_module
+
+_safe_session_id = _safe_session_id_module.safe_session_id
+
+# A working session; after this a stale /tmp record expires on its own.
+DEFAULT_TTL_SECONDS = 12 * 60 * 60
+# Consecutive graced turns with no confirmation before a hard block.
+GRACE_CAP = 3
+
+VALID_MARKER_TYPES: frozenset[str] = frozenset(
+    {"routing", "trivial", "gate", "phase"}
+)
+
+
+@dataclass(frozen=True)
+class GraceState:
+    count: int
+    escalate: bool
+
+
+def _base_dir() -> Path:
+    override = os.environ.get("ARKA_FLOW_AUTH_DIR", "").strip()
+    return Path(override) if override else Path("/tmp/arkaos-flow-auth")
+
+
+def _auth_path(session_id: str) -> Path | None:
+    safe = _safe_session_id(session_id)
+    return (_base_dir() / f"{safe}.json") if safe else None
+
+
+def _read(path: Path | None) -> dict:
+    if path is None or not path.exists():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _write(path: Path | None, data: dict) -> None:
+    if path is None:
+        return
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(data), encoding="utf-8")
+    except OSError:
+        pass  # authorization state must never block the hook
+
+
+def confirm(session_id: str, marker_type: str) -> None:
+    """Persist a confirmed authorization (a marker was observed)."""
+    if marker_type not in VALID_MARKER_TYPES:
+        return
+    path = _auth_path(session_id)
+    if path is None:
+        return
+    _write(path, {
+        "marker_type": marker_type,
+        "confirmed_ts": time.time(),
+        "grace_count": 0,  # confirmation clears accumulated grace
+        "turn_grace": False,
+    })
+
+
+def confirmed_record(
+    session_id: str, ttl_seconds: int = DEFAULT_TTL_SECONDS
+) -> dict | None:
+    """Return the confirmed record if present and within TTL, else None."""
+    data = _read(_auth_path(session_id))
+    ts = data.get("confirmed_ts")
+    if ts is None:
+        return None
+    if time.time() - float(ts) > ttl_seconds:
+        return None
+    return data
+
+
+def is_confirmed(
+    session_id: str, ttl_seconds: int = DEFAULT_TTL_SECONDS
+) -> bool:
+    return confirmed_record(session_id, ttl_seconds) is not None
+
+
+def grant_turn_grace(session_id: str) -> None:
+    """Flag the current turn as graced so its remaining tools pass."""
+    path = _auth_path(session_id)
+    if path is None:
+        return
+    data = _read(path)
+    data["turn_grace"] = True
+    _write(path, data)
+
+
+def has_turn_grace(session_id: str) -> bool:
+    return bool(_read(_auth_path(session_id)).get("turn_grace"))
+
+
+def reset_turn(session_id: str) -> None:
+    """Clear the per-turn grace flag (called at each new user prompt).
+
+    Confirmed authorization and the grace counter are preserved — only
+    the within-turn flag resets, so the next turn re-evaluates.
+    """
+    path = _auth_path(session_id)
+    if path is None:
+        return
+    data = _read(path)
+    if data.get("turn_grace"):
+        data["turn_grace"] = False
+        _write(path, data)
+
+
+def grace_count(session_id: str) -> int:
+    return int(_read(_auth_path(session_id)).get("grace_count", 0) or 0)
+
+
+def register_grace(session_id: str) -> GraceState:
+    """Increment the consecutive-grace counter; escalate past the cap."""
+    path = _auth_path(session_id)
+    if path is None:
+        return GraceState(count=0, escalate=False)
+    data = _read(path)
+    count = int(data.get("grace_count", 0) or 0) + 1
+    data["grace_count"] = count
+    _write(path, data)
+    return GraceState(count=count, escalate=count > GRACE_CAP)
+
+
+def clear(session_id: str) -> None:
+    """Remove all authorization state for a session (tests / session end)."""
+    path = _auth_path(session_id)
+    if path is None:
+        return
+    try:
+        path.unlink()
+    except (FileNotFoundError, OSError):
+        pass

package/core/workflow/flow_enforcer.py

@@ -25,7 +25,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 
 from core.shared import safe_session_id as _safe_session_id_module
-from core.workflow import marker_cache
+from core.workflow import flow_authorization, marker_cache
 
 try:
     import fcntl  # POSIX only
@@ -222,15 +222,24 @@ class Decision:
     marker_found: str | None = None
     phase_observed: str | None = None
     bypass_used: bool = False
+    warning: str = ""
 
     def to_stderr_message(self) -> str:
         if self.allow:
-            return ""
+            return self.warning
+        # Recovery that actually works, given Claude Code exposes no
+        # current-message text to hooks (the inline `ARKA_BYPASS_FLOW=1`
+        # never reached this separate hook process — a documented trap).
         return (
-            f"[ARKA:ENFORCEMENT] Missing `[arka:routing] <dept> -> <lead>` or "
-            f"`[arka:trivial] <reason>` before "
-            f"Write/Edit/MultiEdit/NotebookEdit/Task/Skill/Bash-effect. "
-            f"Bypass once with `ARKA_BYPASS_FLOW=1`. Reason: {self.reason}."
+            f"[ARKA:ENFORCEMENT] No routing marker for "
+            f"{flow_authorization.GRACE_CAP}+ turns. Emit "
+            f"`[arka:routing] <dept> -> <lead>` (or `[arka:trivial] "
+            f"<reason>`) at the START of your reply — it authorises this "
+            f"turn and every turn after. To turn enforcement off set "
+            f"hooks.hardEnforcement=false in ~/.arkaos/config.json; to "
+            f"bypass programmatically export ARKA_BYPASS_FLOW=1 in Claude "
+            f"Code's own environment (settings.json env), not inline on a "
+            f"command. Reason: {self.reason}."
         )
 
 
@@ -414,18 +423,54 @@ def evaluate(
         )
     marker_found, phase_observed = _scan_markers(messages)
 
-    if marker_found is None:
+    if marker_found is not None:
+        # Persist a confirmed authorization so this survives compaction and
+        # the 20-message window rolling — the fix for the 652 false blocks.
+        flow_authorization.confirm(session_id, marker_found)
         return Decision(
-            allow=False,
-            reason=f"no-flow-marker-in-last-{ASSISTANT_WINDOW}-assistant-messages",
+            allow=True,
+            reason=f"marker-found:{marker_found}",
+            marker_found=marker_found,
             phase_observed=phase_observed,
         )
 
+    # No marker in the transcript window. The current turn's marker is
+    # structurally invisible to hooks, so fall back to persistent auth
+    # before ever blocking.
+    if flow_authorization.is_confirmed(session_id):
+        return Decision(
+            allow=True, reason="session-authorized", phase_observed=phase_observed
+        )
+
+    # Same turn, already graced: let the rest of the turn's tools through.
+    if flow_authorization.has_turn_grace(session_id):
+        return Decision(
+            allow=True, reason="turn-grace", phase_observed=phase_observed
+        )
+
+    # First effect-tool of a turn with no confirmed auth. A hard deny here
+    # is a false positive (the assistant may have routed in this very
+    # message — invisible to us). Grace it with a warning; escalate to a
+    # real block only after GRACE_CAP consecutive graced turns without any
+    # confirmation (a normally-routing session confirms by turn 2).
+    grace = flow_authorization.register_grace(session_id)
+    if grace.escalate:
+        return Decision(
+            allow=False,
+            reason=f"no-marker-and-grace-exhausted-after-{grace.count}-turns",
+            phase_observed=phase_observed,
+        )
+    flow_authorization.grant_turn_grace(session_id)
     return Decision(
         allow=True,
-        reason=f"marker-found:{marker_found}",
-        marker_found=marker_found,
+        reason=f"first-tool-grace:{grace.count}",
         phase_observed=phase_observed,
+        warning=(
+            f"[arka:suggest] Effect tool allowed without an observable "
+            f"routing marker (grace {grace.count}/{flow_authorization.GRACE_CAP}). "
+            f"Emit `[arka:routing] <dept> -> <lead>` at the start of your "
+            f"reply to authorise this session."
+        ),
     )
 
 

package/dashboard/app/layouts/default.vue

@@ -52,6 +52,13 @@ const links = [[{
   onSelect: () => {
     open.value = false
   }
+}, {
+  label: 'Models',
+  icon: 'i-lucide-layers',
+  to: '/models',
+  onSelect: () => {
+    open.value = false
+  }
 }, {
   label: 'Tasks',
   icon: 'i-lucide-list-checks',