arkaos 5.10.0 → 5.11.0

package/VERSION

@@ -1 +1 @@
-5.10.0
+5.11.0

package/bin/arka-menubar.py

@@ -79,17 +79,23 @@ def read_state(home: Path | None = None) -> dict:
         "autoupdate_on": True,
     }
     try:
-        manifest = json.loads((home / "install-manifest.json").read_text())
+        manifest = json.loads(
+            (home / "install-manifest.json").read_text(encoding="utf-8")
+        )
         state["version"] = manifest.get("version") or None
     except Exception:
         pass
     try:
-        sync = json.loads((home / "sync-state.json").read_text())
+        sync = json.loads(
+            (home / "sync-state.json").read_text(encoding="utf-8")
+        )
         state["sync_pending"] = sync.get("version") == "pending-sync"
     except Exception:
         pass
     try:
-        profile = json.loads((home / "profile.json").read_text())
+        profile = json.loads(
+            (home / "profile.json").read_text(encoding="utf-8")
+        )
         value = str(profile.get("installProfile", "essential")).strip().lower()
         state["profile"] = value if value in VALID_PROFILES else "essential"
     except Exception:
@@ -154,7 +160,7 @@ def stable_script(name: str) -> Path | None:
     if lib.exists():
         return lib
     try:
-        repo = Path((home / ".repo-path").read_text().strip())
+        repo = Path((home / ".repo-path").read_text(encoding="utf-8").strip())
         candidate = repo / "scripts" / name
         if candidate.exists():
             return candidate
@@ -190,7 +196,8 @@ def action_open_dashboard() -> None:
             log_line(f"open_dashboard: ensure failed ({err})")
     ui_port = ""
     try:
-        for line in (arka_home() / "dashboard.ports").read_text().splitlines():
+        ports = (arka_home() / "dashboard.ports").read_text(encoding="utf-8")
+        for line in ports.splitlines():
             if line.startswith("UI_PORT="):
                 ui_port = line.split("=", 1)[1].strip()
     except Exception:

package/core/agents/loader.py

@@ -24,7 +24,7 @@ def load_agent(path: str | Path) -> Agent:
     if not path.exists():
         raise FileNotFoundError(f"Agent file not found: {path}")
 
-    with open(path) as f:
+    with open(path, encoding="utf-8") as f:
         data = yaml.safe_load(f)
 
     if data is None:

package/core/agents/registry_gen.py

@@ -126,7 +126,7 @@ def generate_registry(departments_dir: str | Path, output_path: str | Path) -> d
         registry["_meta"]["errors"] = errors
 
     output_path.parent.mkdir(parents=True, exist_ok=True)
-    with open(output_path, "w") as f:
+    with open(output_path, "w", encoding="utf-8") as f:
         json.dump(registry, f, indent=2, ensure_ascii=False)
 
     return registry

package/core/budget/manager.py

@@ -178,13 +178,13 @@ class BudgetManager:
             "counter": self._counter,
             "usages": [u.model_dump(mode="json") for u in self._usages],
         }
-        with open(self._storage_path, "w") as f:
+        with open(self._storage_path, "w", encoding="utf-8") as f:
             json.dump(data, f, indent=2)
 
     def _load(self) -> None:
         if self._storage_path is None or not self._storage_path.exists():
             return
-        content = self._storage_path.read_text().strip()
+        content = self._storage_path.read_text(encoding="utf-8").strip()
         if not content:
             return
         data = json.loads(content)

package/core/cognition/scheduler/daemon.py

@@ -61,7 +61,7 @@ class ScheduleConfig:
     @classmethod
     def load(cls, config_path: str) -> "list[ScheduleConfig]":
         """Load schedules from YAML, returning only enabled entries."""
-        with open(config_path) as fh:
+        with open(config_path, encoding="utf-8") as fh:
             data = yaml.safe_load(fh)
 
         schedules = []
@@ -106,7 +106,7 @@ class ArkaScheduler:
         """Acquire an exclusive file lock. Returns False if already locked."""
         Path(self._lock_path).parent.mkdir(parents=True, exist_ok=True)
         try:
-            fd = open(self._lock_path, "w")  # noqa: WPS515
+            fd = open(self._lock_path, "w", encoding="utf-8")  # noqa: WPS515
             if sys.platform == "win32":
                 import msvcrt  # type: ignore[import]
 

package/core/conclave/persistence.py

@@ -22,7 +22,7 @@ def save_profile(board: ConclaveBoard, path: str | Path = "") -> None:
         "contrarian": [a.model_dump(mode="json") for a in board.contrarian],
     }
 
-    with open(path, "w") as f:
+    with open(path, "w", encoding="utf-8") as f:
         json.dump(data, f, indent=2, ensure_ascii=False)
 
 
@@ -33,7 +33,7 @@ def load_profile(path: str | Path = "") -> Optional[ConclaveBoard]:
     if not path.exists():
         return None
 
-    content = path.read_text().strip()
+    content = path.read_text(encoding="utf-8").strip()
     if not content:
         return None
 

package/core/forge/orchestrator.py

@@ -474,7 +474,11 @@ class ForgeOrchestrator:
             repo = Path.cwd().name
 
         version_file = Path(__file__).parent.parent.parent / "VERSION"
-        version = version_file.read_text().strip() if version_file.exists() else "unknown"
+        version = (
+            version_file.read_text(encoding="utf-8").strip()
+            if version_file.exists()
+            else "unknown"
+        )
 
         self._forge_context = ForgeContext(
             repo=repo,

package/core/governance/constitution.py

@@ -146,7 +146,7 @@ def load_constitution(path: str | Path) -> Constitution:
     if not path.exists():
         raise FileNotFoundError(f"Constitution file not found: {path}")
 
-    with open(path) as f:
+    with open(path, encoding="utf-8") as f:
         data = yaml.safe_load(f)
 
     return Constitution.model_validate(data)

package/core/governance/quality_api.py

@@ -31,14 +31,14 @@ def _load_queue() -> list[dict]:
     if not _QUEUE_FILE.exists():
         return []
     try:
-        return json.loads(_QUEUE_FILE.read_text())
+        return json.loads(_QUEUE_FILE.read_text(encoding="utf-8"))
     except (json.JSONDecodeError, OSError):
         return []
 
 
 def _save_queue(queue: list[dict]) -> None:
     _ensure_state_dir()
-    _QUEUE_FILE.write_text(json.dumps(queue, indent=2))
+    _QUEUE_FILE.write_text(json.dumps(queue, indent=2), encoding="utf-8")
 
 
 def _load_workflows() -> list[dict]:
@@ -46,14 +46,14 @@ def _load_workflows() -> list[dict]:
     if not _WORKFLOWS_FILE.exists():
         return []
     try:
-        return json.loads(_WORKFLOWS_FILE.read_text())
+        return json.loads(_WORKFLOWS_FILE.read_text(encoding="utf-8"))
     except (json.JSONDecodeError, OSError):
         return []
 
 
 def _save_workflows(workflows: list[dict]) -> None:
     _ensure_state_dir()
-    _WORKFLOWS_FILE.write_text(json.dumps(workflows, indent=2))
+    _WORKFLOWS_FILE.write_text(json.dumps(workflows, indent=2), encoding="utf-8")
 
 
 def submit(

package/core/governance/skill_proposer.py

@@ -9,9 +9,10 @@ Mirror of the PR20 reorganizer pattern but focused on capability-capture.
 
 from __future__ import annotations
 
+import hashlib
 import re
 from dataclasses import dataclass
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 
 _COMPLETION_PATTERNS: tuple[re.Pattern[str], ...] = (
@@ -41,7 +42,14 @@ _DEFAULT_OUTPUT_DIR: Path = Path.home() / ".arkaos" / "skill-proposals"
 
 @dataclass(frozen=True)
 class SkillProposal:
-    """Outcome of a skill-evaluation pass."""
+    """Outcome of a skill-evaluation pass.
+
+    ``proposal_path`` is set only when a file was actually written. It is
+    ``None`` both when no proposal was warranted and when one was
+    rendered but had nowhere safe to go (reason ``no-safe-filename``) —
+    in that second case ``proposal_markdown`` still carries the capture,
+    so a caller can route it somewhere else.
+    """
     should_propose: bool
     reason: str
     suggested_slug: str | None
@@ -75,12 +83,81 @@ def evaluate(
     markdown = _render_proposal(text, slug, today=today)
     out_dir = output_dir or _DEFAULT_OUTPUT_DIR
     out_dir.mkdir(parents=True, exist_ok=True)
-    iso_today = today or datetime.now(timezone.utc).strftime("%Y-%m-%d")
-    path = out_dir / f"{iso_today}-{slug}.md"
+    iso_today = today or datetime.now(UTC).strftime("%Y-%m-%d")
+    path = _collision_free_path(out_dir, iso_today, slug, markdown)
+    if path is None:
+        return SkillProposal(False, "no-safe-filename", slug, None, markdown)
     path.write_text(markdown, encoding="utf-8")
     return SkillProposal(True, "proposed", slug, path, markdown)
 
 
+def _collision_free_path(
+    out_dir: Path, iso_today: str, slug: str, markdown: str
+) -> Path | None:
+    """Return a path for today's proposal, or ``None`` if none is safe.
+
+    ``_suggest_slug`` anchors on the first matching skill-worthy hint, so
+    same-day slug collisions are the norm: the six word hints plus the
+    fallback yield seven fixed names, and the numeric ``N-phase`` hint
+    mints a fresh one per number it matches (until ``_slugify``'s 60-char
+    cap truncates the extremes back together). The space is small in
+    practice, but it is not the fixed handful this docstring once
+    claimed. Every proposal after the first with the same slug used to
+    overwrite its predecessor, silently: distinct captured capabilities
+    were lost with no error and no trace.
+
+    Disambiguates by content digest rather than a counter, so re-running
+    the hook over the same closing message stays idempotent (same content
+    -> same path -> one file) while genuinely different proposals get
+    their own. One invariant holds every branch honest: never return a
+    path unless it is free or provably holds this exact proposal.
+
+    A name built from our digest proves nothing about the bytes inside
+    the file — any file can carry any name, no hash collision required.
+    So when the plain name and both digest names are all occupied by
+    content we cannot account for, this returns ``None`` and the caller
+    writes nothing: losing one capture is honest, overwriting somebody
+    else's is not.
+
+    The digest names are checked before the plain one, so a re-fire after
+    the operator deleted the plain twin lands back on the file it already
+    wrote instead of duplicating it.
+    """
+    digest = hashlib.sha256(markdown.encode("utf-8")).hexdigest()
+    plain = out_dir / f"{iso_today}-{slug}.md"
+    # 8 hex chars keep the filename readable; the full digest is the
+    # tie-breaker for the day those 32 bits meet a different proposal.
+    digest_paths = (
+        out_dir / f"{iso_today}-{slug}-{digest[:8]}.md",
+        out_dir / f"{iso_today}-{slug}-{digest}.md",
+    )
+    for candidate in digest_paths:
+        if _already_holds(candidate, markdown):
+            return candidate
+    if not plain.exists() or _already_holds(plain, markdown):
+        return plain
+    for candidate in digest_paths:
+        if not candidate.exists():
+            return candidate
+    return None
+
+
+def _already_holds(path: Path, markdown: str) -> bool:
+    """True only when ``path`` provably contains exactly ``markdown``.
+
+    Content we cannot read back is not "equal": a missing, unreadable, or
+    non-UTF-8 file is unknown content, and the caller must treat unknown
+    as another proposal rather than write over it. ``UnicodeDecodeError``
+    is a ``ValueError``, not an ``OSError`` — both belong in the same
+    branch, or the exception escapes ``evaluate`` into the Stop hook's
+    blanket ``except Exception: pass`` and the proposal is lost silently.
+    """
+    try:
+        return path.read_text(encoding="utf-8") == markdown
+    except (OSError, ValueError):
+        return False
+
+
 def _has_completion_signal(text: str) -> bool:
     return any(p.search(text) for p in _COMPLETION_PATTERNS)
 
@@ -108,7 +185,7 @@ def _slugify(value: str) -> str:
 
 
 def _render_proposal(text: str, slug: str, *, today: str | None) -> str:
-    iso = today or datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    iso = today or datetime.now(UTC).strftime("%Y-%m-%d")
     excerpt = text.strip()
     if len(excerpt) > 1000:
         excerpt = excerpt[:1000].rstrip() + "..."

package/core/hooks/session_start.py

@@ -24,6 +24,7 @@ module; with no usable venv it emits a static banner (fail-open).
 
 from __future__ import annotations
 
+import contextlib
 import json
 import os
 import re
@@ -247,13 +248,46 @@ def _marker_safe(value: str) -> str:
     return _CONTROL_RE.sub("", value.splitlines()[0]) if value else value
 
 
+def _spawning_suppressed() -> bool:
+    """Whether this process may launch the operator's background daemons.
+
+    SessionStart spawns two long-lived side processes: the dashboard
+    (`_ensure_dashboard`) and the reorganizer. Both take the *resolved repo
+    root* as their working tree, and `start-dashboard` kills the PIDs
+    recorded in `~/.arkaos/dashboard.pid` — one shared file for every
+    checkout on the machine — before registering its own. (`ensure` leaves
+    a healthy instance alone; `find_port` steps past occupied ports.)
+
+    Run the hook from a test and that is a live-fire action on the machine
+    running the tests: the operator's dashboard is killed through that
+    global PID file and replaced by one served out of the test tree — a
+    checkout that legitimately lacks whatever local state the real install
+    has. It looks like the dashboard broke, not like a test ran.
+    (Observed 2026-07-27: two separate pytest invocations silently took
+    over ports 3333/3334 and served a blank UI.)
+
+    ARKA_HOOK_NO_SPAWN=1 is the explicit switch. PYTEST_CURRENT_TEST is
+    honored as well, deliberately: a test author who forgets the switch
+    should lose a background process they never wanted, not the dashboard
+    they were using. pytest exports it into the environment every child
+    process inherits, so the safety net costs nothing in production, where
+    the variable is simply absent.
+    """
+    return bool(
+        os.environ.get("ARKA_HOOK_NO_SPAWN") == "1"
+        or os.environ.get("PYTEST_CURRENT_TEST")
+    )
+
+
 def _spawn_detached(cmd: list[str], repo: str, log_path: Path | None = None) -> None:
+    if _spawning_suppressed():
+        return
     stdout = subprocess.DEVNULL
     handle = None
     try:
         if log_path is not None:
             log_path.parent.mkdir(parents=True, exist_ok=True)
-            handle = log_path.open("a")
+            handle = log_path.open("a", encoding="utf-8")
             stdout = handle
         subprocess.Popen(
             cmd,
@@ -436,6 +470,47 @@ def build_recap(cwd: str, budget_ms: int = _BUDGET_MS) -> str:
         return ""
 
 
+_CONTRACT_FAILURE_LOG = (
+    Path.home() / ".arkaos" / "telemetry" / "session-start-failures.jsonl"
+)
+
+
+def _contracts_unavailable_notice(exc: BaseException) -> str:
+    """Say the contracts are missing instead of returning an empty string.
+
+    build_context() produces [ARKA:EVIDENCE-FLOW], [ARKA:SKILL-CONTRACT],
+    [ARKA:META-TAG], [ARKA:AUTHORITY] and [ARKA:MODEL-FABRIC], plus the
+    resume and root lines and, when present, the [SESSION-MEMORY] recap —
+    the rules the session is supposed to run under. Swallowing a failure here returns the exact
+    state those blocks exist to prevent: a session with no idea the rules
+    exist, behaving like a generic assistant, with nothing anywhere saying
+    why. That is indistinguishable from the hook never having run, which
+    is precisely how the Windows delivery gap survived unnoticed for
+    months (PR #408).
+
+    Same principle `_authority_brief` already applies: one honest line
+    beats a silent void. The greeting still never breaks
+    and the hook still exits 0.
+    """
+    with contextlib.suppress(Exception):  # telemetry must never be the thing that breaks
+        _CONTRACT_FAILURE_LOG.parent.mkdir(parents=True, exist_ok=True)
+        with _CONTRACT_FAILURE_LOG.open("a", encoding="utf-8") as fh:
+            fh.write(json.dumps({
+                "ts": datetime.now(UTC).isoformat(),
+                "event": "build_context_failed",
+                "error_type": type(exc).__name__,
+                "error": str(exc)[:500],
+            }) + "\n")
+    return (
+        f"\n[ARKA:CONTRACTS] unavailable ({type(exc).__name__}) — the evidence "
+        f"flow, skill-routing, meta-tag, authority and model-routing contracts "
+        f"could not be built for this session. Treat their absence as a fault, not as "
+        f"permission: keep routing and gating as if they were present, and "
+        f"report the failure. Detail in "
+        f"~/.arkaos/telemetry/session-start-failures.jsonl"
+    )
+
+
 def main(stdin_json: dict | None = None) -> int:
     if stdin_json is None:
         stdin_json, _ = read_stdin_json()
@@ -450,8 +525,8 @@ def main(stdin_json: dict | None = None) -> int:
         visible = _FALLBACK_BANNER + "\n  Olá, founder\n"
     try:
         context = build_context(cwd)
-    except Exception:  # contracts are best-effort; greeting never breaks
-        context = ""
+    except Exception as exc:  # greeting never breaks — but never lie either
+        context = _contracts_unavailable_notice(exc)
     payload: dict = {"systemMessage": visible}
     if context:
         # Assign the sub-dict key explicitly — SessionStart's wrapper also

package/core/keys.py

@@ -34,12 +34,12 @@ PROVIDERS = {
 def _load() -> dict[str, str]:
     if not KEYS_PATH.exists():
         return {}
-    return json.loads(KEYS_PATH.read_text())
+    return json.loads(KEYS_PATH.read_text(encoding="utf-8"))
 
 
 def _save(keys: dict[str, str]) -> None:
     KEYS_PATH.parent.mkdir(parents=True, exist_ok=True)
-    KEYS_PATH.write_text(json.dumps(keys, indent=2))
+    KEYS_PATH.write_text(json.dumps(keys, indent=2), encoding="utf-8")
     os.chmod(KEYS_PATH, stat.S_IRUSR | stat.S_IWUSR)  # 600
 
 

package/core/obsidian/writer.py

@@ -131,7 +131,7 @@ class ObsidianWriter:
         if config_path.exists():
             try:
                 from core.runtime.path_resolver import resolve
-                config = json.loads(config_path.read_text())
+                config = json.loads(config_path.read_text(encoding="utf-8"))
                 vault = resolve(config.get("vault_path", ""))
                 if vault and not vault.startswith("${") and Path(vault).exists():
                     return Path(vault)

package/core/personas/manager.py

@@ -73,7 +73,7 @@ class PersonaManager:
             output_dir = Path(agents_dir)
             output_dir.mkdir(parents=True, exist_ok=True)
             output_path = output_dir / f"{agent_id}.yaml"
-            with open(output_path, "w") as f:
+            with open(output_path, "w", encoding="utf-8") as f:
                 yaml.dump(agent_data, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
 
         # Track the clone
@@ -88,13 +88,13 @@ class PersonaManager:
             return
         self._storage_path.parent.mkdir(parents=True, exist_ok=True)
         data = {pid: p.model_dump(mode="json") for pid, p in self._personas.items()}
-        with open(self._storage_path, "w") as f:
+        with open(self._storage_path, "w", encoding="utf-8") as f:
             json.dump(data, f, indent=2)
 
     def _load(self) -> None:
         if self._storage_path is None or not self._storage_path.exists():
             return
-        content = self._storage_path.read_text().strip()
+        content = self._storage_path.read_text(encoding="utf-8").strip()
         if not content:
             return
         data = json.loads(content)

package/core/specs/manager.py

@@ -108,7 +108,7 @@ class SpecManager:
         path = Path(path)
         path.parent.mkdir(parents=True, exist_ok=True)
         data = spec.model_dump(mode="json")
-        with open(path, "w") as f:
+        with open(path, "w", encoding="utf-8") as f:
             yaml.dump(data, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
         return True
 
@@ -117,7 +117,7 @@ class SpecManager:
         path = Path(path)
         if not path.exists():
             raise FileNotFoundError(f"Spec file not found: {path}")
-        with open(path) as f:
+        with open(path, encoding="utf-8") as f:
             data = yaml.safe_load(f)
         spec = Spec.model_validate(data)
         self._specs[spec.id] = spec

package/core/squads/loader.py

@@ -12,7 +12,7 @@ def load_squad(path: str | Path) -> Squad:
     if not path.exists():
         raise FileNotFoundError(f"Squad file not found: {path}")
 
-    with open(path) as f:
+    with open(path, encoding="utf-8") as f:
         data = yaml.safe_load(f)
 
     if data is None:

package/core/synapse/kb_cache.py

@@ -179,12 +179,12 @@ class KBSessionCache:
         if not self._cache_file.exists():
             return {}
         try:
-            return json.loads(self._cache_file.read_text())
+            return json.loads(self._cache_file.read_text(encoding="utf-8"))
         except (json.JSONDecodeError, OSError):
             return {}
 
     def _save(self, data: dict[str, Any]) -> None:
-        self._cache_file.write_text(json.dumps(data, indent=2))
+        self._cache_file.write_text(json.dumps(data, indent=2), encoding="utf-8")
 
     def extract_topics(self, query: str) -> set[str]:
         """Extract key topics from a query string.

package/core/tasks/manager.py

@@ -135,13 +135,13 @@ class TaskManager:
             "counter": self._counter,
             "tasks": {tid: t.model_dump(mode="json") for tid, t in self._tasks.items()},
         }
-        with open(self._storage_path, "w") as f:
+        with open(self._storage_path, "w", encoding="utf-8") as f:
             json.dump(data, f, indent=2)
 
     def _load(self) -> None:
         if self._storage_path is None or not self._storage_path.exists():
             return
-        content = self._storage_path.read_text().strip()
+        content = self._storage_path.read_text(encoding="utf-8").strip()
         if not content:
             return
         data = json.loads(content)

package/core/workflow/loader.py

@@ -19,7 +19,7 @@ def load_workflow(path: str | Path) -> Workflow:
     if not path.exists():
         raise FileNotFoundError(f"Workflow file not found: {path}")
 
-    with open(path) as f:
+    with open(path, encoding="utf-8") as f:
         data = yaml.safe_load(f)
 
     if data is None:

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

@@ -251,27 +251,6 @@
   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,
@@ -279,12 +258,4 @@
   .arka-starfield {
     animation: none;
   }
-  .arka-page-enter-active,
-  .arka-page-leave-active {
-    transition: none;
-  }
-  .arka-page-enter-from,
-  .arka-page-leave-to {
-    transform: none;
-  }
 }

package/dashboard/app/composables/useApi.ts

@@ -3,8 +3,39 @@ export const useApi = () => {
 
   // path may be a plain string or a getter — useFetch accepts a getter URL
   // and refetches when its reactive deps change (compare pages rely on it).
-  const fetchApi = <T>(path: MaybeRefOrGetter<string>, opts?: Record<string, unknown>) =>
-    useFetch<T>(() => `${apiBase}${toValue(path)}`, { ...opts })
+  //
+  // An empty path means "nothing to fetch yet". Every empty-until-selected
+  // caller has that shape: the four compare pages return '' until their ids
+  // land (agents/compare.vue:49-54, departments/compare.vue:36-41,
+  // personas/compare.vue:75-80, personas/compare-with-agent.vue:54-59) and so
+  // does plan-canvas.vue:73-76 until a plan row is picked. useFetch has no
+  // skip flag, so an empty path collapses the URL to apiBase itself and 404s
+  // on mount. The guard therefore sits in the transport, never in
+  // `watch`/`immediate`: `watch: false` freezes the cache key at setup
+  // (fetch.js:106 passes `key.value`, not `key`), which merges two parallel
+  // fetches that start empty into one asyncData entry — both compare columns
+  // would then render the same record — and also kills the refetch of the
+  // pages that pass a reactive `query`.
+  //
+  // The app is client-only (`ssr: false`), so overriding `$fetch` costs
+  // nothing: useFetch's `useRequestFetch()` branch is server-side only, and
+  // apiBase is absolute, which disqualifies that branch anyway.
+  type Transport = typeof globalThis.$fetch
+
+  const fetchApi = <T>(path: MaybeRefOrGetter<string>, opts?: Record<string, unknown>) => {
+    const relative = computed(() => toValue(path))
+    const caller = opts?.$fetch as Transport | undefined
+
+    const skipWhenPathEmpty = ((...args: Parameters<Transport>) =>
+      relative.value
+        ? (caller ?? globalThis.$fetch)(...args)
+        : Promise.resolve(undefined)) as Transport
+
+    return useFetch<T>(() => `${apiBase}${relative.value}`, {
+      ...opts,
+      $fetch: skipWhenPathEmpty
+    })
+  }
 
   return { fetchApi, apiBase }
 }

package/dashboard/nuxt.config.ts

@@ -14,13 +14,6 @@ export default defineNuxtConfig({
     enabled: true
   },
 
-  app: {
-    pageTransition: {
-      name: 'arka-page',
-      mode: 'out-in'
-    }
-  },
-
   css: ['~/assets/css/main.css'],
 
   colorMode: {

package/departments/dev/skills/animated-website/scripts/extract_frames.py

@@ -314,7 +314,7 @@ def generate_manifest(output_dir, video_info, frame_count, scroll_height,
         manifest["mobile"] = _variant_summary(mobile_info)
 
     manifest_path = Path(output_dir) / "manifest.json"
-    with open(manifest_path, "w") as f:
+    with open(manifest_path, "w", encoding="utf-8") as f:
         json.dump(manifest, f, indent=2)
     print(f"\n  Manifest saved to: {manifest_path}", file=sys.stderr)
     return manifest

package/departments/dev/skills/onboard/scripts/detect-stack.py

@@ -109,7 +109,7 @@ def detect_stack(project_path: str) -> dict:
     composer_path = p / "composer.json"
     if composer_path.exists():
         try:
-            composer = json.loads(composer_path.read_text())
+            composer = json.loads(composer_path.read_text(encoding="utf-8"))
             require = {**composer.get("require", {}), **composer.get("require-dev", {})}
 
             if "laravel/framework" in require:
@@ -162,7 +162,7 @@ def detect_stack(project_path: str) -> dict:
                     php_files = list(app_path.rglob("*.php"))[:5]
                     for pf in php_files:
                         try:
-                            content = pf.read_text(errors="ignore")[:200]
+                            content = pf.read_text(encoding="utf-8", errors="ignore")[:200]
                             if "declare(strict_types=1)" in content:
                                 result["conventions"]["strict_types"] = True
                                 break
@@ -176,7 +176,7 @@ def detect_stack(project_path: str) -> dict:
     package_path = p / "package.json"
     if package_path.exists():
         try:
-            pkg = json.loads(package_path.read_text())
+            pkg = json.loads(package_path.read_text(encoding="utf-8"))
             deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
 
             # Nuxt
@@ -261,7 +261,7 @@ def detect_stack(project_path: str) -> dict:
                     fp = p / f
                     if fp.exists():
                         try:
-                            content = fp.read_text(errors="ignore")[:2000]
+                            content = fp.read_text(encoding="utf-8", errors="ignore")[:2000]
                             if "fastapi" in content.lower() or "FastAPI" in content:
                                 result["framework"] = "FastAPI"
                                 result["stack"].append("FastAPI")
@@ -275,7 +275,7 @@ def detect_stack(project_path: str) -> dict:
     env_file = p / ".env.example" if (p / ".env.example").exists() else p / ".env"
     if env_file.exists():
         try:
-            env_content = env_file.read_text(errors="ignore")
+            env_content = env_file.read_text(encoding="utf-8", errors="ignore")
             if "DB_CONNECTION=pgsql" in env_content or "DATABASE_URL=postgres" in env_content:
                 result["database"].append("PostgreSQL")
             elif "DB_CONNECTION=mysql" in env_content:

package/knowledge/skills-manifest.json

@@ -1,7 +1,7 @@
 {
   "_meta": {
     "generator": "scripts/marketplace_gen.py",
-    "version": "5.10.0",
+    "version": "5.11.0",
     "marketplace": "arkaos"
   },
   "structural": {

package/mcps/arka-prompts/server.py

@@ -39,7 +39,7 @@ def _find_skills_dir() -> Path:
     # Dev mode: .repo-path points to the repo checkout
     repo_path_file = Path.home() / ".claude" / "skills" / "arka" / ".repo-path"
     if repo_path_file.exists():
-        repo_path = Path(repo_path_file.read_text().strip())
+        repo_path = Path(repo_path_file.read_text(encoding="utf-8").strip())
         if repo_path.is_dir():
             return repo_path  # Return repo root for dev mode resolution
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arkaos",
-  "version": "5.10.0",
+  "version": "5.11.0",
   "description": "The Operating System for AI Agent Teams",
   "type": "module",
   "bin": {

package/pyproject.toml

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

package/scripts/dashboard-api.py

@@ -88,7 +88,7 @@ def _load_agents() -> list[dict]:
     if _agents_cache is None:
         path = ARKAOS_ROOT / "knowledge" / "agents-registry-v2.json"
         if path.exists():
-            data = json.loads(path.read_text())
+            data = json.loads(path.read_text(encoding="utf-8"))
             _agents_cache = data.get("agents", [])
         else:
             _agents_cache = []
@@ -100,7 +100,7 @@ def _load_commands() -> list[dict]:
     if _commands_cache is None:
         path = ARKAOS_ROOT / "knowledge" / "commands-registry.json"
         if path.exists():
-            data = json.loads(path.read_text())
+            data = json.loads(path.read_text(encoding="utf-8"))
             _commands_cache = data.get("commands", [])
         else:
             _commands_cache = []
@@ -739,7 +739,7 @@ def agent_detail(agent_id: str):
     if yaml_file.exists():
         try:
             import yaml
-            raw = yaml.safe_load(yaml_file.read_text())
+            raw = yaml.safe_load(yaml_file.read_text(encoding="utf-8"))
             dna = raw.get("behavioral_dna", {})
             disc = dna.get("disc", {})
             ennea = dna.get("enneagram", {})
@@ -4486,7 +4486,7 @@ def metrics():
     if not metrics_file.exists():
         return {"entries": [], "avg_ms": 0}
     entries = []
-    for line in metrics_file.read_text().strip().split("\n"):
+    for line in metrics_file.read_text(encoding="utf-8").strip().split("\n"):
         try:
             entries.append(json.loads(line))
         except Exception:

package/scripts/harness_gen.py

@@ -88,13 +88,13 @@ STACK_DISPLAY = {
 
 def _load_agents() -> list[dict]:
     data = json.loads(
-        (ROOT / "knowledge" / "agents-registry-v2.json").read_text())
+        (ROOT / "knowledge" / "agents-registry-v2.json").read_text(encoding="utf-8"))
     return data["agents"]
 
 
 def _load_command_counts() -> dict[str, int]:
     data = json.loads(
-        (ROOT / "knowledge" / "commands-registry.json").read_text())
+        (ROOT / "knowledge" / "commands-registry.json").read_text(encoding="utf-8"))
     return data["_meta"]["departments"]
 
 
@@ -114,7 +114,7 @@ def _split_frontmatter(text: str) -> tuple[list[str], str]:
 def _stack_rules() -> list[tuple[str, list[str], str]]:
     rules = []
     for path in sorted(STACK_RULES_DIR.glob("*.md")):
-        globs, body = _split_frontmatter(path.read_text())
+        globs, body = _split_frontmatter(path.read_text(encoding="utf-8"))
         rules.append((path.stem, globs, body))
     return rules
 
@@ -402,7 +402,7 @@ def write_bundle(files: dict[str, str], harness_dir: Path) -> None:
     for rel, content in files.items():
         target = harness_dir / rel
         target.parent.mkdir(parents=True, exist_ok=True)
-        target.write_text(content)
+        target.write_text(content, encoding="utf-8")
 
 
 def main() -> int:

package/scripts/synapse-bridge.py

@@ -99,7 +99,7 @@ def load_agents_registry(root: Path) -> dict:
     if not path.exists():
         return {}
     try:
-        data = json.loads(path.read_text())
+        data = json.loads(path.read_text(encoding="utf-8"))
         agents = {}
         for agent in data.get("agents", []):
             agent_id = agent.get("id", "")
@@ -116,7 +116,7 @@ def load_commands_registry(root: Path) -> list:
     if not path.exists():
         return []
     try:
-        data = json.loads(path.read_text())
+        data = json.loads(path.read_text(encoding="utf-8"))
         return data.get("commands", [])
     except Exception:
         return []