arkaos 4.35.0 → 4.37.0

package/THE-ARKAOS-GUIDE.md

@@ -1,6 +1,6 @@
 # The ArkaOS Guide
 
-> v4.35.0 — 89 agents, 17 departments, 331 skills, 297 commands, 16 ADRs.
+> v4.36.0 — 89 agents, 17 departments, 331 skills, 297 commands, 17 ADRs.
 > One file, everything you need to start. Generated by `scripts/guide_gen.py` — never hand-edited.
 
 ## What it is

package/VERSION

@@ -1 +1 @@
-4.35.0
+4.37.0

package/bin/arka-menubar.py

@@ -278,10 +278,44 @@ def run_app() -> int:
             super().__init__(TITLE, quit_button=None)
             self._rumps = rumps
             self._pollers = set()
+            # QG r2 follow-ups: the ollama probe result is CACHED and
+            # refreshed by a worker (the 2s `ollama list` subprocess
+            # never runs on the menu runloop); the auto-update toggle
+            # is disabled while its worker is in flight.
+            self._ollama_cache = "absent"
+            self._probe_running = False
+            self._toggle_inflight = False
             self.refresh(None)
             self.timer = rumps.Timer(self.refresh, REFRESH_SECONDS)
             self.timer.start()
 
+        def _schedule_ollama_probe(self):
+            """Worker-side probe -> cache; redraw only on change."""
+            if self._probe_running:
+                return
+            self._probe_running = True
+            before = self._ollama_cache
+
+            def probe():
+                try:
+                    self._ollama_cache = ollama_status()
+                finally:
+                    self._probe_running = False
+
+            worker = threading.Thread(target=probe, daemon=True)
+            worker.start()
+
+            def poll(timer):
+                if not worker.is_alive():
+                    timer.stop()
+                    self._pollers.discard(timer)
+                    if self._ollama_cache != before:
+                        self.refresh(None)
+
+            poller = self._rumps.Timer(poll, 1)
+            self._pollers.add(poller)
+            poller.start()
+
         def _spawn(self, work, refresh_after=False):
             """Run side-effect work off the AppKit main thread (a blocking
             subprocess in a rumps callback freezes the whole menu bar).
@@ -313,7 +347,11 @@ def run_app() -> int:
 
         def refresh(self, _sender):
             state = read_state()
-            ollama = ollama_status_for(state)
+            if state["profile"] == "local-ai":
+                ollama = self._ollama_cache
+                self._schedule_ollama_probe()
+            else:
+                ollama = "absent"
             self.title = title_for(state)
             self.menu.clear()
             info = rumps.MenuItem(version_label(state))
@@ -331,8 +369,9 @@ def run_app() -> int:
                 "doctor": ("Run Doctor", self.on_doctor),
                 "start_ollama": ("Start Ollama", self.on_start_ollama),
                 "autoupdate_toggle": (
-                    "Auto-update: on" if state["autoupdate_on"] else "Auto-update: off",
-                    self.on_autoupdate_toggle,
+                    "Auto-update: switching…" if self._toggle_inflight
+                    else ("Auto-update: on" if state["autoupdate_on"] else "Auto-update: off"),
+                    None if self._toggle_inflight else self.on_autoupdate_toggle,
                 ),
                 "disable": ("Disable menu bar (permanent)", self.on_disable),
                 "quit": ("Quit until next login", self.on_quit),
@@ -340,7 +379,7 @@ def run_app() -> int:
             for item_id in visible:
                 label, callback = labels[item_id]
                 entry = rumps.MenuItem(label, callback=callback)
-                if item_id == "autoupdate_toggle":
+                if item_id == "autoupdate_toggle" and not self._toggle_inflight:
                     entry.state = 1 if state["autoupdate_on"] else 0
                 if item_id == "disable":
                     entries.append(rumps.separator)
@@ -365,8 +404,22 @@ def run_app() -> int:
             self._spawn(action_start_ollama, refresh_after=True)
 
         def on_autoupdate_toggle(self, _):
+            # Guard against double-fire while the (up to 180s) npx
+            # worker runs — the item is disabled and relabelled until
+            # the post-worker refresh (QG r2 minor).
+            if self._toggle_inflight:
+                return
+            self._toggle_inflight = True
             enable = not read_state()["autoupdate_on"]
-            self._spawn(lambda: action_autoupdate(enable=enable), refresh_after=True)
+
+            def work():
+                try:
+                    action_autoupdate(enable=enable)
+                finally:
+                    self._toggle_inflight = False
+
+            self._spawn(work, refresh_after=True)
+            self.refresh(None)
 
         def on_disable(self, _):
             try:

package/core/runtime/opencode.py

@@ -1,18 +1,40 @@
-"""OpenCode runtime adapter (Foundation PR-6).
+"""OpenCode runtime adapter (Foundation PR-6 + headless follow-up).
 
 OpenCode (opencode.ai) — open-source terminal AI coding agent with
 native agents (markdown, ``~/.config/opencode/agents/``), custom
-commands (``commands/``), MCP servers (``opencode.json``), and AGENTS.md
-instructions. The installer adapter (installer/adapters/opencode.js)
-deploys the generated harness bundle onto those surfaces.
-
-Honesty note: OpenCode ships a headless ``opencode run`` mode, but the
-invocation/event shape has NOT been live-verified against a real binary
-the way codex_cli.py documents — until that verification lands,
-``headless_supported`` stays False (base-adapter conservatism; the
-capabilities matrix must never overclaim). Registered follow-up.
+commands (``commands/``), MCP servers (``opencode.json``), AGENTS.md
+instructions, and a TypeScript plugin system (``plugins/``). The
+installer adapter (installer/adapters/opencode.js) deploys the
+generated harness bundle onto those surfaces, including
+``plugins/arka.ts``, which bridges OpenCode events into
+``core.runtime.opencode_hooks`` (kb-first research gate, frontend
+gate, MCP telemetry, stop-hook compliance, compaction context).
+
+Headless invocation (live-verified against the installed binary,
+opencode 1.18.4, ``opencode run --help`` + a real probe, 2026-07-23):
+
+    opencode run --format json "<prompt>"
+
+``--format json`` prints JSONL events to stdout. Live-verified shapes:
+
+    {"type":"step_start", "sessionID":"...", "part":{...}}
+    {"type":"text","part":{"type":"text","text":"ok",...}}
+    {"type":"step_finish","part":{"reason":"stop","tokens":
+        {"total":N,"input":N,"output":N,"reasoning":N,
+         "cache":{"write":N,"read":N}},"cost":X}}
+    {"type":"error","error":{"name":"...","data":{"message":"..."}}}
+
+The error event fires with exit 1 when the user's DEFAULT model/provider
+is broken (observed live) — headless_complete surfaces that as
+LLMUnavailable with the event message. When no JSONL parses at all,
+stdout is treated as raw text with a ``len(text) // 4`` token estimate
+(same fallback as the Codex/Gemini adapters). stdin is closed explicitly
+(codex precedent — a piped stdin must never leak into the prompt).
 """
 
