arkaos 4.13.0 → 4.13.2

package/VERSION

@@ -1 +1 @@
-4.13.0
+4.13.2

package/bin/arka-doctor

@@ -2,7 +2,7 @@
 # ============================================================================
 # ARKA OS — Doctor (Health Check System)
 # Usage: arka doctor [--fix] [--json]
-# 16 modular checks: fail = critical, warn = advisory
+# 17 modular checks: fail = critical, warn = advisory
 # ============================================================================
 set -euo pipefail
 
@@ -362,6 +362,20 @@ else
 fi
 run_check "plugins" "warn" "$PLUGINS_DESC" "$PLUGINS_OK" "Run: bash install.sh"
 
+# ─── Check 17: Hyperframes Skills (video production) ──────────────────────
+# Parity with installer/doctor.js `hyperframes-skills` (PR-C2): same name,
+# same sentinel, warn-only — video production is opt-in.
+HF_OK=false
+HF_DESC="Hyperframes skills AUSENTE (video-as-code editing for /content video)"
+for hf_name in hyperframes hyperframes-core; do
+  if [ -f "$HOME/.claude/skills/$hf_name/SKILL.md" ]; then
+    HF_OK=true
+    HF_DESC="Hyperframes skills installed ($hf_name)"
+    break
+  fi
+done
+run_check "hyperframes-skills" "warn" "$HF_DESC" "$HF_OK" "Run /content video-setup in Claude Code"
+
 # ─── Output ────────────────────────────────────────────────────────────────
 TOTAL=$((PASS_COUNT + WARN_COUNT + FAIL_COUNT))
 

package/core/governance/evidence_checks.py

@@ -185,20 +185,101 @@ def _mypy_configured(project_dir: Path) -> bool:
 
 # ─── Individual checks ──────────────────────────────────────────────────
 
+_LINTABLE_PY = frozenset({".py"})
+_LINTABLE_JS = frozenset({".js", ".jsx", ".ts", ".tsx", ".vue", ".mjs", ".cjs"})
+_LINTABLE_PHP = frozenset({".php"})
+
+
+def _scoped_files(
+    project_dir: Path, changed: list[str] | None, exts: frozenset[str],
+) -> list[str]:
+    """Changed files that live inside project_dir and carry a lintable ext."""
+    if not changed:
+        return []
+    root = project_dir.resolve()
+    out: list[str] = []
+    for raw in changed:
+        p = Path(raw)
+        candidate = p if p.is_absolute() else project_dir / p
+        try:
+            rel = candidate.resolve().relative_to(root)
+        except (ValueError, OSError):
+            continue
+        if candidate.suffix.lower() in exts and candidate.is_file():
+            out.append(str(rel))
+    return out
+
+
+def _labelled(result: CheckResult, label: str) -> CheckResult:
+    """Prefix the reported command with the lint scope label."""
+    result.command = f"{label} {result.command}".strip()
+    return result
+
+
+def _lint_scoped(
+    project_dir: Path, changed: list[str], timeout: int,
+) -> CheckResult | None:
+    """Lint only the changed files when the detected linter supports it.
+
+    Pre-existing project-wide debt is master's debt, not this change's —
+    the same principle _check_security_grep already applies to its diff
+    scope. Returns None when no scoped run applies (caller falls back).
+    """
+    if shutil.which("ruff"):
+        files = _scoped_files(project_dir, changed, _LINTABLE_PY)
+        if files:
+            result = _run("lint", ["ruff", "check", *files], project_dir, timeout)
+            return _labelled(result, f"lint(scoped: {len(files)} file(s))")
+    eslint = project_dir / "node_modules" / ".bin" / "eslint"
+    if eslint.is_file():
+        files = _scoped_files(project_dir, changed, _LINTABLE_JS)
+        if files:
+            result = _run("lint", [str(eslint), *files], project_dir, timeout)
+            return _labelled(result, f"lint(scoped: {len(files)} file(s))")
+    pint = project_dir / "vendor" / "bin" / "pint"
+    if pint.is_file():
+        files = _scoped_files(project_dir, changed, _LINTABLE_PHP)
+        if files:
+            result = _run(
+                "lint", [str(pint), "--test", *files], project_dir, timeout,
+            )
+            return _labelled(result, f"lint(scoped: {len(files)} file(s))")
+    return None
+
 
 def _check_lint(
     project_dir: Path, changed: list[str] | None,
     test_command: str | None, timeout: int,
 ) -> CheckResult:
