arkaos 4.3.5 → 4.4.0

package/core/sync/content_syncer.py

@@ -36,7 +36,7 @@ def sync_project_content(project: Project) -> ContentSyncResult:
 
 def _do_sync(project: Project) -> ContentSyncResult:
     core = _core_root()
-    version = (core / "VERSION").read_text().strip()
+    version = (core / "VERSION").read_text(encoding="utf-8").strip()
     project_claude = Path(project.path) / ".claude"
     project_claude.mkdir(parents=True, exist_ok=True)
 
@@ -73,28 +73,28 @@ def _sync_claude_md(
     unchanged: list[str],
     errored: list[str],
 ) -> None:
-    base = (core / "config" / "user-claude.md").read_text()
+    base = (core / "config" / "user-claude.md").read_text(encoding="utf-8")
     overlays_dir = core / "config" / "standards" / "claude-md-overlays"
     overlays: list[str] = []
     for stack in project.stack:
         overlay = overlays_dir / f"{stack}.md"
         if overlay.exists():
-            overlays.append(overlay.read_text())
+            overlays.append(overlay.read_text(encoding="utf-8"))
 
     managed_content = "\n\n".join([base, *overlays]).strip()
     target_file = project_claude / "CLAUDE.md"
-    target_text = target_file.read_text() if target_file.exists() else ""
+    target_text = target_file.read_text(encoding="utf-8") if target_file.exists() else ""
 
     result = merge_managed_content(target_text, managed_content, version)
     if result.status == "error":
         errored.append(f"CLAUDE.md: {result.error}")
         sidecar = target_file.with_suffix(".md.arkaos-new")
-        sidecar.write_text(managed_content)
+        sidecar.write_text(managed_content, encoding="utf-8")
         return
     if result.status == "unchanged":
         unchanged.append("CLAUDE.md")
         return
-    target_file.write_text(result.new_text)
+    target_file.write_text(result.new_text, encoding="utf-8")
     updated.append("CLAUDE.md")
 
 
