arkaos 4.3.0 → 4.3.2

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/core/workflow/state_reader.sh

@@ -5,6 +5,13 @@
 # Dependencies: jq (required)
 # ============================================================================
 
+# ─── Shared Python resolver (exports ARKA_PY) ──────────────────────────
+# The lib is not a sibling here; try the in-repo path then the installed tree.
+for _l in "$(dirname "${BASH_SOURCE[0]:-$0}")/../../config/hooks/_lib/arka_python.sh" "$HOME/.arkaos/config/hooks/_lib/arka_python.sh"; do
+  if [ -f "$_l" ]; then . "$_l"; break; fi
+done
+: "${ARKA_PY:=python3}"
+
 STATE_FILE="$HOME/.arkaos/workflow-state.json"
 
 if [ ! -f "$STATE_FILE" ]; then
@@ -73,11 +80,11 @@ case "$CMD" in
       echo "none"
       exit 0
     fi
-    if command -v python3 &>/dev/null; then
-      _F_NAME=$(FORGE_FILE="$_FORGE_FILE" python3 -c "import yaml,os; d=yaml.safe_load(open(os.environ['FORGE_FILE'])); print(d.get('name',''))" 2>/dev/null)
-      _F_STATUS=$(FORGE_FILE="$_FORGE_FILE" python3 -c "import yaml,os; d=yaml.safe_load(open(os.environ['FORGE_FILE'])); print(d.get('status',''))" 2>/dev/null)
-      _F_PHASES=$(FORGE_FILE="$_FORGE_FILE" python3 -c "import yaml,os; d=yaml.safe_load(open(os.environ['FORGE_FILE'])); print(len(d.get('plan_phases',[])))" 2>/dev/null)
-      _F_BRANCH=$(FORGE_FILE="$_FORGE_FILE" python3 -c "import yaml,os; d=yaml.safe_load(open(os.environ['FORGE_FILE'])); print(d.get('governance',{}).get('branch_strategy',''))" 2>/dev/null)
+    if command -v "$ARKA_PY" >/dev/null 2>&1; then
+      _F_NAME=$(FORGE_FILE="$_FORGE_FILE" "$ARKA_PY" -c "import yaml,os; d=yaml.safe_load(open(os.environ['FORGE_FILE'])); print(d.get('name',''))" 2>/dev/null)
+      _F_STATUS=$(FORGE_FILE="$_FORGE_FILE" "$ARKA_PY" -c "import yaml,os; d=yaml.safe_load(open(os.environ['FORGE_FILE'])); print(d.get('status',''))" 2>/dev/null)
+      _F_PHASES=$(FORGE_FILE="$_FORGE_FILE" "$ARKA_PY" -c "import yaml,os; d=yaml.safe_load(open(os.environ['FORGE_FILE'])); print(len(d.get('plan_phases',[])))" 2>/dev/null)
+      _F_BRANCH=$(FORGE_FILE="$_FORGE_FILE" "$ARKA_PY" -c "import yaml,os; d=yaml.safe_load(open(os.environ['FORGE_FILE'])); print(d.get('governance',{}).get('branch_strategy',''))" 2>/dev/null)
       echo "${_FORGE_ID}|${_F_NAME}|${_F_STATUS}|${_F_PHASES}|${_F_BRANCH}"
     else
       echo "${_FORGE_ID}|||0|"

package/dashboard/app/pages/models.vue