+import json
+import shutil
+import subprocess
 from pathlib import Path
 from os.path import expanduser
 from typing import TYPE_CHECKING
@@ -23,6 +45,13 @@ if TYPE_CHECKING:
     from core.runtime.llm_provider import LLMResponse
 
 
+# `opencode run` is a full agent turn (session bootstrap + provider
+# round-trip) — mirror the Codex budget, not the tighter Gemini one.
+_TIMEOUT_SECONDS = 120
+_TOKEN_ESTIMATE_DIVISOR = 4  # Rough chars-per-token heuristic.
+_STDERR_CLIP = 200
+
+
 class OpenCodeAdapter(RuntimeAdapter):
     """Adapter for OpenCode (terminal AI coding agent)."""
 
@@ -35,18 +64,25 @@ class OpenCodeAdapter(RuntimeAdapter):
             config_dir=config_dir,
             skills_dir=config_dir / "commands",
             settings_file=config_dir / "opencode.json",
-            supports_hooks=False,
+            supports_hooks=(config_dir / "plugins" / "arka.ts").exists(),
             supports_subagents=True,
             supports_mcp=True,
             max_context_tokens=200_000,
         )
 
     def capabilities(self) -> dict[str, bool]:
+        plugin = (
+            Path(expanduser("~")) / ".config" / "opencode" / "plugins" / "arka.ts"
+        )
         return {
             "agent_dispatch": False,  # native agents exist; no ArkaOS wiring yet
-            "headless": False,        # `opencode run` not live-verified yet
+            "headless": True,         # `opencode run` live-verified 2026-07-23
             "file_ops": True,         # terminal agent edits files natively
-            "hooks": False,           # plugins exist; no PreToolUse/Stop parity
+            # plugins/arka.ts (deployed by the installer adapter) bridges
+            # prompt/pre_tool/post_tool/idle/compact events into
+            # core.runtime.opencode_hooks — kb-first, frontend gate,
+            # telemetry, compliance. True only when actually deployed.
+            "hooks": plugin.exists(),
         }
 
     def inject_context(self, layers: dict[str, str]) -> str:
@@ -97,7 +133,7 @@ class OpenCodeAdapter(RuntimeAdapter):
         raise NotImplementedError("Use OpenCode's native content search")
 
     def headless_supported(self) -> bool:
-        return False
+        return shutil.which("opencode") is not None
 
     def headless_complete(
         self,
@@ -106,8 +142,122 @@ class OpenCodeAdapter(RuntimeAdapter):
         max_tokens: int = 2000,
         system: str = "",
     ) -> "LLMResponse":
-        raise NotImplementedError(
-            "OpenCode `opencode run` exists but its invocation/output "
-            "shape is not live-verified yet (codex_cli.py precedent). "
-            "Fall back to AnthropicDirectProvider or StubProvider."
+        """One-shot completion via `opencode run --format json`.
+
+        Verified against opencode 1.18.4 (live probe, 2026-07-23). The
+        model comes from the user's opencode config; a broken default
+        provider surfaces as an error event -> LLMUnavailable. Raises
+        LLMUnavailable on non-zero exit or timeout.
+        """
+        from core.runtime.llm_provider import LLMUnavailable
+
+        binary = shutil.which("opencode")
+        if binary is None:
+            raise NotImplementedError(
+                "opencode CLI not found on PATH — install OpenCode to "
+                "enable headless completion."
+            )
+        effective_prompt = _merge_system_prompt(prompt, system)
+        cmd = [binary, "run", "--format", "json", effective_prompt]
+        proc = _run_opencode_cli(cmd)
+        if proc.returncode != 0:
+            # The error event carries the actionable message (observed
+            # live with a broken default model); stderr is often empty.
+            event_message = _first_error_message(proc.stdout)
+            detail = event_message or proc.stderr.strip()[:_STDERR_CLIP]
+            raise LLMUnavailable(
+                f"opencode run exited {proc.returncode}: {detail}"
+            )
+        return _parse_opencode_output(proc.stdout)
+
+
+def _merge_system_prompt(prompt: str, system: str) -> str:
+    # `opencode run` takes a single message; prepend the system text so
+    # downstream behaviour matches the other adapters.
+    if not system:
+        return prompt
+    return f"{system}\n\n---\n\n{prompt}"
+
+
+def _run_opencode_cli(cmd: list[str]) -> subprocess.CompletedProcess:
+    from core.runtime.llm_provider import LLMUnavailable
+
+    try:
+        return subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=_TIMEOUT_SECONDS,
+            check=False,
+            # codex precedent: piped stdin must never leak into the run.
+            stdin=subprocess.DEVNULL,
+        )
+    except subprocess.TimeoutExpired as err:
+        raise LLMUnavailable(
+            f"opencode run timed out after {_TIMEOUT_SECONDS}s"
+        ) from err
+
+
+def _iter_events(stdout: str):
+    for line in stdout.splitlines():
+        line = line.strip()
+        if not line.startswith("{"):
+            continue
+        try:
+            yield json.loads(line)
+        except (ValueError, TypeError):
+            continue
+
+
+def _first_error_message(stdout: str) -> str:
+    for event in _iter_events(stdout):
+        if event.get("type") == "error":
+            data = (event.get("error") or {}).get("data") or {}
+            message = data.get("message") or (event.get("error") or {}).get("name")
+            if message:
+                return str(message)[:_STDERR_CLIP]
+    return ""
+
+
+def _parse_opencode_output(stdout: str) -> "LLMResponse":
+    """Parse the live-verified JSONL stream (see module docstring)."""
+    from core.runtime.llm_provider import LLMResponse, LLMUnavailable
+
+    texts: list[str] = []
+    tokens_in = 0
+    tokens_out = 0
+    cached = 0
+    saw_event = False
+    for event in _iter_events(stdout):
+        saw_event = True
+        kind = event.get("type")
+        part = event.get("part") or {}
+        if kind == "text" and part.get("type") == "text":
+            texts.append(str(part.get("text", "")))
+        elif kind == "step_finish":
+            tokens = part.get("tokens") or {}
+            tokens_in += int(tokens.get("input") or 0)
+            tokens_out += int(tokens.get("output") or 0)
+            cached += int((tokens.get("cache") or {}).get("read") or 0)
+        elif kind == "error":
+            message = _first_error_message(stdout) or "unknown opencode error"
+            raise LLMUnavailable(f"opencode run error event: {message}")
+    if saw_event:
+        return LLMResponse(
+            text="".join(texts),
+            tokens_in=tokens_in,
+            tokens_out=tokens_out,
+            cached_tokens=cached,
+            model="",  # events carry no model id (verified 1.18.4)
         )