+    if changed:
+        scoped = _lint_scoped(project_dir, changed, timeout)
+        if scoped is not None:
+            return scoped
+        lintable = (
+            _scoped_files(project_dir, changed, _LINTABLE_PY)
+            or _scoped_files(project_dir, changed, _LINTABLE_JS)
+            or _scoped_files(project_dir, changed, _LINTABLE_PHP)
+        )
+        if not lintable:
+            return _skip("lint", "changed files contain no lintable sources")
     if _has_python(project_dir, changed) and shutil.which("ruff"):
-        return _run("lint", ["ruff", "check", "."], project_dir, timeout)
+        return _labelled(
+            _run("lint", ["ruff", "check", "."], project_dir, timeout),
+            "lint(project-wide)",
+        )
     if _package_json_script(project_dir, "lint"):
-        return _run(
-            "lint", ["npm", "run", "--silent", "lint"], project_dir, timeout,
+        return _labelled(
+            _run(
+                "lint", ["npm", "run", "--silent", "lint"], project_dir, timeout,
+            ),
+            "lint(project-wide)",
         )
     pint = project_dir / "vendor" / "bin" / "pint"
     if pint.is_file():
-        return _run("lint", [str(pint), "--test"], project_dir, timeout)
+        return _labelled(
+            _run("lint", [str(pint), "--test"], project_dir, timeout),
+            "lint(project-wide)",
+        )
     return _skip("lint", "no lint tooling detected (ruff/eslint/pint)")
 
 

package/core/workflow/design_authorization.py

@@ -0,0 +1,106 @@
+"""Persistent per-session design authorization — frontend-gate resilience.
+
+The frontend gate reasons over a 20-message transcript window. Two
+structural blind spots produce false denies in hard mode (the same class
+the flow enforcer solved with ``flow_authorization``, "652 false
+blocks"):
+
+- the current turn's ``[arka:design]`` marker is invisible to that
+  turn's own PreToolUse hook (a denied tool call never persists its
+  turn's text to the transcript), and
+- a tool-heavy sequence serializes as ``<tool_use:...>`` placeholders
+  and rolls the marker's text block out of the window.
+
+Fix: **persist-on-observe + consult-before-deny**. Whenever ``evaluate``
+observes a structured marker in the window it confirms it here; when the
+window shows nothing, a valid persisted confirmation for the session
+still allows. Deliberately NO turn-grace tier: a session with no design
+evidence at all must keep denying in hard mode (excellence-mandate), and
+the first confirmation has a natural path — emit the marker in a turn
+whose tools are not gated (loading skills / reading the design system),
+which persists to the transcript and confirms on the next evaluation.
+
+State dir: ``/tmp/arkaos-design-auth`` (override via
+``ARKA_DESIGN_AUTH_DIR``).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from pathlib import Path
+
+from core.shared import safe_session_id as _safe_session_id_module
+from core.shared.temp_paths import arkaos_temp_dir
+
+_safe_session_id = _safe_session_id_module.safe_session_id
+
+# A working session; a stale /tmp record expires on its own.
+DEFAULT_TTL_SECONDS = 12 * 60 * 60
+
+
+def _base_dir() -> Path:
+    override = os.environ.get("ARKA_DESIGN_AUTH_DIR", "").strip()
+    return Path(override) if override else arkaos_temp_dir("arkaos-design-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 confirm(session_id: str, marker: str) -> None:
+    """Persist a confirmed design authorization (structured marker seen)."""
+    path = _auth_path(session_id)
+    if path is None:
+        return
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(
+            json.dumps({"marker": marker, "confirmed_ts": time.time()}),
+            encoding="utf-8",
+        )
+    except OSError:
+        pass  # authorization state must never block the hook
+
+
+def confirmed_marker(
+    session_id: str, ttl_seconds: int = DEFAULT_TTL_SECONDS
+) -> str | None:
+    """Return the persisted marker 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
+    marker = data.get("marker")
+    return marker if isinstance(marker, str) and marker else None
+
+
+def is_confirmed(
+    session_id: str, ttl_seconds: int = DEFAULT_TTL_SECONDS
+) -> bool:
+    return confirmed_marker(session_id, ttl_seconds) is not None
+
+
+def clear(session_id: str) -> None:
+    """Remove 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/frontend_gate.py

@@ -40,6 +40,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 design_authorization
 from core.workflow.flow_enforcer import (
     TRIVIAL_RE,
     _load_last_assistant_messages,
@@ -186,6 +187,56 @@ def _classify_marker(messages: list[str]) -> tuple[str | None, str]:
     return None, "none"
 
 
+def _resolve_ui_scope(
+    tool_name: str, file_path: str, tool_input: dict
+) -> str | None:
+    """Return 'suffix' | 'heuristic' when the call is UI-scoped, else None."""
+    if tool_name not in _GATED_TOOLS:
+        return None
+    if is_ui_file(file_path):
+        return "suffix"
+    if is_heuristic_ui_file(file_path, tool_name, tool_input):
+        return "heuristic"
+    return None
+
+
+def _marker_decision(
+    session_id: str, marker: str | None, kind: str,
+    mode: str, file_path: str, ui_scope: str,
+) -> Decision:
+    """Decide allow/deny from the classified marker + persisted auth.
+
+    A structured marker is persisted (persist-on-observe) so later
+    evaluations survive transcript window-rolling — the deadlock fix,
+    mirroring flow_authorization. Trivial markers do NOT persist (they
+    authorize one small edit, not a session). With nothing in the
+    window, a valid persisted confirmation still allows.
+    """
+    if kind == "structured" and marker:
+        design_authorization.confirm(session_id, marker)
+    if kind in ("structured", "trivial"):
+        return Decision(allow=True, reason="design-evidence", mode=mode,
+                        target_file=file_path, marker_found=marker,
+                        marker_kind=kind, ui_scope=ui_scope)
+    persisted = design_authorization.confirmed_marker(session_id)
+    if persisted is not None:
+        return Decision(allow=True, reason="design-evidence-persisted",
+                        mode=mode, target_file=file_path,
+                        marker_found=persisted, marker_kind="persisted",
+                        ui_scope=ui_scope)
+    # Heuristic scope is WARN-only by design: it never denies, even in
+    # hard mode — its telemetry (ui_scope=heuristic) informs whether it
+    # ever graduates to denying scope.
+    deniable = mode == "hard" and ui_scope == "suffix"
+    if kind == "legacy":
+        return Decision(allow=not deniable, reason="legacy-marker", mode=mode,
+                        target_file=file_path, marker_found=marker,
+                        marker_kind=kind, ui_scope=ui_scope)
+    return Decision(allow=not deniable, reason="no-design-marker",
+                    mode=mode, target_file=file_path, marker_kind=kind,
+                    ui_scope=ui_scope)
+
+
 def evaluate(
     tool_name: str,
     transcript_path: str,
@@ -196,13 +247,8 @@ def evaluate(
 ) -> Decision:
     """Evaluate one tool call against the frontend excellence gate."""
     file_path = str(tool_input.get("file_path", ""))
-    if tool_name not in _GATED_TOOLS:
-        return Decision(allow=True, reason="not-ui-scope", target_file=file_path)
-    if is_ui_file(file_path):
-        ui_scope = "suffix"
-    elif is_heuristic_ui_file(file_path, tool_name, tool_input):
-        ui_scope = "heuristic"
-    else:
+    ui_scope = _resolve_ui_scope(tool_name, file_path, tool_input)
+    if ui_scope is None:
         return Decision(allow=True, reason="not-ui-scope", target_file=file_path)
     mode = _mode()
     if mode == "off":
@@ -216,21 +262,7 @@ def evaluate(
             transcript_path, ASSISTANT_WINDOW
         )
     marker, kind = _classify_marker(messages)
-    if kind in ("structured", "trivial"):
-        return Decision(allow=True, reason="design-evidence", mode=mode,
-                        target_file=file_path, marker_found=marker,
-                        marker_kind=kind, ui_scope=ui_scope)
-    # Heuristic scope is WARN-only by design: it never denies, even in
-    # hard mode — its telemetry (ui_scope=heuristic) informs whether it
-    # ever graduates to denying scope.
-    deniable = mode == "hard" and ui_scope == "suffix"
-    if kind == "legacy":
-        return Decision(allow=not deniable, reason="legacy-marker", mode=mode,
-                        target_file=file_path, marker_found=marker,
-                        marker_kind=kind, ui_scope=ui_scope)
-    return Decision(allow=not deniable, reason="no-design-marker",
-                    mode=mode, target_file=file_path, marker_kind=kind,
-                    ui_scope=ui_scope)
+    return _marker_decision(session_id, marker, kind, mode, file_path, ui_scope)
 
 
 def record_telemetry(session_id: str, tool: str, decision: Decision) -> None:

package/dashboard/app/app.config.ts

@@ -1,8 +1,8 @@
 export default defineAppConfig({
   ui: {
     colors: {
-      primary: 'emerald',
-      neutral: 'stone'
+      primary: 'arka',
+      neutral: 'carbon'
     }
   }
 })

package/dashboard/app/assets/css/main.css

@@ -1,18 +1,290 @@
 @import "tailwindcss" theme(static);
 @import "@nuxt/ui";
 
+/* ─────────────────────────────────────────────────────────────────────────
+   ArkaOS Pulse — design tokens
+   Brand anchors: #00FF88 (signal green) · #0A0A0A (ink) · #FAFAFA (paper)
+   Doctrine: dark-first; green means "alive" (live data, primary action) and
+   is never decorative; surfaces are carbon with a green undertone, not flat
+   black. Full spec: dashboard/DESIGN-SYSTEM.md
+   ───────────────────────────────────────────────────────────────────────── */
+
 @theme static {
-  --font-sans: 'Public Sans', sans-serif;
-
-  --color-green-50: #EFFDF5;
-  --color-green-100: #D9FBE8;
-  --color-green-200: #B3F5D1;
-  --color-green-300: #75EDAE;
-  --color-green-400: #00DC82;
-  --color-green-500: #00C16A;
-  --color-green-600: #00A155;
-  --color-green-700: #007F45;
-  --color-green-800: #016538;
-  --color-green-900: #0A5331;
-  --color-green-950: #052E16;
+  --font-sans: 'Inter', sans-serif;
+  --font-display: 'Space Grotesk', sans-serif;
+  --font-serif: 'Instrument Serif', serif;
+  --font-mono: 'JetBrains Mono', monospace;
+
+  /* arka — brand signal green, anchored at 400 = #00FF88 */
+  --color-arka-50: #E8FFF4;
+  --color-arka-100: #C6FFE3;
+  --color-arka-200: #8FFFC9;
+  --color-arka-300: #4DFFAB;
+  --color-arka-400: #00FF88;
+  --color-arka-500: #00E67A;
+  --color-arka-600: #00BF66;
+  --color-arka-700: #009951;
+  --color-arka-800: #00733D;
+  --color-arka-900: #0A5C34;
+  --color-arka-950: #04331C;
+
+  /* carbon — neutral scale with a green undertone (never flat gray) */
+  --color-carbon-50: #F6F8F7;
+  --color-carbon-100: #E9EDEB;
+  --color-carbon-200: #D4DBD7;
+  --color-carbon-300: #B3BDB8;
+  --color-carbon-400: #8A958F;
+  --color-carbon-500: #6B756F;
+  --color-carbon-600: #525B56;
+  --color-carbon-700: #3E4642;
+  --color-carbon-800: #262C29;
+  --color-carbon-900: #161B18;
+  --color-carbon-950: #0A0D0B;
+}
+
+/* ── Motion tokens ──────────────────────────────────────────────────────
+   One rhythm for the whole product. Enter uses --arka-ease-out (expo-like
+   deceleration), exit is faster (~65%) with --arka-ease-in. The pulse is
+   the signature: only elements that are genuinely live may breathe. */
+:root {
+  --arka-motion-fast: 150ms;
+  --arka-motion-base: 240ms;
+  --arka-motion-slow: 400ms;
+  --arka-ease-out: cubic-bezier(0.16, 1, 0.3, 1);
+  --arka-ease-in: cubic-bezier(0.7, 0, 0.84, 0);
+  --arka-pulse-period: 2.4s;
+  --arka-stagger-step: 40ms;
+}
+
+/* ── Semantic surfaces ──────────────────────────────────────────────────
+   Light: paper + ink. Primary darkened to arka-800: 5.72:1 on paper —
+   arka-700 reads 3.55:1 and fails AA for text-primary usage. */
+:root {
+  --ui-primary: var(--ui-color-primary-800);
+  --ui-bg: #FAFAFA;
+  --ui-bg-muted: #F1F4F2;
+  --ui-bg-elevated: #FFFFFF;
+  --ui-bg-accented: var(--color-carbon-100);
+  --ui-border: var(--color-carbon-200);
+  --ui-border-muted: var(--color-carbon-100);
+  --ui-text: #0A0A0A;
+  --ui-text-muted: var(--color-carbon-500);
+  --arka-glow: 0 0 0 transparent; /* glow is a dark-mode-only voice */
+  --arka-grid-line: color-mix(in srgb, var(--color-carbon-200) 60%, transparent);
+}
+
+/* Dark (flagship): void → muted → elevated → accented, all carbon-tinted.
+   Primary lifts to raw brand green; glow becomes available. */
+.dark {
+  --ui-primary: var(--ui-color-primary-400);
+  --ui-bg: #070908;
+  --ui-bg-muted: #0C100E;
+  --ui-bg-elevated: var(--color-carbon-950);
+  --ui-bg-accented: var(--color-carbon-900);
+  --ui-border: #1E2521;
+  --ui-border-muted: #151A17;
+  --ui-text: var(--color-carbon-100);
+  --ui-text-muted: var(--color-carbon-400);
+  --arka-glow: 0 0 24px color-mix(in srgb, var(--color-arka-400) 25%, transparent);
+  --arka-grid-line: color-mix(in srgb, var(--color-arka-400) 7%, transparent);
+}
+
+/* ── HUD vernacular ─────────────────────────────────────────────────────
+   Eyebrow labels: uppercase mono with wide tracking and a signal tick.
+   This — not ornament — is what carries the Jarvis DNA. */
+.arka-eyebrow {
+  font-family: var(--font-mono);
+  font-size: 0.6875rem;
+  font-weight: 500;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  color: var(--ui-text-muted);
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+.arka-eyebrow::before {
+  content: "";
+  width: 0.375rem;
+  height: 0.375rem;
+  background: var(--ui-primary);
+  clip-path: polygon(0 0, 100% 0, 100% 100%);
+}
+
+/* Live indicator: a dot that breathes. Reserved for genuinely live data. */
+.arka-live-dot {
+  width: 0.5rem;
+  height: 0.5rem;
+  border-radius: 9999px;
+  background: var(--ui-primary);
+  box-shadow: var(--arka-glow);
+  animation: arka-pulse var(--arka-pulse-period) var(--arka-ease-out) infinite;
+}
+
+/* Numbers are data: mono, tabular, never shifting layout as they tick. */
+.arka-data {
+  font-family: var(--font-mono);
+  font-variant-numeric: tabular-nums;
+}
+
+@keyframes arka-pulse {
+  0%, 100% { opacity: 1; transform: scale(1); }
+  50% { opacity: 0.55; transform: scale(0.88); }
+}
+
+/* Stream-in: how live content arrives. Pair with a per-item
+   animation-delay of calc(var(--arka-stagger-step) * i). */
+@keyframes arka-stream-in {
+  from { opacity: 0; transform: translateY(6px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+.arka-stream-in {
+  animation: arka-stream-in var(--arka-motion-base) var(--arka-ease-out) both;
+}
+
+/* Pulse line: the signature EKG. One per view, under live sections. */
+.arka-pulse-line {
+  height: 2px;
+  background: linear-gradient(
+    90deg,
+    transparent,
+    var(--ui-primary) 20%,
+    var(--ui-primary) 80%,
+    transparent
+  );
+  background-size: 200% 100%;
+  animation: arka-pulse-sweep 3.2s linear infinite;
+  opacity: 0.7;
+}
+@keyframes arka-pulse-sweep {
+  from { background-position: 100% 0; }
+  to { background-position: -100% 0; }
+}
+
+/* ── Editorial layer (Pulse v2) ─────────────────────────────────────────
+   The serif voice: cinematic page titles, Roman-numeral section markers,
+   italic brand accents. Serif is display-only — body copy never uses it. */
+.arka-serif-title {
+  font-family: var(--font-serif);
+  font-weight: 400;
+  line-height: 1.05;
+  letter-spacing: -0.01em;
+  color: var(--ui-text);
+}
+.arka-serif-accent {
+  font-family: var(--font-serif);
+  font-style: italic;
+  font-weight: 400;
+}
+.arka-numeral {
+  font-family: var(--font-serif);
+  font-style: italic;
+  font-variant-numeric: tabular-nums;
+  color: color-mix(in srgb, var(--ui-primary) 55%, var(--ui-text-muted));
+}
+
+/* Gradient-border card. Live cards raise the primary tint; glow stays a
+   dark-mode-only voice. Padding-box mask keeps the 1px gradient ring. */
+.arka-glow-card {
+  position: relative;
+  border-radius: calc(var(--ui-radius, 0.25rem) * 3);
+  background: var(--ui-bg-elevated);
+}
+.arka-glow-card::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  border-radius: inherit;
+  padding: 1px;
+  background: linear-gradient(
+    135deg,
+    color-mix(in srgb, var(--ui-primary) 22%, transparent),
+    color-mix(in srgb, var(--color-carbon-700) 45%, transparent) 55%,
+    color-mix(in srgb, var(--color-carbon-700) 25%, transparent)
+  );
+  -webkit-mask: linear-gradient(#000 0 0) content-box, linear-gradient(#000 0 0);
+  -webkit-mask-composite: xor;
+  mask: linear-gradient(#000 0 0) content-box, linear-gradient(#000 0 0);
+  mask-composite: exclude;
+  pointer-events: none;
+}
+.arka-glow-card[data-live="true"]::before {
+  background: linear-gradient(
+    135deg,
+    color-mix(in srgb, var(--ui-primary) 45%, transparent),
+    color-mix(in srgb, var(--ui-primary) 10%, transparent)
+  );
+}
+.dark .arka-glow-card[data-live="true"] {
+  box-shadow: var(--arka-glow);
+}
+.arka-glow-card[data-interactive="true"] {
+  transition:
+    transform var(--arka-motion-fast) var(--arka-ease-out),
+    box-shadow var(--arka-motion-fast) var(--arka-ease-out);
+}
+.arka-glow-card[data-interactive="true"]:hover {
+  transform: translateY(-2px);
+}
+
+/* Ambient starfield: layered radial dots in slow drift. Effective star
+   opacity stays under ~0.06 so it never competes with text contrast. */
+.arka-starfield {
+  position: fixed;
+  inset: -10%;
+  z-index: 0;
+  pointer-events: none;
+  opacity: 0.5;
+  background-image:
+    radial-gradient(1px 1px at 12% 24%, color-mix(in srgb, var(--ui-primary) 12%, transparent), transparent 60%),
+    radial-gradient(1px 1px at 34% 68%, color-mix(in srgb, var(--ui-text-muted) 10%, transparent), transparent 60%),
+    radial-gradient(1.5px 1.5px at 58% 15%, color-mix(in srgb, var(--ui-primary) 9%, transparent), transparent 60%),
+    radial-gradient(1px 1px at 71% 47%, color-mix(in srgb, var(--ui-text-muted) 8%, transparent), transparent 60%),
+    radial-gradient(1px 1px at 86% 79%, color-mix(in srgb, var(--ui-primary) 10%, transparent), transparent 60%),
+    radial-gradient(1.5px 1.5px at 23% 89%, color-mix(in srgb, var(--ui-text-muted) 7%, transparent), transparent 60%),
+    radial-gradient(1px 1px at 47% 38%, color-mix(in srgb, var(--ui-text-muted) 9%, transparent), transparent 60%),
+    radial-gradient(1px 1px at 92% 8%, color-mix(in srgb, var(--ui-primary) 8%, transparent), transparent 60%);
+  background-size: 55% 55%;
+  animation: arka-starfield-drift 140s linear infinite alternate;
+}
+@keyframes arka-starfield-drift {
+  to { transform: translate3d(-2.5%, -1.5%, 0); }
+}
+
+/* Route transitions: one rhythm, upward continuity (enter rises, exit
+   recedes). Wired via app.pageTransition in nuxt.config. */
+.arka-page-enter-active {
+  transition:
+    opacity var(--arka-motion-base) var(--arka-ease-out),
+    transform var(--arka-motion-base) var(--arka-ease-out);
+}
+.arka-page-leave-active {
+  transition:
+    opacity var(--arka-motion-fast) var(--arka-ease-in),
+    transform var(--arka-motion-fast) var(--arka-ease-in);
+}
+.arka-page-enter-from {
+  opacity: 0;
+  transform: translateY(8px);
+}
+.arka-page-leave-to {
+  opacity: 0;
+  transform: translateY(-4px);
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .arka-live-dot,
+  .arka-pulse-line,
+  .arka-stream-in,
+  .arka-starfield {
+    animation: none;
+  }
+  .arka-page-enter-active,
+  .arka-page-leave-active {
+    transition: none;
+  }
+  .arka-page-enter-from,
+  .arka-page-leave-to {
+    transform: none;
+  }
 }