@@ -8,6 +8,14 @@ interface ResolvedRole {
   model: string
   effort: string
   source: string
+  description?: string
+}
+
+interface RuntimeModel {
+  value: string
+  label: string
+  tier: string
+  note: string
 }
 
 interface OllamaModel {
@@ -24,6 +32,7 @@ interface ModelsOverview {
   providers: Record<string, { type: string }>
   aliases: Record<string, Record<string, string>>
   fusion: { judge: Record<string, string>, panel: Array<Record<string, string>> }
+  runtime: { id: string, models: RuntimeModel[] }
   ollama: { installed: boolean, running: boolean, host: string, models: OllamaModel[] }
   keys: { openrouter: boolean, anthropic: boolean }
 }
@@ -119,8 +128,13 @@ const targetOptions = computed(() => {
   const o = overview.value
   if (!o) return []
   const options: { label: string, value: string }[] = []
+  // Concrete runtime models first (Fable 5, Opus, Sonnet, Haiku) so the
+  // operator picks a real model, not just an abstract alias.
+  for (const m of o.runtime?.models ?? []) {
+    options.push({ label: `runtime / ${m.label} · ${m.note}`, value: `runtime/${m.value}` })
+  }
   for (const alias of ['best', 'default', 'fast']) {
-    options.push({ label: `runtime / ${alias}`, value: `runtime/${alias}` })
+    options.push({ label: `runtime / ${alias} (alias)`, value: `runtime/${alias}` })
   }
   for (const m of o.ollama?.models ?? []) {
     options.push({ label: `ollama / ${m.name}`, value: `ollama/${m.name}` })
@@ -148,7 +162,7 @@ async function saveEdit(role: string) {
   }
   saving.value = true
   try {
-    await $fetch(`${apiBase.value}/api/models/role`, {
+    await $fetch(`${apiBase}/api/models/role`, {
       method: 'POST',
       body: { role, target: editTarget.value },
     })
@@ -269,10 +283,15 @@ function formatCost(value: number | null): string {
               >
                 <UIcon
                   :name="QUALITY_ROLES.has(row.role) ? 'i-lucide-gem' : 'i-lucide-cog'"
-                  class="size-4 shrink-0"
+                  class="size-4 shrink-0 mt-0.5 self-start"
                   :class="QUALITY_ROLES.has(row.role) ? 'text-primary' : 'text-muted'"
                 />
-                <span class="w-32 shrink-0 text-sm font-medium">{{ row.role }}</span>
+                <div class="w-56 shrink-0">
+                  <p class="text-sm font-medium">{{ row.role }}</p>
+                  <p v-if="row.description" class="text-xs text-muted leading-snug">
+                    {{ row.description }}
+                  </p>
+                </div>
                 <template v-if="editingRole === row.role">
                   <UInputMenu
                     v-model="editTarget"

package/departments/ops/skills/update/SKILL.md

@@ -23,7 +23,7 @@ Hybrid sync engine: Python handles deterministic operations (MCPs, settings, des
 
 1. **One-stop: npm refresh + engine (PR61 v2.78.0 orchestrator).**
    ```bash
-   cd $ARKAOS_ROOT && python -m core.sync.update_orchestrator --home ~/.arkaos --skills ~/.claude/skills --output json
+   cd $ARKAOS_ROOT && ~/.arkaos/bin/arka-py -m core.sync.update_orchestrator --home ~/.arkaos --skills ~/.claude/skills --output json
    ```
    The orchestrator detects whether the running ArkaOS is behind npm
    latest. When stale, it shells out to `npx arkaos@latest update`
@@ -38,7 +38,7 @@ Hybrid sync engine: Python handles deterministic operations (MCPs, settings, des
    silently skips the npm step and falls through to the engine.
 
    Fallback (no orchestrator): the underlying engine still runs the
-   same way via `python -m core.sync.engine ...` for callers that
+   same way via `~/.arkaos/bin/arka-py -m core.sync.engine ...` for callers that
    don't need the version-drift gate.
 
 2. **Phase 4 (intelligent, AI subagent):** After the engine completes, dispatch ONE subagent with the engine's JSON report + the feature registry (`core/sync/features/*.yaml`). The subagent injects/removes feature sections in each `~/.claude/skills/arka-{ecosystem}/SKILL.md` while preserving all custom content.

package/departments/ops/skills/update/references/sync-engine.md

@@ -7,7 +7,7 @@ Referenced from SKILL.md. Read only when needed.
 Run the sync engine from the ArkaOS repo root:
 
 ```bash
-cd $ARKAOS_ROOT && python -m core.sync.engine --home ~/.arkaos --skills ~/.claude/skills --output json
+cd $ARKAOS_ROOT && ~/.arkaos/bin/arka-py -m core.sync.engine --home ~/.arkaos --skills ~/.claude/skills --output json
 ```
 
 The engine handles deterministic operations and returns a JSON report.

package/departments/quality/SKILL.md

@@ -24,7 +24,7 @@ Any Department Workflow:
   ...
   Phase N-1: QUALITY GATE
     1. Run the evidence engine over the project/diff:
-         python -m core.governance.evidence_checks <project_dir> \
+         ~/.arkaos/bin/arka-py -m core.governance.evidence_checks <project_dir> \
            [--changed-files f1,f2] [--test-command '...'] --json
     2. Marta dispatches Eduardo + Francisca to INTERPRET the report:
        - Eduardo: spellcheck section + prose review of changed copy

package/installer/cli.js

@@ -28,6 +28,9 @@ const { values, positionals } = parseArgs({
     // Model Fabric PR-A — `npx arkaos models [--json] [set ... --effort max]`
     json: { type: "boolean" },
     effort: { type: "string" },
+    // Fusion — `npx arkaos fusion [--save|--show] "question"`
+    save: { type: "boolean" },
+    show: { type: "boolean" },
   },
   allowPositionals: true,
   strict: false,
@@ -177,6 +180,24 @@ async function main() {
       break;
     }
 
+    case "fusion": {
+      const { execSync } = await import("node:child_process");
+      const repoRootFusion = join(__dirname, "..");
+      const pyFusion = getArkaosPython();
+      if (!pyFusion) { console.error("No Python found. Run: npx arkaos install"); process.exit(1); }
+      const fusionArgs = positionals.slice(1).map((a) => `"${a}"`).join(" ");
+      const saveFlag = values.save ? " --save" : "";
+      const showFlag = values.show ? " --show" : "";
+      try {
+        execSync(`"${pyFusion}" -m core.fusion.cli${saveFlag}${showFlag} ${fusionArgs}`, {
+          stdio: "inherit",
+          cwd: repoRootFusion,
+          env: { ...process.env, ARKAOS_ROOT: repoRootFusion, PYTHONPATH: repoRootFusion },
+        });
+      } catch { process.exit(1); }
+      break;
+    }
+
     case "index": {
       const { execSync } = await import("node:child_process");
       const indexArgs = positionals.slice(1).join(" ");

package/installer/index.js

@@ -165,6 +165,12 @@ export async function install({ runtime, path, force, skipSystem, withOllama })
       copyFileSync(cmdSrc, join(binDir, "arka-claude.cmd"));
       installed = true;
     }
+    // arka-py — the ArkaOS Python entrypoint SKILL.md commands invoke.
+    const pyPsSrc  = join(ARKAOS_ROOT, "bin", "arka-py.ps1");
+    const pyCmdSrc = join(ARKAOS_ROOT, "bin", "arka-py.cmd");
+    if (existsSync(pyPsSrc))  copyFileSync(pyPsSrc,  join(binDir, "arka-py.ps1"));
+    if (existsSync(pyCmdSrc)) copyFileSync(pyCmdSrc, join(binDir, "arka-py.cmd"));
+    if (existsSync(pyPsSrc) || existsSync(pyCmdSrc)) ok("arka-py interpreter shim installed (.cmd + .ps1)");
     if (installed) {
       ok("arka-claude wrapper installed (.cmd + .ps1)");
       console.log(`         Add to PATH: setx PATH "%PATH%;%USERPROFILE%\\.arkaos\\bin"`);
@@ -179,6 +185,14 @@ export async function install({ runtime, path, force, skipSystem, withOllama })
       console.log(`         Add to PATH: export PATH="$HOME/.arkaos/bin:$PATH"`);
       console.log(`         Optional alias: alias claude="arka-claude"`);
     }
+    // arka-py — the ArkaOS Python entrypoint SKILL.md commands invoke so the
+    // agent never runs a bare `python` that lacks ArkaOS deps (pyyaml, ...).
+    const arkaPySrc = join(ARKAOS_ROOT, "bin", "arka-py");
+    if (existsSync(arkaPySrc)) {
+      copyFileSync(arkaPySrc, join(binDir, "arka-py"));
+      try { chmodSync(join(binDir, "arka-py"), 0o755); } catch {}
+      ok("arka-py interpreter shim installed");
+    }
   }
   const claudeMdSrc = join(ARKAOS_ROOT, "config", "user-claude.md");
   const userClaudeMd = join(homedir(), ".claude", "CLAUDE.md");

package/installer/update.js

@@ -248,6 +248,13 @@ export async function update() {
     if (existsSync(psSrc) || existsSync(cmdSrc)) {
       console.log("         ✓ arka-claude wrapper updated (.cmd + .ps1)");
     }
+    const pyPsSrc  = join(ARKAOS_ROOT, "bin", "arka-py.ps1");
+    const pyCmdSrc = join(ARKAOS_ROOT, "bin", "arka-py.cmd");
+    if (existsSync(pyPsSrc))  copyFileSync(pyPsSrc,  join(binDir, "arka-py.ps1"));
+    if (existsSync(pyCmdSrc)) copyFileSync(pyCmdSrc, join(binDir, "arka-py.cmd"));
+    if (existsSync(pyPsSrc) || existsSync(pyCmdSrc)) {
+      console.log("         ✓ arka-py interpreter shim updated (.cmd + .ps1)");
+    }
   } else {
     const wrapperSrc = join(ARKAOS_ROOT, "bin", "arka-claude");
     if (existsSync(wrapperSrc)) {
@@ -255,6 +262,12 @@ export async function update() {
       try { chmodSync(join(binDir, "arka-claude"), 0o755); } catch {}
       console.log("         ✓ arka-claude wrapper updated");
     }
+    const arkaPySrc = join(ARKAOS_ROOT, "bin", "arka-py");
+    if (existsSync(arkaPySrc)) {
+      copyFileSync(arkaPySrc, join(binDir, "arka-py"));
+      try { chmodSync(join(binDir, "arka-py"), 0o755); } catch {}
+      console.log("         ✓ arka-py interpreter shim updated");
+    }
   }
   const userClaudeMd = join(homedir(), ".claude", "CLAUDE.md");
   const claudeMdSrc = join(ARKAOS_ROOT, "config", "user-claude.md");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arkaos",
-  "version": "4.3.0",
+  "version": "4.3.2",
   "description": "The Operating System for AI Agent Teams",
   "type": "module",
   "bin": {
@@ -58,5 +58,8 @@
     "CONSTITUTION.md",
     "README.md",
     "LICENSE"
-  ]
+  ],
+  "devDependencies": {
+    "eslint": "^8.57.1"
+  }
 }

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arkaos-core"
-version = "4.3.0"
+version = "4.3.2"
 description = "Core engine for ArkaOS — The Operating System for AI Agent Teams"
 readme = "README.md"
 license = {text = "MIT"}

package/scripts/dashboard-api.py

@@ -867,8 +867,14 @@ def commands(dept: Optional[str] = Query(None), q: Optional[str] = Query(None)):
 @app.get("/api/models")
 def models_overview():
     """Model Fabric: roles, providers, Ollama discovery, key presence."""
-    from core.runtime.model_router import USER_CONFIG_PATH, load_config, resolve_all
+    from core.runtime.model_router import (
+        USER_CONFIG_PATH,
+        load_config,
+        resolve_all,
+        role_description,
+    )
     from core.runtime.ollama_discovery import discover
+    from core.runtime.runtime_models import detect_runtime_models
 
     config, source = load_config()
     keys_path = Path.home() / ".arkaos" / "keys.json"
@@ -876,16 +882,21 @@ def models_overview():
         keys = json.loads(keys_path.read_text(encoding="utf-8"))
     except (OSError, json.JSONDecodeError):
         keys = {}
+    runtime_id, runtime_models = detect_runtime_models()
     return {
         "source": source,
         "config_path": str(USER_CONFIG_PATH),
-        "roles": [item.model_dump() for item in resolve_all()],
+        "roles": [
+            {**item.model_dump(), "description": role_description(item.role)}
+            for item in resolve_all()
+        ],
         "providers": {
             name: {"type": spec.get("type", "")}
             for name, spec in config.providers.items()
         },
         "aliases": config.aliases,
         "fusion": config.fusion.model_dump(),
+        "runtime": {"id": runtime_id, "models": runtime_models},
         "ollama": discover().to_dict(),
         "keys": {
             "openrouter": bool(

package/scripts/seed_initial_patterns.py

@@ -175,7 +175,7 @@ def main() -> int:
     for card in _INITIAL_PATTERNS:
         record_pattern(card)
     print(f"Seeded {len(_INITIAL_PATTERNS)} pattern cards.")
-    print("Inspect: python -m core.knowledge.pattern_cards_cli list")
+    print("Inspect: ~/.arkaos/bin/arka-py -m core.knowledge.pattern_cards_cli list")
     return 0