+    # No JSONL parsed — degrade to raw text (codex/gemini fallback).
+    raw = stdout.strip()
+    return LLMResponse(
+        text=raw,
+        tokens_in=0,
+        tokens_out=max(1, len(raw) // _TOKEN_ESTIMATE_DIVISOR) if raw else 0,
+        cached_tokens=0,
+        model="",
+    )

package/core/runtime/opencode_hooks.py

@@ -0,0 +1,313 @@
+"""OpenCode plugin bridge — JSON stdin/stdout hook adapter.
+
+OpenCode has no shell-hook chain like Claude Code; its plugin system
+(TypeScript, ``~/.config/opencode/plugins/``) emits events instead. The
+``arka.ts`` plugin shells out to this module so the OpenCode runtime
+gets the same governance stack as the Claude runtime:
+
+    prompt    token-hygiene checks (UserPromptSubmit parity)
+    pre_tool  research gate + frontend gate (PreToolUse parity)
+    post_tool MCP usage telemetry (PostToolUse parity)
+    idle      kb-citation + [arka:meta] compliance (Stop-hook parity)
+    compact   gate state context (PreCompact parity)
+
+CLI contract::
+
+    echo '{"action": "pre_tool", ...}' | arka-py -m core.runtime.opencode_hooks
+
+Output is a single JSON object on stdout. The module NEVER raises and
+always exits 0 — a hook bridge must never break a turn (fail-open,
+same posture as the bash hooks it mirrors).
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+_TELEMETRY_DIR = Path.home() / ".arkaos" / "telemetry"
+_PROMPT_CACHE_DIR = Path.home() / ".arkaos" / "context-cache"
+
+_BUILTIN_MAP = {
+    "webfetch": "WebFetch",
+    "websearch": "WebSearch",
+    "edit": "Edit",
+    "write": "Write",
+    "read": "Read",
+    "bash": "Bash",
+    "grep": "Grep",
+    "glob": "Glob",
+    "task": "Task",
+}
+
+_ARG_KEY_MAP = {
+    "filePath": "file_path",
+    "newString": "new_string",
+    "oldString": "old_string",
+}
+
+_VAGUE_RE = re.compile(
+    r"\b(fix the bug|that file|esse ficheiro|esse bug|o erro|aquilo)\b",
+    re.IGNORECASE,
+)
+
+_STOPWORDS = frozenset({
+    "a", "o", "e", "de", "do", "da", "que", "em", "um", "uma", "para",
+    "com", "os", "as", "no", "na", "the", "and", "to", "of", "in", "is",
+})
+
+
+def _map_tool_name(name: str) -> str:
+    """OpenCode ``server_tool`` / builtin -> Claude-style tool name."""
+    if name in _BUILTIN_MAP:
+        return _BUILTIN_MAP[name]
+    if name.startswith("mcp__"):
+        return name
+    server, sep, tool = name.partition("_")
+    if sep and server and tool:
+        return f"mcp__{server}__{tool}"
+    return name
+
+
+def _map_args(args: dict) -> dict:
+    return {_ARG_KEY_MAP.get(k, k): v for k, v in (args or {}).items()}
+
+
+def _keywords(text: str) -> set[str]:
+    return {
+        w
+        for w in re.findall(r"[a-zA-ZÀ-ÿ]{4,}", text.lower())
+        if w not in _STOPWORDS
+    }
+
+
+def _append_jsonl(path: Path, entry: dict) -> None:
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("a", encoding="utf-8") as fh:
+            fh.write(json.dumps(entry, ensure_ascii=False) + "\n")
+    except OSError:
+        pass
+
+
+def _recent_prompts(session_id: str) -> list[str]:
+    safe = re.sub(r"[^A-Za-z0-9_-]", "", session_id or "default")
+    path = _PROMPT_CACHE_DIR / f"opencode-prompts-{safe}.json"
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return []
+
+
+def _store_prompt(session_id: str, prompt: str) -> None:
+    safe = re.sub(r"[^A-Za-z0-9_-]", "", session_id or "default")
+    path = _PROMPT_CACHE_DIR / f"opencode-prompts-{safe}.json"
+    history = _recent_prompts(session_id)
+    history.append(prompt[:500])
+    _append = history[-3:]
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(_append), encoding="utf-8")
+    except OSError:
+        pass
+
+
+def _action_prompt(payload: dict) -> dict:
+    """Token-hygiene parity (config/hooks/token-hygiene.sh)."""
+    prompt = str(payload.get("prompt", ""))
+    session_id = str(payload.get("session_id", ""))
+    suggestions: list[str] = []
+
+    ctx = payload.get("context_pct")
+    if isinstance(ctx, (int, float)):
+        if ctx > 80:
+            suggestions.append(
+                f"[arka:warn] Contexto a {int(ctx)}% — considera /compact."
+            )
+        elif ctx > 60:
+            suggestions.append(
+                f"[arka:suggest] Contexto a {int(ctx)}% — vigia o orçamento."
+            )
+
+    history = _recent_prompts(session_id)
+    if history and prompt:
+        current = _keywords(prompt)
+        if current:
+            recent = set().union(*(_keywords(p) for p in history[-3:]))
+            if recent and len(current & recent) / len(current) < 0.3:
+                suggestions.append(
+                    "[arka:suggest] Mudança de tópico — considera /clear "
+                    "para libertar contexto."
+                )
+    if prompt:
+        _store_prompt(session_id, prompt)
+
+    if len(prompt) > 2000 and "```" in prompt:
+        suggestions.append(
+            "[arka:suggest] Paste grande — usa @filepath em vez de colar "
+            "código no prompt."
+        )
+
+    if _VAGUE_RE.search(prompt) and "@" not in prompt:
+        suggestions.append(
+            "[arka:suggest] Referência vaga — usa @path para apontar o "
+            "ficheiro concreto."
+        )
+
+    return {"suggestions": suggestions}
+
+
+def _action_pre_tool(payload: dict) -> dict:
+    tool = str(payload.get("tool", ""))
+    mapped = _map_tool_name(tool)
+    session_id = str(payload.get("session_id", ""))
+    args = _map_args(payload.get("args") or {})
+
+    from core.workflow import research_gate
+
+    decision = research_gate.evaluate_research_gate(
+        mapped,
+        session_id=session_id,
+        query=str(args.get("query", "") or args.get("url", "")),
+    )
+    if not decision.allow:
+        research_gate.record_telemetry(session_id, mapped, decision)
+        return {
+            "allow": False,
+            "reason": decision.reason,
+            "message": decision.to_stderr_message(),
+        }
+    if decision.nudge:
+        research_gate.record_telemetry(session_id, mapped, decision)
+        return {
+            "allow": True,
+            "reason": decision.reason,
+            "message": decision.to_stderr_message(),
+        }
+
+    if tool in ("edit", "write"):
+        from core.workflow import frontend_gate
+
+        fe = frontend_gate.evaluate(
+            _map_tool_name(tool),
+            "",
+            session_id,
+            str(payload.get("cwd", "")),
+            args,
+            messages=payload.get("messages") or [],
+        )
+        frontend_gate.record_telemetry(session_id, mapped, fe)
+        if not fe.allow or fe.reason == "no-design-marker":
+            return {
+                "allow": fe.allow,
+                "reason": fe.reason,
+                "message": fe.to_stderr_message(),
+            }
+
+    return {"allow": True, "reason": "ok", "message": ""}
+
+
+def _action_post_tool(payload: dict) -> dict:
+    tool = str(payload.get("tool", ""))
+    mapped = _map_tool_name(tool)
+    session_id = str(payload.get("session_id", ""))
+
+    from core.runtime import mcp_telemetry
+
+    recorded = mcp_telemetry.record(mapped, session_id=session_id)
+    _append_jsonl(
+        _TELEMETRY_DIR / "opencode-tools.jsonl",
+        {
+            "ts": datetime.now(timezone.utc).isoformat(),
+            "session": session_id,
+            "tool": mapped,
+            "ok": bool(payload.get("ok", True)),
+        },
+    )
+    return {"recorded_mcp": recorded}
+
+
+def _action_idle(payload: dict) -> dict:
+    """Stop-hook parity: kb-citation + [arka:meta] compliance (soft)."""
+    text = str(payload.get("response_text", ""))
+    session_id = str(payload.get("session_id", ""))
+    nudges: list[str] = []
+
+    from core.governance import kb_cite_check
+
+    result = kb_cite_check.check_citation(text)
+    if not result.passed and result.suggestion:
+        nudges.append(result.suggestion)
+
+    if len(text) > 400 and "[arka:meta]" not in text and "[arka:trivial]" not in text:
+        nudges.append(
+            "[arka:suggest] Resposta substantiva sem tag [arka:meta] — "
+            "fecha com kb=N research=X persona=Y gap=Z critic=W."
+        )
+
+    _append_jsonl(
+        _TELEMETRY_DIR / "opencode-compliance.jsonl",
+        {
+            "ts": datetime.now(timezone.utc).isoformat(),
+            "session": session_id,
+            "kb_cite": result.reason,
+            "meta_tag": "[arka:meta]" in text,
+            "nudges": len(nudges),
+        },
+    )
+    return {"nudges": nudges}
+
+
+def _action_compact(payload: dict) -> dict:
+    """PreCompact parity: carry gate state across compaction."""
+    from core.workflow import state
+
+    context: list[str] = [
+        "## ArkaOS gate state (injected by the opencode bridge)",
+        "Obrigatório: evidence flow G1 contexto -> G2 plano (aprovação) "
+        "-> G3 execução (teste real, exit 0) -> G4 review. Emite "
+        "[arka:gate:N] em cada gate; [arka:trivial] <razão> só para "
+        "edição de 1 ficheiro < 10 linhas.",
+    ]
+    try:
+        current = state.get_state()
+        if current:
+            context.append(f"Workflow activo: {json.dumps(current)[:400]}")
+    except Exception:  # noqa: BLE001 — fail-open
+        pass
+    return {"context": context}
+
+
+_ACTIONS = {
+    "prompt": _action_prompt,
+    "pre_tool": _action_pre_tool,
+    "post_tool": _action_post_tool,
+    "idle": _action_idle,
+    "compact": _action_compact,
+}
+
+
+def main() -> int:
+    try:
+        payload = json.loads(sys.stdin.read() or "{}")
+    except json.JSONDecodeError:
+        payload = {}
+    action = str(payload.pop("action", ""))
+    handler = _ACTIONS.get(action)
+    result: dict
+    if handler is None:
+        result = {"error": f"unknown action: {action!r}"}
+    else:
+        try:
+            result = handler(payload)
+        except Exception as exc:  # noqa: BLE001 — fail-open, never block
+            result = {"error": f"{type(exc).__name__}: {exc}"}
+    sys.stdout.write(json.dumps(result, ensure_ascii=False) + "\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/harness/codex/AGENTS.md

@@ -1,6 +1,6 @@
 # ArkaOS — The Operating System for AI Agent Teams
 
-> v4.35.0 — 89 agents, 17 departments, 331 skills. Generated by `scripts/harness_gen.py`; do not edit.
+> v4.37.0 — 89 agents, 17 departments, 331 skills. Generated by `scripts/harness_gen.py`; do not edit.
 
 You are operating within ArkaOS. Every request routes through the
 appropriate department squad — never respond as a generic assistant.

package/harness/copilot/copilot-instructions.md

@@ -1,6 +1,6 @@
 # ArkaOS — The Operating System for AI Agent Teams
 
-> v4.35.0 — 89 agents, 17 departments, 331 skills. Generated by `scripts/harness_gen.py`; do not edit.
+> v4.37.0 — 89 agents, 17 departments, 331 skills. Generated by `scripts/harness_gen.py`; do not edit.
 
 You are operating within ArkaOS. Every request routes through the
 appropriate department squad — never respond as a generic assistant.