@@ -111,11 +111,11 @@ def _sync_rules(
     dst.mkdir(parents=True, exist_ok=True)
     for rule in src.glob("*.md"):
         target = dst / rule.name
-        src_text = rule.read_text()
-        if target.exists() and target.read_text() == src_text:
+        src_text = rule.read_text(encoding="utf-8")
+        if target.exists() and target.read_text(encoding="utf-8") == src_text:
             unchanged.append(f"rules/{rule.name}")
             continue
-        target.write_text(src_text)
+        target.write_text(src_text, encoding="utf-8")
         updated.append(f"rules/{rule.name}")
 
 
@@ -131,8 +131,8 @@ def _sync_hooks(
     dst.mkdir(parents=True, exist_ok=True)
     for hook in src.glob("*.sh"):
         target = dst / hook.name
-        src_text = hook.read_text()
-        if target.exists() and target.read_text() == src_text:
+        src_text = hook.read_text(encoding="utf-8")
+        if target.exists() and target.read_text(encoding="utf-8") == src_text:
             unchanged.append(f"hooks/{hook.name}")
             continue
         shutil.copy2(hook, target)
@@ -149,16 +149,16 @@ def _sync_constitution(
 ) -> None:
     src = core / "config" / "constitution.yaml"
     target = project_claude / "constitution-applicable.md"
-    data = yaml.safe_load(src.read_text()) or {}
+    data = yaml.safe_load(src.read_text(encoding="utf-8")) or {}
     rules = data.get("rules", [])
     lines = ["# ArkaOS Constitution — Applicable Rules", ""]
     for rule in rules:
         lines.append(f"- **{rule.get('name', '?')}** — {rule.get('level', '?')}")
     body = "\n".join(lines) + "\n"
-    if target.exists() and target.read_text() == body:
+    if target.exists() and target.read_text(encoding="utf-8") == body:
         unchanged.append("constitution-applicable.md")
         return
-    target.write_text(body)
+    target.write_text(body, encoding="utf-8")
     updated.append("constitution-applicable.md")
 
 

package/core/sync/descriptor_syncer.py

@@ -47,7 +47,7 @@ def sync_descriptor(project: Project) -> DescriptorSyncResult:
 def _do_sync(project: Project) -> DescriptorSyncResult:
     """Execute the descriptor sync logic for a single project."""
     desc_path = Path(project.descriptor_path)  # type: ignore[arg-type]
-    text = desc_path.read_text()
+    text = desc_path.read_text(encoding="utf-8")
     frontmatter, body = _split_frontmatter(text)
     changes: list[str] = []
 
@@ -193,4 +193,4 @@ def _get_last_commit_days(project_path: str) -> int | None:
 def _write_descriptor(desc_path: Path, frontmatter: dict, body: str) -> None:
     """Write updated frontmatter and preserved body back to the descriptor file."""
     fm_text = yaml.dump(frontmatter, default_flow_style=False, allow_unicode=True)
-    desc_path.write_text(f"---\n{fm_text}---{body}")
+    desc_path.write_text(f"---\n{fm_text}---{body}", encoding="utf-8")

package/core/sync/discovery.py

@@ -21,7 +21,7 @@ def _detect_from_composer(project_path: Path) -> list[str]:
     if not composer.exists():
         return []
     try:
-        data = json.loads(composer.read_text())
+        data = json.loads(composer.read_text(encoding="utf-8"))
         require = data.get("require", {})
         if "laravel/framework" in require:
             return ["php", "laravel"]
@@ -35,7 +35,7 @@ def _detect_from_package_json(project_path: Path) -> list[str]:
     if not pkg.exists():
         return []
     try:
-        data = json.loads(pkg.read_text())
+        data = json.loads(pkg.read_text(encoding="utf-8"))
         deps = {
             **data.get("dependencies", {}),
             **data.get("devDependencies", {}),
@@ -100,7 +100,7 @@ def _parse_descriptor_frontmatter(text: str) -> dict:
 def _read_descriptor_item(item: Path) -> dict:
     """Read a descriptor file and return its frontmatter as a dict."""
     try:
-        return _parse_descriptor_frontmatter(item.read_text())
+        return _parse_descriptor_frontmatter(item.read_text(encoding="utf-8"))
     except OSError:
         return {}
 
@@ -187,7 +187,7 @@ def discover_from_ecosystems(ecosystems_file: Path) -> list[Project]:
     if not ecosystems_file.exists():
         return []
     try:
-        data = json.loads(ecosystems_file.read_text())
+        data = json.loads(ecosystems_file.read_text(encoding="utf-8"))
     except (json.JSONDecodeError, OSError):
         return []
 

package/core/sync/engine.py

@@ -117,7 +117,7 @@ def _read_previous_version(arkaos_home: Path) -> str:
     if not state_file.exists():
         return "pending-sync"
     try:
-        data = json.loads(state_file.read_text())
+        data = json.loads(state_file.read_text(encoding="utf-8"))
         return data.get("version", "pending-sync") or "pending-sync"
     except (json.JSONDecodeError, OSError):
         return "pending-sync"
@@ -132,7 +132,7 @@ def _read_current_version(arkaos_home: Path) -> str:
     if not version_file.exists():
         return "unknown"
     try:
-        return version_file.read_text().strip()
+        return version_file.read_text(encoding="utf-8").strip()
     except OSError:
         return "unknown"
 
@@ -143,7 +143,7 @@ def _read_repo_path(arkaos_home: Path) -> Path | None:
     if not repo_path_file.exists():
         return None
     try:
-        raw = repo_path_file.read_text().strip()
+        raw = repo_path_file.read_text(encoding="utf-8").strip()
         return Path(raw) if raw else None
     except OSError:
         return None
@@ -204,7 +204,7 @@ def _load_scan_dirs_from_profile(arkaos_home: Path) -> list[Path]:
     if not profile_file.exists():
         return []
     try:
-        data = json.loads(profile_file.read_text())
+        data = json.loads(profile_file.read_text(encoding="utf-8"))
         projects_dir_str = data.get("projectsDir", "")
         if not projects_dir_str:
             return []

package/core/sync/manifest.py

@@ -18,7 +18,7 @@ def load_features(features_dir: Path) -> list[FeatureSpec]:
     for path in sorted(features_dir.iterdir()):
         if path.suffix != ".yaml":
             continue
-        data = yaml.safe_load(path.read_text())
+        data = yaml.safe_load(path.read_text(encoding="utf-8"))
         features.append(FeatureSpec(**data))
 
     return features

package/core/sync/mcp_optimizer.py

@@ -92,7 +92,7 @@ def _load_override(project_path: Path) -> tuple[dict, list[str]]:
     if not override.exists():
         return {}, []
     try:
-        return yaml.safe_load(override.read_text()) or {}, []
+        return yaml.safe_load(override.read_text(encoding="utf-8")) or {}, []
     except (yaml.YAMLError, OSError) as exc:
         return {}, [f"override YAML parse error: {exc}"]
 
@@ -123,7 +123,7 @@ def _inject_env_vars(project_path: Path, vault_path: Path | None, project_name:
         return []
 
     try:
-        data = json.loads(mcp_file.read_text())
+        data = json.loads(mcp_file.read_text(encoding="utf-8"))
     except (json.JSONDecodeError, OSError):
         return [".mcp.json malformed; skipped env injection"]
 
@@ -137,7 +137,7 @@ def _inject_env_vars(project_path: Path, vault_path: Path | None, project_name:
     changed, missing = _merge_env(servers, merged_env)
 
     if changed:
-        mcp_file.write_text(json.dumps(data, indent=2) + "\n")
+        mcp_file.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
 
     if missing:
         _write_env_example(project_path, missing)
@@ -157,7 +157,7 @@ def _load_vault(path: Path) -> tuple[dict, list[str]]:
     if st.st_mode & (stat.S_IRWXG | stat.S_IRWXO):
         return {}, ["vault permissions too permissive (group/world readable); secrets not injected"]
     try:
-        return json.loads(path.read_text()), []
+        return json.loads(path.read_text(encoding="utf-8")), []
     except (json.JSONDecodeError, OSError):
         return {}, ["vault JSON parse error; secrets not injected"]
 
@@ -167,7 +167,7 @@ def _write_env_example(project_path: Path, missing: dict[str, str]) -> None:
     for var, server in sorted(missing.items()):
         lines.append(f"# required by {server}")
         lines.append(f"{var}=")
-    (project_path / ".env.arkaos.example").write_text("\n".join(lines) + "\n")
+    (project_path / ".env.arkaos.example").write_text("\n".join(lines) + "\n", encoding="utf-8")
 
 
 def optimize_all_mcps(

package/core/sync/mcp_syncer.py

@@ -39,7 +39,7 @@ def load_registry(registry_path: Path) -> dict:
     if not registry_path.exists():
         return {}
     try:
-        data = json.loads(registry_path.read_text())
+        data = json.loads(registry_path.read_text(encoding="utf-8"))
         return data.get("mcpServers", {})
     except (json.JSONDecodeError, OSError):
         return {}
@@ -142,7 +142,7 @@ def _read_current_mcps(mcp_file: Path) -> dict:
     if not mcp_file.exists():
         return {}
     try:
-        data = json.loads(mcp_file.read_text())
+        data = json.loads(mcp_file.read_text(encoding="utf-8"))
         return data.get("mcpServers", {})
     except (json.JSONDecodeError, OSError):
         return {}
@@ -252,4 +252,4 @@ def _build_merged(
 def _write_mcp_json(mcp_file: Path, servers: dict) -> None:
     """Write the mcpServers dict to .mcp.json with 2-space indentation."""
     payload = {"mcpServers": servers}
-    mcp_file.write_text(json.dumps(payload, indent=2) + "\n")
+    mcp_file.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")

package/core/sync/policy_loader.py

@@ -30,7 +30,7 @@ class PolicyDecision:
 
 def load_policy(path: Path) -> Policy:
     """Load and parse an mcp-policy.yaml file."""
-    data = yaml.safe_load(path.read_text()) or {}
+    data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
     rules = [
         PolicyRule(
             match=r.get("match", {}),

package/core/sync/reporter.py

@@ -74,7 +74,7 @@ def write_sync_state(state_file: Path, report: SyncReport) -> None:
         "skills_synced": len(report.skill_results),
         "errors": report.errors,
     }
-    state_file.write_text(json.dumps(state, indent=2))
+    state_file.write_text(json.dumps(state, indent=2), encoding="utf-8")
 
 
 def format_report(report: SyncReport) -> str:

package/core/sync/settings_syncer.py

@@ -82,7 +82,7 @@ def _read_current_settings(settings_file: Path) -> dict:
     if not settings_file.exists():
         return {}
     try:
-        return json.loads(settings_file.read_text())
+        return json.loads(settings_file.read_text(encoding="utf-8"))
     except (json.JSONDecodeError, OSError):
         return {}
 
@@ -118,4 +118,4 @@ def _build_merged_settings(current: dict, target_servers: list[str]) -> dict:
 def _write_settings(settings_file: Path, data: dict) -> None:
     """Create parent dirs if needed and write settings as 2-space JSON."""
     settings_file.parent.mkdir(parents=True, exist_ok=True)
-    settings_file.write_text(json.dumps(data, indent=2) + "\n")
+    settings_file.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")

package/core/terminal/session.py

@@ -21,16 +21,23 @@ Design notes
 from __future__ import annotations
 
 import errno
-import fcntl
 import os
-import pty
 import secrets
+import shutil
 import signal
 import struct
-import termios
 import time
 from typing import Any, Optional
 
+try:  # POSIX-only: the Windows backend lives in session_windows.py
+    import fcntl
+    import pty
+    import termios
+    _PTY_SUPPORTED = True
+except ModuleNotFoundError:
+    fcntl = pty = termios = None  # type: ignore[assignment]
+    _PTY_SUPPORTED = False
+
 from core.terminal import audit
 
 
@@ -39,10 +46,47 @@ class SessionCapacityError(RuntimeError):
 
 
 def _default_shell() -> str:
+    if os.name == "nt":
+        # Windows PowerShell renders reliably under ConPTY; bare cmd.exe can
+        # emit no prompt when the API is launched without an attached
+        # console, and the WindowsApps "pwsh" alias is a Store reparse point
+        # that misbehaves when spawned programmatically — so resolve the real
+        # System32 powershell.exe first.
+        return _resolve_windows_shell()
     return os.environ.get("SHELL") or "/bin/zsh"
 
 
+def _resolve_windows_shell() -> str:
+    """Pick a Windows shell that works under ConPTY, skipping Store aliases."""
+    candidates = []
+    pwsh = shutil.which("pwsh")
+    if pwsh and "windowsapps" not in pwsh.lower():
+        candidates.append(pwsh)
+    powershell = shutil.which("powershell")
+    if powershell:
+        candidates.append(powershell)
+    candidates.append(os.environ.get("COMSPEC") or "cmd.exe")
+    return candidates[0]
+
+
 def _default_cwd() -> str:
+    """Open new terminals in the user's configured projectsDir, else home.
+
+    The dashboard sends no cwd, so without this a terminal lands in the
+    home directory rather than where the operator actually works. Reads
+    the existing ~/.arkaos/profile.json projectsDir; falls back to home
+    when it is unset or missing (unchanged behaviour for that case).
+    """
+    try:
+        import json
+        profile = os.path.join(os.path.expanduser("~"), ".arkaos", "profile.json")
+        if os.path.isfile(profile):
+            with open(profile, encoding="utf-8") as fh:
+                projects_dir = json.load(fh).get("projectsDir")
+            if projects_dir and os.path.isdir(projects_dir):
+                return projects_dir
+    except Exception:
+        pass
     return os.path.expanduser("~")
 
 
@@ -251,14 +295,25 @@ class TerminalSessionManager:
         sid = secrets.token_urlsafe(8)
         chosen_shell = shell or _default_shell()
         chosen_cwd = cwd or _default_cwd()
-        session = TerminalSession(
-            session_id=sid,
-            shell=chosen_shell,
-            cwd=chosen_cwd,
-            cols=cols,
-            rows=rows,
-            scrollback_bytes=self.scrollback_bytes,
-        )
+        if not _PTY_SUPPORTED:
+            from core.terminal.session_windows import WindowsTerminalSession
+            session = WindowsTerminalSession(
+                session_id=sid,
+                shell=chosen_shell,
+                cwd=chosen_cwd,
+                cols=cols,
+                rows=rows,
+                scrollback_bytes=self.scrollback_bytes,
+            )
+        else:
+            session = TerminalSession(
+                session_id=sid,
+                shell=chosen_shell,
+                cwd=chosen_cwd,
+                cols=cols,
+                rows=rows,
+                scrollback_bytes=self.scrollback_bytes,
+            )
         self._sessions[sid] = session
         audit.log_start(sid, chosen_shell, chosen_cwd)
         return session

package/core/terminal/session_windows.py

@@ -0,0 +1,211 @@
+"""Windows PTY session backend (ConPTY via pywinpty).
+
+The POSIX backend in ``session.py`` builds on ``pty.fork`` + fcntl /
+termios, none of which exist on Windows. This module provides the same
+``TerminalSession`` surface on top of pywinpty's ConPTY wrapper, so the
+dashboard terminal works on Windows. ``TerminalSessionManager.create``
+selects it when ``os.name == "nt"``.
+
+IO model
+--------
+pywinpty's ``read`` is blocking and there is no pollable fd, so the POSIX
+approach (``loop.add_reader(master_fd)``) does not apply. Instead each
+session owns one daemon reader thread that drains the pty for the
+session's whole lifetime: it always appends to the bounded scrollback
+(so a client reconnecting after navigating away replays what it missed)
+and, when a WebSocket is attached, forwards each chunk to that single
+``listener``. Decoupling the reader from the connection avoids two
+readers racing on the same pty across a reload/supersede.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from typing import Any, Callable, Optional
+
+from core.terminal import audit
+
+DEFAULT_SCROLLBACK_BYTES = 512 * 1024
+
+
+class WindowsTerminalSession:
+    """A ConPTY-backed shell + the bookkeeping the manager relies on.
+
+    Mirrors the public surface of ``session.TerminalSession``:
+    ``read``/``write``/``resize``/``scrollback``/``is_alive``/``kill``/
+    ``to_dict`` plus the ``session_id``/``shell``/``cwd``/``exit_code``
+    attributes. ``master_fd`` is always ``-1`` — the dashboard WebSocket
+    handler uses that to pick the thread-listener pump instead of
+    ``add_reader``.
+    """
+
+    def __init__(
+        self,
+        session_id: str,
+        shell: str,
+        cwd: str,
+        cols: int = 120,
+        rows: int = 32,
+        scrollback_bytes: int = DEFAULT_SCROLLBACK_BYTES,
+    ) -> None:
+        import winpty  # lazy: the dependency is only needed on Windows
+
+        self.session_id = session_id
+        self.shell = shell
+        self.cwd = cwd
+        self.created_at = time.time()
+        self.last_activity = time.monotonic()
+        self.exit_code: Optional[int] = None
+        self.title = ""
+        self.scrollback_max = max(0, int(scrollback_bytes))
+        self._scrollback = bytearray()
+        self._closed = False
+        self.master_fd = -1  # no pollable fd on Windows
+
+        # ConPTY dimensions are (rows, cols).
+        self._proc = winpty.PtyProcess.spawn(
+            shell,
+            cwd=cwd,
+            dimensions=(max(1, int(rows)), max(1, int(cols))),
+        )
+        self.pid = self._proc.pid
+
+        self._listener: Optional[Callable[[bytes], None]] = None
+        self._lock = threading.Lock()
+        self._reader = threading.Thread(target=self._read_loop, daemon=True)
+        self._reader.start()
+
+    # -- reader thread ------------------------------------------------------
+    def _read_loop(self) -> None:
+        """Drain the pty for the session lifetime; feed scrollback + listener."""
+        while not self._closed:
+            try:
+                chunk = self._proc.read(8192)
+            except EOFError:
+                break
+            except OSError:
+                break
+            if not chunk:
+                if not self._proc_alive():
+                    break
+                continue
+            raw = chunk.encode("utf-8", "replace") if isinstance(chunk, str) else bytes(chunk)
+            self.last_activity = time.monotonic()
+            # Record + capture the listener under the lock so attach() can
+            # snapshot scrollback and start receiving with no gap and no dup.
+            with self._lock:
+                self._record(raw)
+                listener = self._listener
+            if listener is not None:
+                try:
+                    listener(raw)
+                except Exception:
+                    pass
+        self._closed = True
+
+    def attach(self, listener: Callable[[bytes], None]) -> bytes:
+        """Atomically snapshot scrollback and register the live output sink.
+
+        Returns the scrollback to replay. Any chunk recorded after this
+        snapshot is delivered to ``listener`` (no gap, no duplicate).
+        """
+        with self._lock:
+            snapshot = bytes(self._scrollback)
+            self._listener = listener
+            return snapshot
+
+    def set_listener(self, listener: Optional[Callable[[bytes], None]]) -> None:
+        """Register (or clear with ``None``) the live output sink."""
+        with self._lock:
+            self._listener = listener
+
+    def _proc_alive(self) -> bool:
+        try:
+            return self._proc.isalive()
+        except OSError:
+            return False
+
+    # -- output -------------------------------------------------------------
+    def read(self, max_bytes: int = 4096) -> bytes:
+        """Compatibility shim: a session-owned thread does the real reading.
+
+        The POSIX backend is polled via ``read``; on Windows reading happens
+        in ``_read_loop``, so direct callers get an empty read.
+        """
+        return b""
+
+    def _record(self, data: bytes) -> None:
+        if self.scrollback_max <= 0:
+            return
+        self._scrollback += data
+        if len(self._scrollback) > self.scrollback_max:
+            del self._scrollback[: -self.scrollback_max]
+
+    def scrollback(self) -> bytes:
+        return bytes(self._scrollback)
+
+    # -- input / control ----------------------------------------------------
+    def write(self, data: bytes) -> int:
+        if self._closed or not data:
+            return 0
+        text = (
+            data.decode("utf-8", "replace")
+            if isinstance(data, (bytes, bytearray))
+            else str(data)
+        )
+        try:
+            self._proc.write(text)
+        except (OSError, EOFError):
+            self._closed = True
+            return 0
+        self.last_activity = time.monotonic()
+        return len(data)
+
+    def resize(self, cols: int, rows: int) -> None:
+        if self._closed:
+            return
+        try:
+            self._proc.setwinsize(max(1, int(rows)), max(1, int(cols)))
+        except OSError:
+            pass
+
+    def is_alive(self) -> bool:
+        if self._closed:
+            return False
+        if not self._proc_alive():
+            self.exit_code = getattr(self._proc, "exitstatus", None)
+            self._closed = True
+            return False
+        return True
+
+    def kill(self, sig: Optional[int] = None) -> None:
+        self._closed = True
+        self._listener = None
+        try:
+            self._proc.terminate(force=True)
+        except Exception:
+            pass
+
+    def _close_fd(self) -> None:
+        self._listener = None
+        if not self._closed:
+            try:
+                self._proc.terminate(force=True)
+            except Exception:
+                pass
+        self._scrollback.clear()
+        self._closed = True
+
+    def to_dict(self) -> dict[str, Any]:
+        idle_s = max(0.0, time.monotonic() - self.last_activity)
+        return {
+            "session_id": self.session_id,
+            "shell": self.shell,
+            "cwd": self.cwd,
+            "title": self.title or self.session_id,
+            "created_at": self.created_at,
+            "idle_seconds": round(idle_s, 1),
+            "alive": self.is_alive(),
+            "exit_code": self.exit_code,
+        }

package/core/workflow/flow_authorization.py

@@ -42,6 +42,7 @@ from dataclasses import dataclass
 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
 
@@ -63,7 +64,7 @@ class GraceState:
 
 def _base_dir() -> Path:
     override = os.environ.get("ARKA_FLOW_AUTH_DIR", "").strip()
-    return Path(override) if override else Path("/tmp/arkaos-flow-auth")
+    return Path(override) if override else arkaos_temp_dir("arkaos-flow-auth")
 
 
 def _auth_path(session_id: str) -> Path | None:

package/core/workflow/flow_enforcer.py

@@ -25,6 +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.shared.temp_paths import arkaos_temp_dir
 from core.workflow import flow_authorization, marker_cache
 
 try:
@@ -210,7 +211,7 @@ ASSISTANT_WINDOW = 20
 CONFIG_PATH = Path.home() / ".arkaos" / "config.json"
 BYPASS_AUDIT_PATH = Path.home() / ".arkaos" / "audit" / "bypass.log"
 TELEMETRY_PATH = Path.home() / ".arkaos" / "telemetry" / "enforcement.jsonl"
-FLOW_REQUIRED_DIR = Path("/tmp/arkaos-wf-required")
+FLOW_REQUIRED_DIR = arkaos_temp_dir("arkaos-wf-required")
 
 
 @dataclass