+ 
-
+
Why | - Try it | + Dhee UI | Install | How it works | Integrations | @@ -58,32 +58,33 @@ The promise is simple: --- -## Try It +## Dhee UI -Run the built-in context-router demo. It needs no API key and no connected agent: +Run the local Dhee workspace UI. It needs no API key and no connected agent: ```bash -dhee demo token-router +dhee ui ``` -Example result: +
+ +
-```text -Dhee token-router demo - context firewall: agent sees the right thing, not everything - raw tokens: 25,208 - digest tokens: 1,742 - saved: 23,466 (93.1%) -``` ++ Watch the 13-second UI demo +
-The demo shows how Dhee handles three common agent hazards: +The UI opens on a command center, then lets you inspect: -- a noisy pytest failure log -- a large git diff -- a long source file read +- Context Firewall: token savings, digests, evidence pointers, expansions, and session history +- Repo Brain: an infinite folders canvas for linked repos, projects, active sessions, tasks, and shared context +- Handoff Hub: resumable task state without replaying the transcript +- Proof Replay: what Dhee injected, hid, digested, expanded, promoted, or rejected +- Learning Inbox: evidence-backed candidate learnings with promote/reject actions +- Portability & Trust: signed `.dheemem` export/import readiness and dry-run inspection -In each case the agent receives a useful digest, while exact raw evidence stays -behind `dhee_expand_result(ptr="...")` for explicit expansion. +The raw evidence still stays behind `dhee_expand_result(ptr="...")`; the UI +makes the routing and expansion decisions inspectable. --- @@ -110,7 +111,7 @@ Useful first commands: ```bash dhee status dhee doctor -dhee demo token-router +dhee ui dhee handoff dhee context state --card dhee runtime status diff --git a/dhee/cli.py b/dhee/cli.py index 1b65661..7d788a6 100644 --- a/dhee/cli.py +++ b/dhee/cli.py @@ -14,6 +14,7 @@ dhee handoff Emit structured resume JSON for a new harness/agent dhee harness status Show native Claude Code / Codex integration state dhee demo token-router Show how Dhee keeps raw tool output behind pointers + dhee ui Open the local Dhee dashboard dhee benchmark Run performance benchmarks dhee status Version, config, DB info """ @@ -1240,6 +1241,20 @@ def cmd_demo(args: argparse.Namespace) -> None: print(format_token_router_demo(report, show_digests=not getattr(args, "no_digests", False))) +def cmd_ui(args: argparse.Namespace) -> None: + """Run the local Dhee web UI.""" + from dhee.ui.cli import cmd_ui as run_ui + + run_ui(args) + + +def cmd_ui_build(args: argparse.Namespace) -> None: + """Build the local Dhee web UI assets.""" + from dhee.ui.cli import cmd_ui_build as run_ui_build + + run_ui_build(args) + + def cmd_status(args: argparse.Namespace) -> None: """Show version, config, DB size, detected agents, and brain health. @@ -2531,6 +2546,20 @@ def build_parser() -> argparse.ArgumentParser: p_demo.add_argument("--no-digests", action="store_true", help="Hide digest previews") p_demo.add_argument("--json", action="store_true", help="JSON output") + # ui + p_ui = sub.add_parser("ui", help="Run the local Dhee web UI") + p_ui.add_argument("--host", default="127.0.0.1", help="Bind host (loopback by default)") + p_ui.add_argument("--port", type=int, default=8787, help="Bind port") + p_ui.add_argument("--repo", help="Repo/workspace to inspect (default: cwd)") + p_ui.add_argument("--dev", action="store_true", help="Start the Vite frontend with hot reload") + p_ui.add_argument("--verbose", action="store_true", help="Show frontend logs in dev mode") + p_ui.add_argument("--open", action="store_true", help=argparse.SUPPRESS) + p_ui.add_argument("--no-open", action="store_true", help="Don't auto-open the UI in the default browser") + + p_ui_build = sub.add_parser("ui-build", help="Build the Dhee web UI assets") + p_ui_build.add_argument("--install", action="store_true", help="Force `npm install` before building") + p_ui_build.set_defaults(func=cmd_ui_build) + # list p_list = sub.add_parser("list", help="List all memories") p_list.add_argument("--user-id", default="default", help="User ID") @@ -3082,6 +3111,7 @@ def build_parser() -> argparse.ArgumentParser: "search": cmd_search, "checkpoint": cmd_checkpoint, "demo": cmd_demo, + "ui": cmd_ui, "list": cmd_list, "stats": cmd_stats, "decay": cmd_decay, diff --git a/dhee/ui/__init__.py b/dhee/ui/__init__.py new file mode 100644 index 0000000..b0fbb59 --- /dev/null +++ b/dhee/ui/__init__.py @@ -0,0 +1,20 @@ +"""Sankhya — Dhee's web UI. + +`dhee ui` starts a FastAPI server that serves the built React SPA and +exposes the Dhee substrate (memories, router stats, policy, evolution, +conflicts, tasks) as JSON endpoints. +""" + +try: + from dhee.ui.server import app, create_app # noqa: F401 +except ModuleNotFoundError: + # FastAPI is an optional dep (`pip install dhee[api]`). The package + # still imports so `dhee ui` can print a useful message. + app = None # type: ignore[assignment] + + def create_app(*args, **kwargs): # type: ignore[no-redef] + raise ModuleNotFoundError( + "dhee.ui requires fastapi + uvicorn. Install with `pip install 'dhee[api]'`." + ) + +__all__ = ["app", "create_app"] diff --git a/dhee/ui/cli.py b/dhee/ui/cli.py new file mode 100644 index 0000000..e9c768b --- /dev/null +++ b/dhee/ui/cli.py @@ -0,0 +1,171 @@ +"""`dhee ui` — start Sankhya. + +Starts the FastAPI bridge (which also serves the built SPA) on a local +port. If the SPA hasn't been built, prints the build instructions and +exits cleanly so users know exactly what to do. +""" + +from __future__ import annotations + +import argparse +import logging +import os +import subprocess +import sys +import threading +import time +import webbrowser +from pathlib import Path + +_LOOPBACK_HOSTS = {"127.0.0.1", "localhost", "::1"} + + +def _schedule_browser_open(url: str, delay: float = 1.2) -> None: + """Open the UI in the default browser shortly after startup. + + Runs in a thread so we don't block uvicorn. Silent on failure — + headless boxes (CI, servers, SSH sessions without $DISPLAY) fall + back cleanly to the printed URL. + """ + + def _run() -> None: + time.sleep(delay) + try: + webbrowser.open_new_tab(url) + except Exception: + pass + + threading.Thread(target=_run, daemon=True).start() + + +def cmd_ui(args: argparse.Namespace) -> None: + try: + import uvicorn + except ModuleNotFoundError as exc: + print("Dhee UI requires uvicorn. Install with `pip install 'dhee[api]'`.", file=sys.stderr) + raise SystemExit(1) from exc + try: + from dhee.ui.server import create_app + except ModuleNotFoundError as exc: + print("Dhee UI requires FastAPI. Install with `pip install 'dhee[api]'`.", file=sys.stderr) + raise SystemExit(1) from exc + + if args.host not in _LOOPBACK_HOSTS and os.environ.get("DHEE_UI_ALLOW_PUBLIC") != "1": + raise SystemExit( + "Refusing to expose Dhee UI on a non-loopback host. " + "Set DHEE_UI_ALLOW_PUBLIC=1 only behind a trusted auth proxy." + ) + + if getattr(args, "repo", None): + os.environ["DHEE_UI_REPO"] = str(Path(args.repo).expanduser().resolve()) + + web_dir = Path(__file__).parent / "web" + dist = web_dir / "dist" + + # Auto-fallback to dev mode if dist is missing and we're in a source tree + if not dist.exists() and not args.dev: + if (web_dir / "package.json").exists(): + print("Sankhya SPA not built. Falling back to dev mode (hot-reloading)...") + args.dev = True + else: + print(f"Sankhya SPA not built yet.") + print(f" cd {web_dir}") + print(f" npm install && npm run build") + sys.exit(1) + + logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s") + + app = create_app(serve_static=not args.dev, dev_mode=args.dev) + host_display = "127.0.0.1" if args.host in ("0.0.0.0", "::") else args.host + ui_url = f"http://{host_display}:{args.port}/" + print(f"Sankhya — Dhee UI") + print(f" API http://{args.host}:{args.port}/api") + + frontend_proc = None + if args.dev: + print(f" Dev Starting Vite frontend (http://127.0.0.1:5173)...") + print(f" Dashboard http://{args.host}:{args.port}/ (Proxied to Vite)") + try: + frontend_proc = subprocess.Popen( + ["npm", "run", "dev"], + cwd=str(web_dir), + stdout=subprocess.DEVNULL if not args.verbose else None, + stderr=subprocess.STDOUT if not args.verbose else None, + ) + except Exception as e: + print(f"Warning: Could not start frontend: {e}") + else: + print(f" Dashboard http://{args.host}:{args.port}/") + if args.host == "127.0.0.1" and args.port == 8080: + print(f" Tip: Add '127.0.0.1 dhee.ui' to /etc/hosts to use http://dhee.ui:8080/") + + should_open = not args.no_open and os.environ.get("DHEE_UI_NO_OPEN") != "1" + # Skip auto-open on headless servers (no DISPLAY on X11). + if should_open and sys.platform.startswith("linux") and not os.environ.get("DISPLAY"): + should_open = False + if should_open: + _schedule_browser_open(ui_url, delay=1.5 if args.dev else 1.0) + + try: + uvicorn.run(app, host=args.host, port=args.port, log_level="info") + finally: + if frontend_proc: + frontend_proc.terminate() + try: + frontend_proc.wait(timeout=5) + except subprocess.TimeoutExpired: + frontend_proc.kill() + + +def cmd_ui_build(args: argparse.Namespace) -> None: + web = Path(__file__).parent / "web" + if not (web / "package.json").exists(): + print(f"No package.json at {web}", file=sys.stderr) + sys.exit(1) + if args.install or not (web / "node_modules").exists(): + print("→ npm install") + subprocess.check_call(["npm", "install"], cwd=str(web)) + print("→ npm run build") + subprocess.check_call(["npm", "run", "build"], cwd=str(web)) + print("✓ Built at", web / "dist") + + +def register(sub: "argparse._SubParsersAction[argparse.ArgumentParser]") -> None: + p = sub.add_parser("ui", help="Start Sankhya (Dhee web UI)") + p.add_argument("--host", default="127.0.0.1") + p.add_argument("--port", type=int, default=8787) + p.add_argument("--repo", help="Repo/workspace to inspect (default: cwd)") + p.add_argument( + "--dev", + action="store_true", + help="Start both API bridge and Vite frontend with hot-reloading.", + ) + p.add_argument( + "--verbose", + action="store_true", + help="Show frontend (Vite) logs in dev mode.", + ) + p.add_argument( + "--no-open", + action="store_true", + help="Don't auto-open the UI in the default browser.", + ) + p.add_argument("--open", action="store_true", help=argparse.SUPPRESS) + p.set_defaults(func=cmd_ui) + + pb = sub.add_parser("ui-build", help="Build the Sankhya SPA (npm install + npm run build)") + pb.add_argument("--install", action="store_true", help="Force `npm install` even if node_modules exists") + pb.set_defaults(func=cmd_ui_build) + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(prog="dhee-ui") + sub = parser.add_subparsers(dest="command") + register(sub) + args = parser.parse_args(["ui", *(argv or sys.argv[1:])]) + args.func(args) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/dhee/ui/server.py b/dhee/ui/server.py new file mode 100644 index 0000000..ba0a24c --- /dev/null +++ b/dhee/ui/server.py @@ -0,0 +1,8102 @@ +"""FastAPI bridge between the Sankhya SPA and the Dhee substrate. + +Endpoints map the fields the prototype UI expects onto real Dhee state: + +- /api/memories FullMemory.get_all -> engram shape +- /api/memories (POST) remember() +- /api/memories/{id} DELETE archive +- /api/router/stats router.stats.compute_stats +- /api/router/policy router.policy.load + router.tune.build_report +- /api/router/tune (POST) router.tune.apply +- /api/meta-buddhi MetaBuddhi snapshot +- /api/evolution samskara / evolution log +- /api/conflicts derived from memory history +- /api/tasks shared_tasks.shared_task_snapshot +- /api/status overall health +- /api/security/api-keys encrypted API-key storage + rotation + +Honesty: where a piece of the prototype has no live adapter yet (e.g. +the curated evolution timeline with pretty labels), we synthesize a +minimal shape from real session logs and mark `live: false` on that +endpoint so the UI can show a "derived" badge. No silent mocks. +""" + +from __future__ import annotations + +import asyncio +import hashlib +import json +import logging +import os +import re +import shutil +import sqlite3 +import subprocess +import threading +import time +from collections import Counter, deque +from datetime import datetime, timedelta, timezone +from pathlib import Path +from typing import Any, Dict, List, Optional, Tuple + +from fastapi import Body, FastAPI, File, Form, HTTPException, Request, UploadFile, WebSocket, WebSocketDisconnect +from fastapi.middleware.cors import CORSMiddleware +from fastapi.responses import StreamingResponse +from fastapi.staticfiles import StaticFiles +from pydantic import AliasChoices, BaseModel, ConfigDict, Field + +log = logging.getLogger(__name__) + +_LOCAL_UI_ORIGIN_REGEX = r"https?://(localhost|127\.0\.0\.1|\[::1\])(:[0-9]+)?" +_SESSION_LOG_TAIL_BYTES = int(os.environ.get("DHEE_UI_SESSION_LOG_TAIL_BYTES", str(768 * 1024))) +_RUNTIME_MIRROR_CODEX_LIMIT = int(os.environ.get("DHEE_UI_RUNTIME_CODEX_LIMIT", "6")) +_RUNTIME_MIRROR_CLAUDE_LIMIT = int(os.environ.get("DHEE_UI_RUNTIME_CLAUDE_LIMIT", "6")) +_SESSION_LOG_PARSE_CACHE: Dict[Tuple[str, str, str], Tuple[int, int, Dict[str, Any]]] = {} +_MIRROR_RUNTIME_CACHE_TTL_SECONDS = float(os.environ.get("DHEE_UI_MIRROR_RUNTIME_TTL_SECONDS", "3")) +_MIRROR_RUNTIME_CACHE: Dict[Tuple[str, ...], Tuple[float, Dict[str, Any]]] = {} +_MIRROR_RUNTIME_LOCK = threading.Lock() +_UI_DB = None + + +class CaptureSessionStartPayload(BaseModel): + source_app: str + namespace: Optional[str] = None + metadata: Optional[Dict[str, Any]] = None + + +class CaptureSessionEndPayload(BaseModel): + session_id: Optional[str] = None + distill: bool = True + summary_hint: Optional[str] = None + + +class CaptureActionPayload(BaseModel): + session_id: str + source_app: Optional[str] = None + namespace: Optional[str] = None + created_at: Optional[str] = None + action_type: str + target: Optional[Dict[str, Any]] = None + surface: Optional[Dict[str, Any]] = None + surface_id: Optional[str] = None + surface_type: Optional[str] = None + title: Optional[str] = None + url: Optional[str] = None + path: Optional[str] = None + path_hint: Optional[List[str]] = None + previous_surface_id: Optional[str] = None + capture_mode: Optional[str] = None + confidence: Optional[float] = None + action_payload: Optional[Dict[str, Any]] = None + source_kind: Optional[str] = None + before_context: Optional[str] = None + after_context: Optional[str] = None + before_frame_ref: Optional[str] = None + after_frame_ref: Optional[str] = None + task_instruction: Optional[str] = None + recent_actions: Optional[List[str]] = None + metadata: Optional[Dict[str, Any]] = None + + +class CaptureObservationPayload(BaseModel): + session_id: str + source_app: Optional[str] = None + namespace: Optional[str] = None + created_at: Optional[str] = None + action_id: Optional[str] = None + source_kind: Optional[str] = None + kind: Optional[str] = None + text: Optional[str] = None + text_payload: Optional[str] = None + structured: Optional[Dict[str, Any]] = None + structured_payload: Optional[Dict[str, Any]] = None + confidence: Optional[float] = None + surface: Optional[Dict[str, Any]] = None + + +class RememberPayload(BaseModel): + content: str + tier: Optional[str] = None + tags: Optional[List[str]] = None + source: Optional[str] = None + + +class CaptureArtifactPayload(BaseModel): + session_id: str + source_app: Optional[str] = None + namespace: Optional[str] = None + created_at: Optional[str] = None + action_id: Optional[str] = None + content_base64: Optional[str] = None + path: Optional[str] = None + mime_type: Optional[str] = None + artifact_type: Optional[str] = None + retention: Optional[str] = None + ttl_hours: Optional[int] = None + surface: Optional[Dict[str, Any]] = None + surface_id: Optional[str] = None + surface_type: Optional[str] = None + title: Optional[str] = None + url: Optional[str] = None + path_hint: Optional[List[str]] = None + label: Optional[str] = None + metadata: Optional[Dict[str, Any]] = None + + +class CapturePreferencePayload(BaseModel): + source_app: str + enabled: bool + mode: str = "sampled" + metadata: Optional[Dict[str, Any]] = None + + +class MemoryAskPayload(BaseModel): + query: str + source_app: Optional[str] = None + limit: int = 6 + + +class AgentContextPackPayload(BaseModel): + task_instruction: str + agent_id: Optional[str] = None + source_app: Optional[str] = None + current_frame_ref: Optional[str] = None + current_context_text: Optional[str] = None + recent_actions: Optional[List[str]] = None + limit: int = 5 + + +class WorldContextPackPayload(BaseModel): + current_frame_ref: str + current_context_text: str + task_instruction: str + recent_actions: Optional[List[str]] = None + limit: int = 5 + + +class UiPayload(BaseModel): + model_config = ConfigDict(populate_by_name=True, extra="ignore") + + +class WorkspaceRootCreatePayload(UiPayload): + name: Optional[str] = Field(default=None, validation_alias=AliasChoices("name", "label")) + description: Optional[str] = None + root_path: Optional[str] = Field( + default=None, + validation_alias=AliasChoices("root_path", "rootPath", "workspace_path", "workspacePath", "path"), + ) + + +class WorkspaceRootUpdatePayload(UiPayload): + name: Optional[str] = Field(default=None, validation_alias=AliasChoices("name", "label")) + description: Optional[str] = None + + +class WorkspaceCreatePayload(UiPayload): + workspace_path: Optional[str] = Field( + default=None, + validation_alias=AliasChoices("workspace_path", "workspacePath", "root_path", "rootPath", "path"), + ) + label: Optional[str] = None + folder_path: Optional[str] = Field(default=None, validation_alias=AliasChoices("folder_path", "folderPath")) + is_primary: bool = Field(default=False, validation_alias=AliasChoices("is_primary", "isPrimary")) + folders: Optional[List[str]] = None + + +class WorkspaceFolderPayload(UiPayload): + path: Optional[str] = Field(default=None, validation_alias=AliasChoices("path", "mount_path", "mountPath", "rootPath")) + label: Optional[str] = None + + +class WorkspaceUpdatePayload(UiPayload): + label: Optional[str] = Field(default=None, validation_alias=AliasChoices("label", "name")) + description: Optional[str] = None + root_path: Optional[str] = Field( + default=None, + validation_alias=AliasChoices("root_path", "rootPath", "workspace_path", "workspacePath", "path"), + ) + + +class WorkspaceProjectCreatePayload(UiPayload): + name: Optional[str] = Field(default=None, validation_alias=AliasChoices("name", "label")) + description: Optional[str] = None + default_runtime: Optional[str] = Field(default=None, validation_alias=AliasChoices("default_runtime", "defaultRuntime")) + color: Optional[str] = None + icon: Optional[str] = None + scope_rules: Optional[List[Dict[str, Any]]] = Field(default=None, validation_alias=AliasChoices("scope_rules", "scopeRules")) + + +class WorkspaceProjectUpdatePayload(UiPayload): + name: Optional[str] = Field(default=None, validation_alias=AliasChoices("name", "label")) + description: Optional[str] = None + default_runtime: Optional[str] = Field(default=None, validation_alias=AliasChoices("default_runtime", "defaultRuntime")) + color: Optional[str] = None + icon: Optional[str] = None + scope_rules: Optional[List[Dict[str, Any]]] = Field(default=None, validation_alias=AliasChoices("scope_rules", "scopeRules")) + + +class FolderPickPayload(BaseModel): + prompt: Optional[str] = None + + +class AssetAskPayload(BaseModel): + question: str + + +class ConflictResolutionPayload(BaseModel): + action: str + merged_content: Optional[str] = None + reason: Optional[str] = None + + +class SessionLaunchPayload(BaseModel): + runtime: str + title: Optional[str] = None + permission_mode: Optional[str] = None + task_id: Optional[str] = None + project_id: Optional[str] = None + + +class WorkspaceLineMessagePayload(BaseModel): + project_id: Optional[str] = None + target_project_id: Optional[str] = None + channel: Optional[str] = None + session_id: Optional[str] = None + task_id: Optional[str] = None + message_kind: str = "update" + title: Optional[str] = None + body: str + metadata: Optional[Dict[str, Any]] = None + + +class ContextUpsertPayload(BaseModel): + context_id: Optional[str] = None + expected_content_hash: Optional[str] = None + title: str + content: str + scope: str + kind: str = "note" + project_id: Optional[str] = None + team_id: Optional[str] = None + user_id: Optional[str] = None + tags: Optional[List[str]] = None + summary: Optional[str] = None + metadata: Optional[Dict[str, Any]] = None + + +class ProposalCreatePayload(BaseModel): + title: str + content: str + scope: str + kind: str + project_id: Optional[str] = None + team_id: Optional[str] = None + proposed_by_user_id: str + supersedes_id: Optional[str] = None + tags: Optional[List[str]] = None + metadata: Optional[Dict[str, Any]] = None + + +class ProposalDecisionPayload(BaseModel): + reviewer_user_id: str + + +class FindingResolvePayload(BaseModel): + resolved_by: Optional[str] = None + + +class IntegrationPayload(BaseModel): + scope: str + target_id: str + type: str + value: Any + metadata: Optional[Dict[str, Any]] = None + + +class TeamJoinPayload(BaseModel): + org_id: str + project_id: Optional[str] = None + team_id: Optional[str] = None + role: Optional[str] = "developer" + repo_root: Optional[str] = None + + +class EnterpriseWorkspacePayload(BaseModel): + name: str + root_path: Optional[str] = None + default_branch: Optional[str] = "main" + + +class EnterpriseProjectCreatePayload(BaseModel): + name: str + project_id: Optional[str] = None + description: Optional[str] = "" + + +class ProjectTeamCreatePayload(BaseModel): + name: str + team_id: Optional[str] = None + description: Optional[str] = "" + + +class ProjectFolderAddPayload(BaseModel): + local_path: Optional[str] = None + repo_url: Optional[str] = None + label: Optional[str] = None + kind: Optional[str] = "folder" + + +class LocalContextFolderPayload(BaseModel): + path: str + shared: Optional[bool] = True + + +class TeamCollaborationPayload(BaseModel): + target_team_id: str + + +# Module-level payloads for the new workspace + context endpoints. +# These need to live outside ``create_app()`` because FastAPI's body +# resolution can't see classes that live in nested function scope when +# ``from __future__ import annotations`` defers annotation evaluation +# (the existing pattern in this file is module-level for body params, +# inline only for ad-hoc query helpers). + + +class LocalWorkspaceCreatePayload(BaseModel): + name: Optional[str] = None + id: Optional[str] = None + + +class ContextPromotePayload(BaseModel): + memory_id: str + repo: Optional[str] = None + kind: Optional[str] = "learning" + title: Optional[str] = None + + +class ContextDemotePayload(BaseModel): + entry_id: str + repo: Optional[str] = None + + +class UiLearningDecisionPayload(BaseModel): + scope: Optional[str] = "personal" + repo: Optional[str] = None + approved_by: Optional[str] = "dhee-ui" + reason: Optional[str] = None + + +class UiPortabilityExportPayload(BaseModel): + output_path: Optional[str] = None + user_id: str = "default" + repo: Optional[str] = None + + +class UiPortabilityImportPayload(BaseModel): + input_path: str + user_id: str = "default" + repo: Optional[str] = None + + +# ─── Shape helpers ──────────────────────────────────────────────────────────── + +_TIER_BY_SCORE = [ + (0.90, "canonical"), + (0.70, "high"), + (0.40, "medium"), + (0.00, "short-term"), +] + + +def _tier_for(mem: Dict[str, Any]) -> str: + meta = mem.get("metadata") or {} + explicit = meta.get("tier") or mem.get("tier") + if explicit in {"canonical", "high", "medium", "short-term", "avoid"}: + return explicit + if meta.get("avoid") or mem.get("avoid"): + return "avoid" + score = float( + mem.get("score") + or meta.get("confidence") + or meta.get("importance") + or 0.5 + ) + for threshold, tier in _TIER_BY_SCORE: + if score >= threshold: + return tier + return "short-term" + + +def _estimate_tokens(text: str) -> int: + return max(1, len(text) // 4) + + +def _engram_from_memory(mem: Dict[str, Any]) -> Dict[str, Any]: + meta = mem.get("metadata") or {} + content = mem.get("memory") or mem.get("content") or mem.get("text") or "" + created = ( + mem.get("created_at") + or mem.get("createdAt") + or meta.get("created_at") + or "" + ) + if isinstance(created, (int, float)): + created = time.strftime("%Y-%m-%d", time.localtime(float(created))) + elif isinstance(created, str) and "T" in created: + created = created.split("T", 1)[0] + decay = mem.get("decay") + if decay is None: + decay = meta.get("decay") + if decay is None: + # Flat 1.0 unless Dhee has populated a decay signal. + decay = 1.0 + tags = meta.get("tags") or mem.get("tags") or [] + if isinstance(tags, str): + tags = [t.strip() for t in tags.split(",") if t.strip()] + return { + "id": str(mem.get("id") or meta.get("id") or meta.get("memory_id") or ""), + "tier": _tier_for(mem), + "content": content, + "source": str(meta.get("source") or mem.get("source") or "dhee"), + "created": created or time.strftime("%Y-%m-%d"), + "tags": list(tags), + "decay": float(decay), + "reaffirmed": int(meta.get("reaffirmed") or mem.get("reaffirmed") or 0), + "tokens": _estimate_tokens(content), + } + + +_AUTO_MEMORY_TIER_BY_TYPE = { + "user": "high", + "feedback": "high", + "project": "medium", + "reference": "medium", +} + + +def _parse_auto_memory_file(path: Path) -> Optional[Dict[str, Any]]: + try: + text = path.read_text(encoding="utf-8") + except OSError: + return None + name = path.stem + description = "" + mem_type = "project" + body = text + if text.startswith("---"): + end = text.find("\n---", 3) + if end != -1: + header = text[3:end] + body = text[end + 4 :].lstrip("\n") + for line in header.splitlines(): + key, sep, value = line.partition(":") + if not sep: + continue + key = key.strip().lower() + value = value.strip().strip('"').strip("'") + if key == "name" and value: + name = value + elif key == "description" and value: + description = value + elif key == "type" and value: + mem_type = value + body = body.strip() + if not body and not description: + return None + content_parts: List[str] = [f"[{mem_type}] {name}"] + if description: + content_parts.append(description) + if body: + content_parts.append(body) + content = "\n\n".join(content_parts) + try: + created = datetime.fromtimestamp(path.stat().st_mtime, tz=timezone.utc).strftime("%Y-%m-%d") + except OSError: + created = time.strftime("%Y-%m-%d") + tier = _AUTO_MEMORY_TIER_BY_TYPE.get(mem_type, "medium") + file_id = hashlib.sha1(str(path).encode("utf-8")).hexdigest()[:16] + return { + "id": f"auto:{file_id}", + "tier": tier, + "content": content, + "source": "claude_auto_memory", + "created": created, + "tags": [mem_type, "auto-memory"], + "decay": 1.0, + "reaffirmed": 0, + "tokens": _estimate_tokens(content), + } + + +def _auto_memory_engrams() -> List[Dict[str, Any]]: + roots = [Path.home() / ".claude" / "projects"] + engrams: List[Dict[str, Any]] = [] + for root in roots: + if not root.is_dir(): + continue + try: + project_dirs = [p for p in root.iterdir() if p.is_dir()] + except OSError: + continue + for project_dir in project_dirs: + memory_dir = project_dir / "memory" + if not memory_dir.is_dir(): + continue + try: + files = [p for p in memory_dir.iterdir() if p.is_file() and p.suffix == ".md"] + except OSError: + continue + for path in files: + if path.name.upper() == "MEMORY.MD": + continue + eng = _parse_auto_memory_file(path) + if eng: + engrams.append(eng) + engrams.sort(key=lambda e: e.get("created") or "", reverse=True) + return engrams + + +# ─── App factory ────────────────────────────────────────────────────────────── + + +def create_app(*, serve_static: bool = True, dev_mode: bool = False) -> FastAPI: + app = FastAPI(title="Sankhya — Dhee UI", version="1.0.0") + app.add_middleware( + CORSMiddleware, + allow_origin_regex=os.environ.get("DHEE_UI_CORS_ORIGIN_REGEX") or _LOCAL_UI_ORIGIN_REGEX, + allow_credentials=False, + allow_methods=["*"], + allow_headers=["*"], + ) + + # ─── Memory ────────────────────────────────────────────────────────────── + + def _get_memory(): + from dhee.cli_config import get_memory_instance + + return get_memory_instance(None) + + _memory_os_service = None + + def _get_memory_os_service(): + nonlocal _memory_os_service + if _memory_os_service is None: + from dhee.world_memory import MemoryOSService + + _memory_os_service = MemoryOSService.from_default_runtime(memory=_get_memory()) + return _memory_os_service + + @app.get("/api/memories") + def list_memories(limit: int = 500) -> Dict[str, Any]: + try: + mem = _get_memory() + raw = mem.get_all( + user_id=os.environ.get("DHEE_UI_USER_ID", "default"), + limit=limit, + ) + # get_all returns {"results": [...]} in some codepaths + if isinstance(raw, dict): + raw = raw.get("results") or raw.get("memories") or [] + engrams = [_engram_from_memory(m) for m in raw if m] + engrams.extend(_auto_memory_engrams()) + return {"live": True, "engrams": engrams, "count": len(engrams)} + except Exception as exc: # noqa: BLE001 + log.warning("list_memories failed: %s", exc) + return {"live": False, "engrams": [], "count": 0, "error": str(exc)} + + + @app.post("/api/memories") + def remember(payload: RememberPayload) -> Dict[str, Any]: + try: + mem = _get_memory() + result = mem.add( + messages=[{"role": "user", "content": payload.content}], + user_id=os.environ.get("DHEE_UI_USER_ID", "default"), + metadata={ + "source": payload.source or "sankhya-ui", + "tier": payload.tier or "short-term", + "tags": payload.tags or [], + }, + ) + return {"ok": True, "result": result} + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=500, detail=str(exc)) from exc + + @app.delete("/api/memories/{memory_id}") + def archive_memory(memory_id: str) -> Dict[str, Any]: + try: + mem = _get_memory() + mem.delete(memory_id) + return {"ok": True, "id": memory_id} + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=500, detail=str(exc)) from exc + + # ─── Router ────────────────────────────────────────────────────────────── + + @app.get("/api/router/stats") + def router_stats(agent_id: Optional[str] = None) -> Dict[str, Any]: + try: + from dhee.router import stats as rstats + + selected_agent = None if agent_id in (None, "", "all") else agent_id + s = rstats.compute_stats(agent_id=selected_agent).to_dict() + agents = rstats.list_agent_stats() + codex_native = _router_codex_native_usage(_ui_repo()) + tools = [] + for name, calls in s.get("calls_by_tool", {}).items(): + tokens_saved = int( + s.get("est_tokens_diverted", 0) + * (calls / max(1, s.get("total_calls", 1))) + ) + tools.append( + { + "name": name, + "calls": calls, + "tokensSaved": tokens_saved, + "expansions": int( + s.get("expansion_calls", 0) + * (calls / max(1, s.get("total_calls", 1))) + ), + "avgDigest": 60, + "avgRaw": int(tokens_saved / max(1, calls)) if calls else 0, + } + ) + enterprise_saved_tokens = 0 + enterprise_saved_pct = 0.0 + enterprise_raw_tokens = 0 + enterprise_summary_tokens = 0 + enterprise_raw_fallbacks = 0 + enterprise_gate_suggestions = 0 + enterprise_gate_denials = 0 + enterprise_gate_fallbacks = 0 + return { + "live": True, + "selectedAgent": selected_agent or "all", + "sessionTokensSaved": s.get("est_tokens_diverted", 0), + "enterpriseSavedTokens": enterprise_saved_tokens, + "enterpriseSavedPct": enterprise_saved_pct, + "enterpriseRawTokens": enterprise_raw_tokens, + "enterpriseSummaryTokens": enterprise_summary_tokens, + "enterpriseRawFallbacks": enterprise_raw_fallbacks, + "enterpriseGateSuggestions": enterprise_gate_suggestions, + "enterpriseGateDenials": enterprise_gate_denials, + "enterpriseGateFallbacks": enterprise_gate_fallbacks, + "totalCalls": s.get("total_calls", 0), + "expansionRate": s.get("expansion_rate", 0.0), + "sessionCost": round( + s.get("est_tokens_diverted", 0) * 1e-6 * 3.0, 4 + ), + "estimatedFullCost": round( + (s.get("est_tokens_diverted", 0) + s.get("bytes_stored", 0) / 3.5) + * 1e-6 + * 3.0, + 4, + ), + "tools": tools, + "agents": agents, + "sessions": s.get("sessions", 0), + "bytesStored": s.get("bytes_stored", 0), + "dailySavings": _seven_day_savings(selected_agent), + "days": _seven_day_labels(), + "codexNative": codex_native, + } + except Exception as exc: # noqa: BLE001 + log.warning("router_stats failed: %s", exc) + return {"live": False, "error": str(exc)} + + @app.get("/api/router/policy") + def router_policy() -> Dict[str, Any]: + try: + from dhee.router import policy, tune + + data = policy.load() + report = tune.build_report() + prev = { + (s.tool, s.intent): s.current_depth for s in getattr(report, "suggestions", []) + } + depths_map = data.get("depths", {}) + depth_rank = {"shallow": 1, "normal": 2, "deep": 3} + policies = [] + for tool, intents in depths_map.items(): + for intent, depth in intents.items(): + expansion = 0.0 + for s in getattr(report, "suggestions", []): + if s.tool == tool and s.intent == intent: + expansion = getattr(s, "expansion_rate", 0.0) + prev_depth = prev.get((tool, intent), depth) + policies.append( + { + "intent": intent, + "label": intent.replace("_", " ").title(), + "depth": depth_rank.get(depth, 2), + "prevDepth": depth_rank.get(prev_depth, 2), + "expansionRate": expansion, + "tuned": depth != prev_depth, + "tool": tool, + } + ) + return {"live": True, "policies": policies, "raw": data} + except Exception as exc: # noqa: BLE001 + log.warning("router_policy failed: %s", exc) + return {"live": False, "policies": [], "error": str(exc)} + + @app.post("/api/router/tune") + def router_tune_apply() -> Dict[str, Any]: + try: + from dhee.router import tune + + report = tune.build_report() + applied = tune.apply(report) + return { + "ok": True, + "applied": applied, + "human": tune.format_human(report), + "suggestions": [ + { + "tool": s.tool, + "intent": s.intent, + "from": s.current_depth, + "to": s.proposed_depth, + "reason": getattr(s, "reason", ""), + } + for s in getattr(report, "suggestions", []) + ], + } + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=500, detail=str(exc)) from exc + + # ─── MetaBuddhi + Evolution ────────────────────────────────────────────── + + @app.get("/api/meta-buddhi") + def meta_buddhi_status() -> Dict[str, Any]: + try: + from dhee.core import meta_buddhi as mb + + snapshot: Dict[str, Any] = { + "status": "active", + "strategy": "Adaptive depth v2.3", + } + if hasattr(mb, "latest_snapshot"): + snapshot.update(mb.latest_snapshot() or {}) # type: ignore[attr-defined] + snapshot.setdefault("sessionInsights", 0) + snapshot.setdefault("totalInsights", 0) + snapshot.setdefault("pendingProposals", 0) + snapshot.setdefault("lastGate", "") + snapshot.setdefault("confidenceGroups", _default_confidence_groups()) + return {"live": True, **snapshot} + except Exception as exc: # noqa: BLE001 + log.warning("meta_buddhi failed: %s", exc) + return { + "live": False, + "status": "unknown", + "strategy": "—", + "sessionInsights": 0, + "totalInsights": 0, + "pendingProposals": 0, + "lastGate": "", + "confidenceGroups": _default_confidence_groups(), + "error": str(exc), + } + + @app.get("/api/evolution") + def evolution_timeline() -> Dict[str, Any]: + events = _load_evolution_events() + return {"live": bool(events), "events": events} + + # ─── Conflicts ─────────────────────────────────────────────────────────── + + @app.get("/api/conflicts") + def conflicts() -> Dict[str, Any]: + try: + mem = _get_memory() + items: List[Dict[str, Any]] = [] + supported = bool(hasattr(mem, "resolve_conflict")) + if hasattr(mem, "get_conflicts"): + items = list(mem.get_conflicts()) # type: ignore[attr-defined] + return { + "live": True, + "supported": supported, + "conflicts": items, + "resolutionMode": "native" if supported else "read-only", + } + except Exception as exc: # noqa: BLE001 + log.info("conflicts: no live adapter (%s)", exc) + return { + "live": False, + "supported": False, + "conflicts": [], + "resolutionMode": "unavailable", + } + + @app.post("/api/conflicts/{conflict_id}/resolve") + def resolve_conflict( + conflict_id: str, + payload: ConflictResolutionPayload = Body(...), + ) -> Dict[str, Any]: + try: + mem = _get_memory() + if not hasattr(mem, "resolve_conflict"): + raise HTTPException( + status_code=501, + detail="Conflict resolution is not available in this Dhee runtime yet", + ) + result = mem.resolve_conflict( # type: ignore[attr-defined] + conflict_id, + payload.action, + merged_content=payload.merged_content, + reason=payload.reason, + ) + return {"ok": True, "id": conflict_id, "action": payload.action, "result": result} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=500, detail=str(exc)) from exc + + # ─── Projects / Workspaces / Sessions ─────────────────────────────────── + + @app.get("/api/projects") + def list_projects_api() -> Dict[str, Any]: + try: + return _build_project_index_payload() + except Exception as exc: # noqa: BLE001 + log.warning("projects failed: %s", exc) + return { + "live": False, + "workspaces": [], + "currentProjectId": "", + "currentWorkspaceId": "", + "currentSessionId": "", + "error": str(exc), + } + + @app.get("/api/workspaces") + def list_workspaces_api() -> Dict[str, Any]: + try: + return _build_project_index_payload() + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/workspaces") + def create_workspace_api(payload: WorkspaceRootCreatePayload) -> Dict[str, Any]: + try: + db = _get_db() + workspace_name = _display_name(payload.name, fallback="Workspace") + if not workspace_name: + raise HTTPException(status_code=400, detail="Workspace name is required") + workspace = db.upsert_workspace( + { + "user_id": _ui_user_id(), + "name": workspace_name, + "description": payload.description, + "root_path": None, + "metadata": {"created_via": "sankhya-ui"}, + } + ) + _mirror_runtime_sessions(db) + return {"ok": True, "workspace": _workspace_summary(db, workspace)} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/legacy-projects") + def create_project_api(payload: WorkspaceRootCreatePayload) -> Dict[str, Any]: + try: + db = _get_db() + workspace_name = _display_name(payload.name, fallback_path=payload.root_path) + workspace = db.upsert_workspace( + { + "user_id": _ui_user_id(), + "name": workspace_name, + "description": payload.description, + "root_path": _abs_user_path(payload.root_path) or None, + "metadata": {"created_via": "sankhya-ui"}, + } + ) + _mirror_runtime_sessions(db, extra_paths=[_workspace_primary_path(workspace)]) + return {"ok": True, "workspace": _workspace_summary(db, workspace)} + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/legacy-projects/{project_id}") + def get_project_api(project_id: str) -> Dict[str, Any]: + try: + db = _get_db() + _mirror_runtime_sessions(db) + workspace = db.get_workspace(project_id, user_id=_ui_user_id()) + if not workspace: + raise HTTPException(status_code=404, detail="Workspace not found") + return {"live": True, "workspace": _workspace_summary(db, workspace)} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/projects/{project_id}/canvas") + def project_canvas_api(project_id: str) -> Dict[str, Any]: + try: + return _build_project_canvas_payload(project_id) + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/projects/{project_id}/workspaces") + def list_project_workspaces_api(project_id: str) -> Dict[str, Any]: + try: + db = _get_db() + _mirror_runtime_sessions(db) + rows = db.list_project_workspaces( + user_id=_ui_user_id(), + project_id=project_id, + limit=100, + ) + return { + "live": True, + "workspaces": [_workspace_summary(db, row) for row in rows], + } + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/projects/{project_id}/workspaces") + def create_project_workspace_api( + project_id: str, + payload: WorkspaceCreatePayload, + ) -> Dict[str, Any]: + try: + db = _get_db() + workspace_path = _abs_user_path(payload.workspace_path) + if not workspace_path: + raise HTTPException(status_code=400, detail="workspace_path is required") + workspace = db.upsert_project_workspace( + { + "user_id": _ui_user_id(), + "project_id": project_id, + "workspace_path": workspace_path, + "label": payload.label or (os.path.basename(workspace_path) or workspace_path), + "folder_path": payload.folder_path or ".", + "is_primary": payload.is_primary, + "metadata": { + "created_via": "sankhya-ui", + "folders": [ + {"path": os.path.abspath(os.path.expanduser(folder))} + for folder in (payload.folders or []) + if str(folder).strip() + ], + }, + } + ) + _mirror_runtime_sessions(db, extra_paths=[workspace_path]) + return {"ok": True, "workspace": _workspace_summary(db, workspace)} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/workspaces/{workspace_id}/projects") + def list_workspace_projects_api(workspace_id: str) -> Dict[str, Any]: + try: + db = _get_db() + _mirror_runtime_sessions(db) + workspace = db.get_workspace(workspace_id, user_id=_ui_user_id()) + if not workspace: + raise HTTPException(status_code=404, detail="Workspace not found") + projects = [ + _project_summary(db, project) + for project in db.list_workspace_projects( + workspace_id=workspace_id, + user_id=_ui_user_id(), + limit=100, + ) + ] + return {"live": True, "projects": projects} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/workspaces/{workspace_id}/projects") + def create_workspace_project_api( + workspace_id: str, + payload: WorkspaceProjectCreatePayload, + ) -> Dict[str, Any]: + try: + db = _get_db() + workspace = db.get_workspace(workspace_id, user_id=_ui_user_id()) + if not workspace: + raise HTTPException(status_code=404, detail="Workspace not found") + project_name = _display_name(payload.name, fallback="Project") + if not project_name: + raise HTTPException(status_code=400, detail="Project name is required") + project = db.upsert_workspace_project( + { + "workspace_id": workspace_id, + "user_id": _ui_user_id(), + "name": project_name, + "description": payload.description, + "default_runtime": payload.default_runtime or "codex", + "color": payload.color, + "icon": payload.icon, + "metadata": {"created_via": "sankhya-ui"}, + } + ) + rules = _normalize_scope_rules(payload.scope_rules) + db.replace_workspace_project_scope_rules( + project_id=str(project.get("id") or ""), + user_id=_ui_user_id(), + rules=rules, + ) + _mirror_runtime_sessions( + db, + extra_paths=[str(rule.get("path_prefix") or "") for rule in rules], + ) + return {"ok": True, "project": _project_summary(db, project)} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/projects/{project_id}") + def get_workspace_project_api(project_id: str) -> Dict[str, Any]: + try: + db = _get_db() + _mirror_runtime_sessions(db) + project = db.get_workspace_project(project_id, user_id=_ui_user_id()) + if not project: + raise HTTPException(status_code=404, detail="Project not found") + return {"live": True, "project": _project_summary(db, project)} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.patch("/api/projects/{project_id}") + def update_workspace_project_api( + project_id: str, + payload: WorkspaceProjectUpdatePayload, + ) -> Dict[str, Any]: + try: + db = _get_db() + project = db.get_workspace_project(project_id, user_id=_ui_user_id()) + if not project: + raise HTTPException(status_code=404, detail="Project not found") + updated = db.upsert_workspace_project( + { + "id": project_id, + "workspace_id": project.get("workspace_id"), + "user_id": _ui_user_id(), + "name": str(payload.name or project.get("name") or "").strip() or project.get("name"), + "description": payload.description if payload.description is not None else project.get("description"), + "default_runtime": payload.default_runtime or project.get("default_runtime") or "codex", + "color": payload.color if payload.color is not None else project.get("color"), + "icon": payload.icon if payload.icon is not None else project.get("icon"), + "metadata": dict(project.get("metadata") or {}), + } + ) + scan_paths: List[str] = [] + if payload.scope_rules is not None: + rules = _normalize_scope_rules(payload.scope_rules) + db.replace_workspace_project_scope_rules( + project_id=project_id, + user_id=_ui_user_id(), + rules=rules, + ) + scan_paths.extend(str(rule.get("path_prefix") or "") for rule in rules) + workspace = db.get_workspace(str(project.get("workspace_id") or ""), user_id=_ui_user_id()) + if workspace: + scan_paths.append(_workspace_primary_path(workspace)) + _mirror_runtime_sessions(db, extra_paths=scan_paths) + return {"ok": True, "project": _project_summary(db, updated)} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/projects/{project_id}/sessions") + def list_workspace_project_sessions_api(project_id: str) -> Dict[str, Any]: + try: + db = _get_db() + _mirror_runtime_sessions(db) + project = db.get_workspace_project(project_id, user_id=_ui_user_id()) + if not project: + raise HTTPException(status_code=404, detail="Project not found") + sessions = [ + _session_summary(db, session) + for session in _workspace_project_sessions(db, project) + ] + return {"live": True, "sessions": sessions} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/folders/pick") + def pick_folder_api(payload: Optional[FolderPickPayload] = None) -> Dict[str, Any]: + try: + prompt = (payload.prompt if payload else None) or "Select folder" + safe_prompt = prompt.replace("\\", "\\\\").replace('"', '\\"') + script = ( + f'set chosenFolder to choose folder with prompt "{safe_prompt}"\n' + "POSIX path of chosenFolder" + ) + result = subprocess.run( + ["osascript", "-e", script], + capture_output=True, + text=True, + check=False, + ) + if result.returncode != 0: + detail = (result.stderr or result.stdout or "").strip() + if "User canceled" in detail or "User cancelled" in detail: + return {"ok": False, "cancelled": True} + raise HTTPException(status_code=400, detail=detail or "Folder picker failed") + return {"ok": True, "path": (result.stdout or "").strip()} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/workspaces/{workspace_id}/folders") + @app.post("/api/workspaces/{workspace_id}/mounts") + def add_workspace_folder_api( + workspace_id: str, + payload: WorkspaceFolderPayload, + ) -> Dict[str, Any]: + try: + db = _get_db() + workspace = db.get_workspace(workspace_id, user_id=_ui_user_id()) + if not workspace: + raise HTTPException(status_code=404, detail="Workspace not found") + resolved = _abs_user_path(payload.path) + if not resolved: + raise HTTPException(status_code=400, detail="path is required") + mounts = db.list_workspace_mounts(workspace_id=workspace_id, user_id=_ui_user_id()) + if not any(str(mount.get("mount_path") or "") == resolved for mount in mounts): + db.upsert_workspace_mount( + { + "workspace_id": workspace_id, + "user_id": _ui_user_id(), + "mount_path": resolved, + "label": payload.label or os.path.basename(resolved) or resolved, + "is_primary": not mounts, + } + ) + updated = db.get_workspace(workspace_id, user_id=_ui_user_id()) + if not updated: + raise HTTPException(status_code=404, detail="Workspace not found") + _mirror_runtime_sessions(db, extra_paths=[resolved]) + return {"ok": True, "workspace": _workspace_summary(db, updated)} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.patch("/api/workspaces/{workspace_id}") + def update_workspace_api( + workspace_id: str, + payload: WorkspaceUpdatePayload, + ) -> Dict[str, Any]: + try: + db = _get_db() + workspace = db.get_workspace(workspace_id, user_id=_ui_user_id()) + if not workspace: + raise HTTPException(status_code=404, detail="Workspace not found") + next_name = str(payload.label or "").strip() or str(workspace.get("name") or "").strip() + if not next_name: + raise HTTPException(status_code=400, detail="Workspace name is required") + next_description = ( + payload.description + if payload.description is not None + else workspace.get("description") + ) + next_root = ( + _abs_user_path(payload.root_path) + if payload.root_path is not None and str(payload.root_path).strip() + else _workspace_primary_path(workspace) + ) + updated = db.upsert_workspace( + { + "id": workspace_id, + "user_id": _ui_user_id(), + "name": next_name, + "description": next_description, + "root_path": next_root, + "metadata": dict(workspace.get("metadata") or {}), + } + ) + # Keep the mount table in sync so the workspace graph, + # asset drawer path resolution, and folder list all see + # the new primary root immediately. + if payload.root_path is not None and str(payload.root_path).strip(): + resolved_root = _abs_user_path(next_root) + try: + # Demote any pre-existing primary mounts to non-primary. + for mount in db.list_workspace_mounts(workspace_id=workspace_id, user_id=_ui_user_id()): + if mount.get("is_primary") and str(mount.get("mount_path") or "") != resolved_root: + db.upsert_workspace_mount( + { + "workspace_id": workspace_id, + "user_id": _ui_user_id(), + "mount_path": str(mount.get("mount_path") or ""), + "label": mount.get("label"), + "is_primary": False, + } + ) + db.upsert_workspace_mount( + { + "workspace_id": workspace_id, + "user_id": _ui_user_id(), + "mount_path": resolved_root, + "label": os.path.basename(resolved_root.rstrip(os.sep)) or resolved_root, + "is_primary": True, + } + ) + except Exception: + pass + _mirror_runtime_sessions(db, extra_paths=[next_root]) + return {"ok": True, "workspace": _workspace_summary(db, updated)} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.delete("/api/workspaces/{workspace_id}") + def delete_workspace_api(workspace_id: str) -> Dict[str, Any]: + """Delete a workspace and everything scoped to it. + + Cascades through projects, mounts, line messages, project assets, + and session assets. We do the cascade application-side so we can + surface a friendly error if any step fails instead of leaving a + half-deleted workspace behind. + """ + try: + db = _get_db() + workspace = db.get_workspace(workspace_id, user_id=_ui_user_id()) + if not workspace: + raise HTTPException(status_code=404, detail="Workspace not found") + ok = False + if hasattr(db, "delete_workspace_cascade"): + ok = bool(db.delete_workspace_cascade(workspace_id, user_id=_ui_user_id())) + else: + raise HTTPException(status_code=501, detail="Cascade delete not supported by this DB") + return {"ok": ok, "id": workspace_id} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.delete("/api/projects/{project_id}") + def delete_project_api(project_id: str) -> Dict[str, Any]: + """Delete a project and its project-scoped assets + line messages. + + Workspace survives. Project-linked assets get their storage + files removed best-effort; anything that fails logs silently + rather than aborting the delete. + """ + try: + db = _get_db() + project = db.get_workspace_project(project_id, user_id=_ui_user_id()) + if not project: + raise HTTPException(status_code=404, detail="Project not found") + ok = False + if hasattr(db, "delete_workspace_project_cascade"): + # Best-effort asset file cleanup before the DB cascade drops rows. + try: + for asset in db.list_project_assets(project_id=project_id, user_id=_ui_user_id()): + storage_path = str(asset.get("storage_path") or "") + if storage_path and os.path.exists(storage_path): + try: + os.remove(storage_path) + except Exception: + pass + except Exception: + pass + ok = bool(db.delete_workspace_project_cascade(project_id, user_id=_ui_user_id())) + else: + raise HTTPException(status_code=501, detail="Cascade delete not supported by this DB") + return {"ok": ok, "id": project_id, "workspace_id": project.get("workspace_id")} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.delete("/api/workspaces/{workspace_id}/folders") + @app.delete("/api/workspaces/{workspace_id}/mounts") + def remove_workspace_folder_api(workspace_id: str, path: str) -> Dict[str, Any]: + try: + db = _get_db() + workspace = db.get_workspace(workspace_id, user_id=_ui_user_id()) + if not workspace: + raise HTTPException(status_code=404, detail="Workspace not found") + resolved = os.path.abspath(os.path.expanduser(path)) + mounts = _workspace_folder_mounts( + {**workspace, "mounts": db.list_workspace_mounts(workspace_id=workspace_id, user_id=_ui_user_id())} + ) + retained = [mount for mount in mounts if str(mount.get("path") or "") != resolved] + if not retained: + raise HTTPException(status_code=400, detail="Workspace must keep at least one mounted folder") + primary_mount = next((mount for mount in retained if mount.get("primary")), None) or retained[0] + for mount in mounts: + db.delete_workspace_mount( + workspace_id=workspace_id, + mount_path=str(mount.get("path") or ""), + user_id=_ui_user_id(), + ) + for mount in retained: + db.upsert_workspace_mount( + { + "workspace_id": workspace_id, + "user_id": _ui_user_id(), + "mount_path": mount["path"], + "label": mount.get("label") or os.path.basename(mount["path"]) or mount["path"], + "is_primary": mount["path"] == primary_mount["path"], + } + ) + updated = db.upsert_workspace( + { + "id": workspace_id, + "user_id": _ui_user_id(), + "name": workspace.get("name"), + "description": workspace.get("description"), + "root_path": primary_mount["path"], + "metadata": dict(workspace.get("metadata") or {}), + } + ) + return {"ok": True, "workspace": _workspace_summary(db, updated)} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/workspaces/{workspace_id}") + def get_workspace_api(workspace_id: str) -> Dict[str, Any]: + try: + db = _get_db() + _mirror_runtime_sessions(db) + return _workspace_detail_payload(db, workspace_id) + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/workspaces/{workspace_id}/sessions") + def list_workspace_sessions_api(workspace_id: str) -> Dict[str, Any]: + try: + db = _get_db() + _mirror_runtime_sessions(db) + workspace = db.get_workspace(workspace_id, user_id=_ui_user_id()) + if not workspace: + raise HTTPException(status_code=404, detail="Workspace not found") + sessions = _workspace_sessions(db, workspace)[:100] + return { + "live": True, + "sessions": [_session_summary(db, session) for session in sessions], + } + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/workspaces/{workspace_id}/canvas") + def get_workspace_canvas_api(workspace_id: str) -> Dict[str, Any]: + try: + return _build_workspace_canvas_payload(workspace_id) + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/sessions/{session_id}") + def get_session_api(session_id: str) -> Dict[str, Any]: + try: + db = _get_db() + _mirror_runtime_sessions(db) + return _session_detail_payload(db, session_id) + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/sessions/{session_id}/messages") + def get_session_messages_api(session_id: str) -> Dict[str, Any]: + try: + db = _get_db() + _mirror_runtime_sessions(db) + session = db.get_agent_session(session_id) + if not session: + raise HTTPException(status_code=404, detail="Session not found") + return {"live": True, "messages": _session_messages_from_agent_session(session)} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/sessions/{session_id}/assets") + async def upload_session_asset_api( + session_id: str, + file: UploadFile = File(...), + label: Optional[str] = Form(None), + ) -> Dict[str, Any]: + try: + db = _get_db() + session = db.get_agent_session(session_id) + if not session: + raise HTTPException(status_code=404, detail="Session not found") + asset_root = Path(_dhee_data_dir_str()) / "session_assets" / session_id + asset_root.mkdir(parents=True, exist_ok=True) + filename = os.path.basename(file.filename or "asset") + stored = asset_root / f"{int(time.time() * 1000)}-{filename}" + size_bytes = 0 + with stored.open("wb") as handle: + while True: + chunk = await file.read(1024 * 1024) + if not chunk: + break + size_bytes += len(chunk) + handle.write(chunk) + artifact_id = None + try: + from dhee.core.artifacts import ArtifactManager + + manager = ArtifactManager(db) + extracted_text = _extract_asset_text(str(stored), file.content_type) + if extracted_text: + parsed = manager.capture_host_parse( + path=str(stored), + extracted_text=extracted_text, + user_id=_ui_user_id(), + cwd=str(session.get("cwd") or session.get("workspace_id") or ""), + harness=str(session.get("runtime_id") or "dhee"), + extraction_source="sankhya-upload", + project_id=session.get("project_id"), + metadata={ + "label": label or filename, + "session_id": session_id, + "uploaded_via": "sankhya-ui", + }, + ) + artifact_id = str((parsed or {}).get("artifact_id") or "") or None + else: + attached = manager.attach( + str(stored), + user_id=_ui_user_id(), + cwd=str(session.get("cwd") or session.get("workspace_id") or ""), + harness=str(session.get("runtime_id") or "dhee"), + project_id=session.get("project_id"), + metadata={ + "label": label or filename, + "session_id": session_id, + "uploaded_via": "sankhya-ui", + }, + ) + artifact_id = str((attached or {}).get("artifact_id") or "") or None + except Exception: + artifact_id = None + asset = db.add_session_asset( + { + "project_id": session.get("project_id"), + "workspace_id": session.get("workspace_id"), + "session_id": session_id, + "user_id": _ui_user_id(), + "artifact_id": artifact_id, + "storage_path": str(stored), + "name": label or filename, + "mime_type": file.content_type, + "size_bytes": size_bytes, + "metadata": {"uploaded_via": "sankhya-ui", "original_name": filename}, + } + ) + return {"ok": True, "asset": asset} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + # --------- Project / workspace assets (PR 3) ------------------------ + # Distinct from session assets: these live with the project and are + # visible to every agent the workspace ever runs. Dedup by SHA-256 + # within (workspace, project) so re-uploads don't duplicate storage. + + async def _persist_project_asset( + *, + workspace_id: str, + project_id: Optional[str], + folder: Optional[str], + file: UploadFile, + label: Optional[str], + ) -> Dict[str, Any]: + db = _get_db() + workspace = db.get_workspace(workspace_id, user_id=_ui_user_id()) + if not workspace: + raise HTTPException(status_code=404, detail="Workspace not found") + if project_id: + project = db.get_workspace_project(project_id, user_id=_ui_user_id()) + if not project or str(project.get("workspace_id") or "") != workspace_id: + raise HTTPException(status_code=404, detail="Project not found in workspace") + + asset_root = ( + Path(_dhee_data_dir_str()) + / "project_assets" + / workspace_id + / (project_id or "_workspace") + ) + asset_root.mkdir(parents=True, exist_ok=True) + filename = os.path.basename(file.filename or "asset") + stored = asset_root / f"{int(time.time() * 1000)}-{filename}" + + size_bytes = 0 + hasher = hashlib.sha256() + with stored.open("wb") as handle: + while True: + chunk = await file.read(1024 * 1024) + if not chunk: + break + size_bytes += len(chunk) + hasher.update(chunk) + handle.write(chunk) + checksum = hasher.hexdigest() + + artifact_id: Optional[str] = None + try: + from dhee.core.artifacts import ArtifactManager + + manager = ArtifactManager(db) + extracted_text = _extract_asset_text(str(stored), file.content_type) + if extracted_text: + parsed = manager.capture_host_parse( + path=str(stored), + extracted_text=extracted_text, + user_id=_ui_user_id(), + cwd=str(workspace.get("root_path") or ""), + harness="dhee", + extraction_source="sankhya-upload", + project_id=project_id, + metadata={ + "label": label or filename, + "uploaded_via": "sankhya-ui", + "scope": "project" if project_id else "workspace", + }, + ) + artifact_id = str((parsed or {}).get("artifact_id") or "") or None + else: + attached = manager.attach( + str(stored), + user_id=_ui_user_id(), + cwd=str(workspace.get("root_path") or ""), + harness="dhee", + project_id=project_id, + metadata={ + "label": label or filename, + "uploaded_via": "sankhya-ui", + "scope": "project" if project_id else "workspace", + }, + ) + artifact_id = str((attached or {}).get("artifact_id") or "") or None + except Exception: + artifact_id = None + + asset = db.upsert_project_asset( + { + "workspace_id": workspace_id, + "project_id": project_id, + "user_id": _ui_user_id(), + "artifact_id": artifact_id, + "folder": folder, + "storage_path": str(stored), + "name": label or filename, + "mime_type": file.content_type, + "size_bytes": size_bytes, + "checksum": checksum, + "metadata": { + "uploaded_via": "sankhya-ui", + "original_name": filename, + "scope": "project" if project_id else "workspace", + }, + } + ) + + # Announce the upload on the workspace information line so sibling + # agents see that a new asset is available. + try: + from dhee.core.workspace_line import emit_agent_activity + + emit_agent_activity( + db, + user_id=_ui_user_id(), + tool_name="Upload", + packet_kind="asset_upload", + digest=f"asset uploaded · {asset.get('name')}", + cwd=str(workspace.get("root_path") or ""), + source_path=str(stored), + source_event_id=str(asset.get("id") or ""), + artifact_id=artifact_id, + harness="dhee", + agent_id="dhee", + metadata={ + "asset_id": asset.get("id"), + "scope": "project" if project_id else "workspace", + "project_id": project_id, + "workspace_id": workspace_id, + "size_bytes": size_bytes, + "checksum": checksum, + }, + ) + except Exception: + pass + + return asset + + def _project_asset_results_payload( + db: Any, asset: Dict[str, Any], *, limit: int = 16 + ) -> List[Dict[str, Any]]: + """Recent shared-task results that mention this asset's storage path. + + This is what makes the drawer feel alive: "Claude read it 4m ago", + "Codex grepped it 12m ago". We match on storage_path (exact) and + on the matching artifact_id when present, to cover the router + path (which only knows ptrs) and the hook path (which knows files). + """ + storage_path = str(asset.get("storage_path") or "") + if not storage_path: + return [] + # Match only on source_path. `shared_tasks.workspace_id` is a path + # string for router-tracked sessions, not a UUID — filtering on + # `project_assets.workspace_id` (a UUID) would always miss. + # source_path is unique enough. + try: + return db.list_shared_task_results_for_path( + user_id=_ui_user_id(), + source_path=storage_path, + limit=limit, + ) + except Exception: + return [] + + def _project_asset_to_payload(db: Any, asset: Dict[str, Any]) -> Dict[str, Any]: + return { + **asset, + "results": _project_asset_results_payload(db, asset), + } + + @app.get("/api/projects/{project_id}/assets") + def list_project_assets_api(project_id: str, limit: int = 100) -> Dict[str, Any]: + try: + db = _get_db() + project = db.get_workspace_project(project_id, user_id=_ui_user_id()) + if not project: + raise HTTPException(status_code=404, detail="Project not found") + assets = db.list_project_assets( + project_id=project_id, user_id=_ui_user_id(), limit=limit + ) + return { + "live": True, + "project_id": project_id, + "workspace_id": project.get("workspace_id"), + "assets": [_project_asset_to_payload(db, asset) for asset in assets], + } + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/projects/{project_id}/assets") + async def upload_project_asset_api( + project_id: str, + file: UploadFile = File(...), + label: Optional[str] = Form(None), + folder: Optional[str] = Form(None), + ) -> Dict[str, Any]: + try: + db = _get_db() + project = db.get_workspace_project(project_id, user_id=_ui_user_id()) + if not project: + raise HTTPException(status_code=404, detail="Project not found") + asset = await _persist_project_asset( + workspace_id=str(project.get("workspace_id") or ""), + project_id=project_id, + folder=folder, + file=file, + label=label, + ) + return {"ok": True, "asset": _project_asset_to_payload(db, asset)} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/workspaces/{workspace_id}/assets") + def list_workspace_assets_api( + workspace_id: str, + include_project_assets: bool = True, + limit: int = 200, + ) -> Dict[str, Any]: + try: + db = _get_db() + workspace = db.get_workspace(workspace_id, user_id=_ui_user_id()) + if not workspace: + raise HTTPException(status_code=404, detail="Workspace not found") + assets = db.list_workspace_assets( + workspace_id=workspace_id, + user_id=_ui_user_id(), + include_project_assets=include_project_assets, + limit=limit, + ) + return { + "live": True, + "workspace_id": workspace_id, + "assets": [_project_asset_to_payload(db, asset) for asset in assets], + } + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/workspaces/{workspace_id}/assets") + async def upload_workspace_asset_api( + workspace_id: str, + file: UploadFile = File(...), + label: Optional[str] = Form(None), + folder: Optional[str] = Form(None), + project_id: Optional[str] = Form(None), + ) -> Dict[str, Any]: + try: + db = _get_db() + asset = await _persist_project_asset( + workspace_id=workspace_id, + project_id=project_id or None, + folder=folder, + file=file, + label=label, + ) + return {"ok": True, "asset": _project_asset_to_payload(db, asset)} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.delete("/api/project-assets/{asset_id}") + def delete_project_asset_api(asset_id: str) -> Dict[str, Any]: + try: + db = _get_db() + asset = db.get_project_asset(asset_id) + if not asset: + raise HTTPException(status_code=404, detail="Asset not found") + ok = db.delete_project_asset(asset_id, user_id=_ui_user_id()) + if ok: + try: + storage_path = str(asset.get("storage_path") or "") + if storage_path and os.path.exists(storage_path): + os.remove(storage_path) + except Exception: + pass + return {"ok": bool(ok)} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/files/{file_id:path}/context") + def file_context_api(file_id: str, workspace_id: Optional[str] = None) -> Dict[str, Any]: + try: + return {"live": True, **_file_context_payload(_get_db(), file_id, workspace_id=workspace_id)} + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/assets/{asset_id}/context") + def asset_context_api(asset_id: str) -> Dict[str, Any]: + try: + return {"live": True, **_asset_context_payload(_get_db(), asset_id)} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/assets/{asset_id}/ask") + def ask_asset_api(asset_id: str, payload: AssetAskPayload) -> Dict[str, Any]: + try: + db = _get_db() + context = _asset_context_payload(db, asset_id) + asset = context.get("asset") or {} + session = context.get("session") or {} + workspace_id = str(asset.get("workspace_id") or session.get("workspace_id") or "") + if not workspace_id: + raise HTTPException(status_code=400, detail="Asset is not attached to a workspace") + question = str(payload.question or "").strip() + if not question: + raise HTTPException(status_code=400, detail="Question is required") + launch = launch_workspace_session( + workspace_id, + SessionLaunchPayload( + runtime="claude-code", + title=f"Ask {asset.get('name') or 'asset'}", + permission_mode="standard", + ), + ) + task_id = str(launch.get("task_id") or "") + if task_id: + chunk_text = "\n\n".join( + f"chunk {chunk.get('chunk_index')}: {chunk.get('content')}" + for chunk in (context.get("chunks") or [])[:4] + ).strip() + db.save_shared_task_result( + { + "shared_task_id": task_id, + "project_id": asset.get("project_id"), + "workspace_id": workspace_id, + "result_key": f"asset-ask:{asset_id}:{int(time.time())}", + "packet_kind": "note", + "tool_name": "user_note", + "result_status": "completed", + "source_path": str(asset.get("storage_path") or ""), + "artifact_id": asset.get("artifact_id"), + "digest": ( + f"Answer the following question using the attached asset '{asset.get('name')}'.\n\n" + f"Question: {question}\n\n" + f"Known extracted context:\n{chunk_text or context.get('summary') or 'No extracted text available yet.'}" + ), + "metadata": { + "source": "asset_ask", + "asset_id": asset_id, + "question": question, + }, + } + ) + return {"ok": True, "launch": launch, "asset": asset, "question": question} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + # ─── Tasks ─────────────────────────────────────────────────────────────── + + @app.get("/api/tasks") + def tasks() -> Dict[str, Any]: + """Repo-scoped shared tasks → UI task cards.""" + try: + db = _get_db() + sync = _mirror_runtime_sessions(db) + user_id = _ui_user_id() + repo = _ui_repo() + rows = db.list_shared_tasks( + user_id=user_id, + project_id=str((sync.get("project") or {}).get("id") or "") or None, + repo=repo, + limit=48, + ) + out = [ + _shared_task_to_ui_task(db, row, index=i) + for i, row in enumerate(rows) + if isinstance(row, dict) + ] + return {"live": True, "tasks": out, "repo": repo} + except Exception as exc: # noqa: BLE001 + log.warning("tasks failed: %s", exc) + return {"live": False, "tasks": [], "error": str(exc)} + + class TaskCreate(BaseModel): + title: str + harness: Optional[str] = None + + class TaskStatusUpdate(BaseModel): + status: str + + class TaskNotePayload(BaseModel): + content: str + + @app.post("/api/tasks") + def create_task(payload: TaskCreate) -> Dict[str, Any]: + try: + db = _get_db() + sync = _mirror_runtime_sessions(db) + task = db.upsert_shared_task( + { + "user_id": _ui_user_id(), + "project_id": (sync.get("project") or {}).get("id"), + "repo": _ui_repo(), + "workspace_id": (sync.get("workspace") or {}).get("id"), + "folder_path": (sync.get("workspace") or {}).get("folder_path"), + "title": payload.title, + "status": "paused", + "created_by": "sankhya-ui", + "metadata": { + "harness": _normalize_runtime(payload.harness), + "created_via": "sankhya-ui", + }, + } + ) + return { + "ok": True, + "task": _shared_task_to_ui_task(db, task, index=0), + } + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/tasks/{task_id}") + def task_detail(task_id: str, limit: int = 24) -> Dict[str, Any]: + try: + db = _get_db() + _mirror_runtime_sessions(db) + task = _get_shared_task_or_404(db, task_id) + ui_task = _shared_task_to_ui_task(db, task, index=0, result_limit=limit) + results = db.list_shared_task_results(shared_task_id=task_id, limit=limit) + return { + "live": True, + "task": ui_task, + "results": results, + "runtime": _get_runtime_status_payload(), + } + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/tasks/{task_id}/status") + def task_status_update(task_id: str, payload: TaskStatusUpdate) -> Dict[str, Any]: + try: + db = _get_db() + _mirror_runtime_sessions(db) + task = _get_shared_task_or_404(db, task_id) + status = str(payload.status or "").strip().lower() + if status not in {"active", "paused", "completed", "closed", "abandoned"}: + raise HTTPException(status_code=400, detail="Unsupported task status") + updated = _touch_shared_task( + db, + task, + status=status, + metadata_updates={"updated_via": "sankhya-ui"}, + ) + return { + "ok": True, + "task": _shared_task_to_ui_task(db, updated, index=0, result_limit=12), + } + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/tasks/{task_id}/notes") + def task_note_add(task_id: str, payload: TaskNotePayload) -> Dict[str, Any]: + try: + content = str(payload.content or "").strip() + if not content: + raise HTTPException(status_code=400, detail="content is required") + db = _get_db() + _mirror_runtime_sessions(db) + task = _get_shared_task_or_404(db, task_id) + metadata = dict(task.get("metadata") or {}) + result_id = db.save_shared_task_result( + { + "result_key": f"{task_id}:note:{int(time.time() * 1000)}", + "shared_task_id": task_id, + "user_id": _ui_user_id(), + "project_id": task.get("project_id"), + "repo": task.get("repo") or _ui_repo(), + "workspace_id": task.get("workspace_id"), + "folder_path": task.get("folder_path"), + "packet_kind": "note", + "tool_name": "user_note", + "result_status": "completed", + "digest": content, + "metadata": { + "created_via": "sankhya-ui", + "kind": "task_note", + "task_title": task.get("title"), + "harness": metadata.get("harness"), + }, + "harness": _normalize_runtime(metadata.get("harness")), + "agent_id": "sankhya-ui", + } + ) + updated = _touch_shared_task( + db, + task, + metadata_updates={"updated_via": "sankhya-ui"}, + ) + return { + "ok": True, + "task": _shared_task_to_ui_task(db, updated, index=0, result_limit=12), + "result": db.get_shared_task_result(result_id), + } + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + # ─── Pointer Capture Memory OS ───────────────────────────────────────── + + @app.post("/api/capture/session/start") + def capture_session_start(payload: CaptureSessionStartPayload) -> Dict[str, Any]: + try: + return _get_memory_os_service().start_capture_session( + user_id=_ui_user_id(), + source_app=payload.source_app, + namespace=payload.namespace, + metadata=payload.metadata, + ) + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/capture/session/{session_id}/end") + def capture_session_end(session_id: str, payload: CaptureSessionEndPayload) -> Dict[str, Any]: + try: + return _get_memory_os_service().end_capture_session( + session_id, + distill=payload.distill, + summary_hint=payload.summary_hint or "", + ) + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/capture/session/end") + def capture_session_end_legacy(payload: CaptureSessionEndPayload) -> Dict[str, Any]: + session_id = str(payload.session_id or "").strip() + if not session_id: + raise HTTPException(status_code=400, detail="session_id is required") + return capture_session_end(session_id, payload) + + @app.get("/api/capture/session/{session_id}") + def capture_session_get(session_id: str) -> Dict[str, Any]: + try: + return _get_memory_os_service().get_capture_session(session_id) + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=404, detail=str(exc)) from exc + + @app.post("/api/capture/action") + def capture_action(payload: CaptureActionPayload) -> Dict[str, Any]: + try: + return _get_memory_os_service().record_action(payload.model_dump(exclude_none=True)) + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/capture/navigation") + def capture_navigation(payload: CaptureActionPayload) -> Dict[str, Any]: + try: + return _get_memory_os_service().record_navigation(payload.model_dump(exclude_none=True)) + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/capture/observation") + def capture_observation(payload: CaptureObservationPayload) -> Dict[str, Any]: + try: + return _get_memory_os_service().record_observation(payload.model_dump(exclude_none=True)) + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/capture/artifact") + def capture_artifact(payload: CaptureArtifactPayload) -> Dict[str, Any]: + try: + return _get_memory_os_service().record_artifact(payload.model_dump(exclude_none=True)) + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/capture/timeline") + def capture_timeline(source_app: Optional[str] = None, limit: int = 30) -> Dict[str, Any]: + try: + return _get_memory_os_service().timeline( + user_id=_ui_user_id(), + source_app=source_app, + limit=limit, + ) + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/capture/preferences") + def capture_preferences() -> Dict[str, Any]: + try: + return _get_memory_os_service().list_capture_policies() + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/capture/preferences") + def capture_preferences_set(payload: CapturePreferencePayload) -> Dict[str, Any]: + try: + return _get_memory_os_service().set_capture_policy( + source_app=payload.source_app, + enabled=payload.enabled, + mode=payload.mode, + metadata=payload.metadata, + ) + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/memory/now") + def memory_now(source_app: Optional[str] = None, limit: int = 8) -> Dict[str, Any]: + try: + return _get_memory_os_service().memory_now( + user_id=_ui_user_id(), + source_app=source_app, + limit=limit, + ) + except Exception as exc: # noqa: BLE001 + return {"live": False, "memories": [], "engrams": [], "error": str(exc)} + + @app.post("/api/memory/ask") + def memory_ask(payload: MemoryAskPayload) -> Dict[str, Any]: + try: + return _get_memory_os_service().memory_ask( + user_id=_ui_user_id(), + query=payload.query, + source_app=payload.source_app, + limit=payload.limit, + ) + except Exception as exc: # noqa: BLE001 + return {"live": False, "answer": "", "memories": [], "error": str(exc)} + + @app.post("/api/world-memory/context-pack") + def world_context_pack(payload: WorldContextPackPayload) -> Dict[str, Any]: + try: + return _get_memory_os_service().world_context_pack( + user_id=_ui_user_id(), + current_frame_ref=payload.current_frame_ref, + current_context_text=payload.current_context_text, + task_instruction=payload.task_instruction, + recent_actions=payload.recent_actions, + limit=payload.limit, + ) + except Exception as exc: # noqa: BLE001 + return {"live": False, "context": [], "error": str(exc)} + + @app.post("/api/agents/context-pack") + def agents_context_pack(payload: AgentContextPackPayload) -> Dict[str, Any]: + try: + return _get_memory_os_service().agent_context_pack( + user_id=_ui_user_id(), + agent_id=payload.agent_id, + task_instruction=payload.task_instruction, + source_app=payload.source_app, + current_frame_ref=payload.current_frame_ref or "", + current_context_text=payload.current_context_text or "", + recent_actions=payload.recent_actions, + limit=payload.limit, + ) + except Exception as exc: # noqa: BLE001 + return {"live": False, "context": [], "error": str(exc)} + + # ─── Security / API Keys ──────────────────────────────────────────────── + + class ApiKeyPayload(BaseModel): + provider: str + apiKey: str + label: Optional[str] = None + + class RotateApiKeyPayload(BaseModel): + apiKey: str + label: Optional[str] = None + + @app.get("/api/security/api-keys") + def list_api_keys() -> Dict[str, Any]: + try: + from dhee import secret_store + + return {"live": True, "providers": secret_store.list_provider_statuses()} + except Exception as exc: # noqa: BLE001 + log.warning("list_api_keys failed: %s", exc) + return {"live": False, "providers": [], "error": str(exc)} + + @app.post("/api/security/api-keys") + def store_api_key(payload: ApiKeyPayload) -> Dict[str, Any]: + try: + from dhee import secret_store + + provider = secret_store.store_api_key( + payload.provider, + payload.apiKey, + label=payload.label, + ) + return {"ok": True, "provider": provider} + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/security/api-keys/{provider}/rotate") + def rotate_api_key(provider: str, payload: RotateApiKeyPayload) -> Dict[str, Any]: + try: + from dhee import secret_store + + rotated = secret_store.rotate_api_key( + provider, + payload.apiKey, + label=payload.label, + ) + return {"ok": True, "provider": rotated} + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + # ─── Status + Launch ───────────────────────────────────────────────────── + + @app.get("/api/status") + def status() -> Dict[str, Any]: + try: + from dhee.router import stats as rstats + + s = rstats.compute_stats() + return { + "ok": True, + "router": { + "sessions": s.sessions, + "calls": s.total_calls, + "tokensSaved": s.est_tokens_diverted, + }, + "dhee_data_dir": _dhee_data_dir_str(), + } + except Exception as exc: # noqa: BLE001 + return {"ok": False, "error": str(exc)} + + @app.get("/api/runtime-status") + def runtime_status() -> Dict[str, Any]: + try: + return _get_runtime_status_payload() + except Exception as exc: # noqa: BLE001 + log.warning("runtime_status failed: %s", exc) + return { + "live": False, + "repo": _ui_repo(), + "runtimes": [], + "error": str(exc), + } + + class LaunchPayload(BaseModel): + taskId: Optional[str] = None + runtime: str # claude-code | codex | both + title: Optional[str] = None + permission_mode: Optional[str] = None + + @app.post("/api/workspaces/{workspace_id}/sessions/launch") + def launch_workspace_session( + workspace_id: str, + payload: SessionLaunchPayload, + ) -> Dict[str, Any]: + runtime = _normalize_runtime(payload.runtime) + if runtime is None: + raise HTTPException(status_code=400, detail="Unsupported runtime") + try: + db = _get_db() + _mirror_runtime_sessions(db) + workspace = db.get_workspace(workspace_id, user_id=_ui_user_id()) + if not workspace: + raise HTTPException(status_code=404, detail="Workspace not found") + project = None + if payload.project_id: + project = db.get_workspace_project(payload.project_id, user_id=_ui_user_id()) + if not project: + project = _resolve_workspace_project_for_path( + db, + workspace_id=workspace_id, + path=_workspace_primary_path(workspace), + ) + if not project: + projects = db.list_workspace_projects( + workspace_id=workspace_id, + user_id=_ui_user_id(), + limit=20, + ) + project = (projects[0] if projects else None) or _ensure_unassigned_workspace_project(db, workspace) + existing = None + if payload.task_id: + existing = db.get_shared_task(payload.task_id, user_id=_ui_user_id()) + title = str(payload.title or (existing or {}).get("title") or "").strip() + if not title: + raise HTTPException(status_code=400, detail="Task title is required") + permission_mode = _normalize_permission_mode(runtime, payload.permission_mode) + native_seed = f"{runtime}:{workspace_id}:{int(time.time() * 1000)}" + session_id = _agent_session_id(runtime, native_seed) + launch_cwd = _workspace_primary_path(workspace) + scope_rules = _workspace_project_scope_rules(db, str(project.get("id") or "")) + if scope_rules: + launch_cwd = str((scope_rules[0] or {}).get("path_prefix") or launch_cwd) + task = db.upsert_shared_task( + { + "id": (existing or {}).get("id") or _session_task_id(runtime, native_seed), + "user_id": _ui_user_id(), + "project_id": project.get("id") if project else None, + "repo": _ui_repo(), + "workspace_id": workspace_id, + "folder_path": ".", + "session_id": session_id, + "thread_id": native_seed, + "runtime_id": runtime, + "native_session_id": native_seed, + "title": title, + "status": "active", + "created_by": "sankhya-ui", + "metadata": { + "harness": runtime, + "created_via": "sankhya-ui", + "launch_requested": True, + "permission_mode": permission_mode, + }, + } + ) + session = db.upsert_agent_session( + { + "id": session_id, + "project_id": project.get("id") if project else None, + "workspace_id": workspace_id, + "user_id": _ui_user_id(), + "runtime_id": runtime, + "native_session_id": native_seed, + "task_id": task.get("id"), + "title": title, + "state": "launch-requested", + "cwd": launch_cwd, + "permission_mode": permission_mode, + "updated_at": _now_iso(), + "metadata": { + "messages": [], + "recent_tools": [], + "plan": [], + "touched_files": [], + "rate_limits": {}, + "preview": "Launch requested from Dhee.", + }, + } + ) + if runtime == "claude-code": + launch_command = f'cd "{launch_cwd}" && claude' + if permission_mode == "full-access": + launch_command += " --dangerously-skip-permissions" + elif runtime == "codex": + launch_command = f'cd "{launch_cwd}" && codex' + else: + launch_command = f'cd "{launch_cwd}" && dhee install --harness all' + return { + "ok": True, + "project_id": project.get("id") if project else None, + "workspace_id": workspace_id, + "session_id": session.get("id"), + "task_id": task.get("id"), + "runtime": runtime, + "permission_mode": permission_mode, + "launch_command": launch_command, + "control_state": "mirrored", + "session": _session_summary(db, session), + "task": _shared_task_to_ui_task(db, task, index=0, result_limit=12), + } + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=500, detail=str(exc)) from exc + + @app.get("/api/workspaces/{workspace_id}/line/messages") + def list_workspace_line_messages_api( + workspace_id: str, + project_id: Optional[str] = None, + channel: Optional[str] = None, + cursor: Optional[str] = None, + limit: int = 50, + ) -> Dict[str, Any]: + try: + db = _get_db() + rows = db.list_workspace_line_messages( + workspace_id=workspace_id, + user_id=_ui_user_id(), + project_id=project_id, + channel=channel, + cursor=cursor, + limit=limit, + ) + return { + "live": True, + "messages": rows, + "nextCursor": _line_cursor(rows[-1] if rows else None), + } + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/workspaces/{workspace_id}/line/messages") + def publish_workspace_line_message_api( + workspace_id: str, + payload: WorkspaceLineMessagePayload, + ) -> Dict[str, Any]: + try: + db = _get_db() + workspace = db.get_workspace(workspace_id, user_id=_ui_user_id()) + if not workspace: + raise HTTPException(status_code=404, detail="Workspace not found") + source_project_id = str(payload.project_id or "").strip() or None + target_project_id = str(payload.target_project_id or "").strip() or None + suggested_task = None + if target_project_id and target_project_id != source_project_id: + suggested_task = _create_suggested_task_from_broadcast( + db, + workspace_id=workspace_id, + project_id=target_project_id, + source_project_id=source_project_id, + title=str(payload.title or "Workspace broadcast").strip() or "Workspace broadcast", + body=str(payload.body or "").strip(), + session_id=payload.session_id, + ) + message = db.add_workspace_line_message( + { + "workspace_id": workspace_id, + "project_id": source_project_id, + "target_project_id": target_project_id, + "user_id": _ui_user_id(), + "channel": payload.channel or ("project" if source_project_id else "workspace"), + "session_id": payload.session_id, + "task_id": (suggested_task or {}).get("id") or payload.task_id, + "message_kind": payload.message_kind, + "title": payload.title, + "body": payload.body, + "metadata": payload.metadata or {}, + } + ) + # Fan this onto the in-process bus so every SSE subscriber on + # this workspace gets it in the same tick — no 1s poll lag. + if message: + try: + from dhee.core.workspace_line_bus import publish as _publish_bus + + _publish_bus(message) + except Exception: + pass + return { + "ok": True, + "message": message, + "suggestedTask": _shared_task_to_ui_task(db, suggested_task, index=0, result_limit=8) + if suggested_task + else None, + } + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.get("/api/workspaces/{workspace_id}/line/stream") + async def workspace_line_stream_api( + workspace_id: str, + project_id: Optional[str] = None, + channel: Optional[str] = None, + cursor: Optional[str] = None, + backfill: int = 0, + ) -> StreamingResponse: + """Real-time line stream via an in-process pub/sub bus. + + Replaces the prior 1s DB-poll loop. Each subscription gets + messages pushed in the same event-loop tick as the write, with + heartbeat keep-alives every 15s. A best-effort ``backfill`` + parameter lets the client catch up on the N most recent + messages on (re)connect without a separate REST call. + """ + from dhee.core.workspace_line_bus import iter_messages + + async def gen(): + db = _get_db() + # Optional backfill — send the most recent N messages so a + # reconnect doesn't require a separate REST hop. + if backfill and backfill > 0: + try: + rows = db.list_workspace_line_messages( + workspace_id=workspace_id, + user_id=_ui_user_id(), + project_id=project_id, + channel=channel, + cursor=cursor, + limit=min(int(backfill), 100), + ) + for row in reversed(rows): + yield f"data: {json.dumps(row)}\n\n" + except Exception: + pass + + try: + async for message in iter_messages( + workspace_id=workspace_id, + project_id=project_id, + channel=channel, + ): + if message is None: + yield ": keep-alive\n\n" + else: + yield f"data: {json.dumps(message)}\n\n" + except asyncio.CancelledError: + return + + return StreamingResponse(gen(), media_type="text/event-stream") + + @app.post("/api/projects/{project_id}/tasks/from-broadcast") + def create_task_from_broadcast_api( + project_id: str, + payload: WorkspaceLineMessagePayload, + ) -> Dict[str, Any]: + try: + db = _get_db() + project = db.get_workspace_project(project_id, user_id=_ui_user_id()) + if not project: + raise HTTPException(status_code=404, detail="Project not found") + task = _create_suggested_task_from_broadcast( + db, + workspace_id=str(project.get("workspace_id") or ""), + project_id=project_id, + source_project_id=str(payload.project_id or "").strip() or None, + title=str(payload.title or "Workspace broadcast").strip() or "Workspace broadcast", + body=str(payload.body or "").strip(), + session_id=payload.session_id, + ) + return {"ok": True, "task": _shared_task_to_ui_task(db, task, index=0, result_limit=8)} + except HTTPException: + raise + except Exception as exc: # noqa: BLE001 + raise HTTPException(status_code=400, detail=str(exc)) from exc + + @app.post("/api/launch") + def launch(payload: LaunchPayload) -> Dict[str, Any]: + try: + db = _get_db() + sync = _mirror_runtime_sessions(db) + workspace_id = str((sync.get("workspace") or {}).get("id") or "") + if not workspace_id: + raise HTTPException(status_code=400, detail="No workspace available") + launched = launch_workspace_session( + workspace_id, + SessionLaunchPayload( + runtime=payload.runtime, + title=payload.title, + permission_mode=payload.permission_mode, + task_id=payload.taskId, + ), + ) + launched["taskId"] = launched.get("task_id") + launched["command"] = launched.get("launch_command") + launched["message"] = "Session prepared in Dhee. Open the native runtime with the launch command." + return launched + except HTTPException: + raise + + @app.get("/api/workspace/graph") + def workspace_graph( + workspace_id: Optional[str] = None, + project_id: Optional[str] = None, + ) -> Dict[str, Any]: + try: + if workspace_id: + return _build_workspace_canvas_payload(workspace_id, focus_project_id=project_id) + return _build_workspace_graph_payload() + except Exception as exc: # noqa: BLE001 + log.warning("workspace_graph failed: %s", exc) + return { + "live": False, + "repo": _ui_repo(), + "graph": {"nodes": [], "links": []}, + "sessions": [], + "tasks": [], + "files": [], + "workspaces": [], + "error": str(exc), + } + + # ─── Local context service used by the workspace UI ────────────────────── + + class _LocalContextStore: + def __init__(self, service: "_LocalContextService") -> None: + self.service = service + + def list_context_items(self, **kwargs: Any) -> List[Dict[str, Any]]: + rows = self.service.list_context_items() + team_id = kwargs.get("team_id") + project_id = kwargs.get("project_id") + scope = kwargs.get("scope") + if team_id: + rows = [r for r in rows if r.get("team_id") in {team_id, None, ""}] + if project_id: + rows = [r for r in rows if r.get("project_id") in {project_id, None, ""}] + if scope: + rows = [r for r in rows if r.get("scope") == scope] + return rows[: int(kwargs.get("limit") or 200)] + + def get_context_item(self, org_id: str, context_id: str) -> Optional[Dict[str, Any]]: + del org_id + for row in self.service.list_context_items(): + if str(row.get("context_id") or row.get("id") or "") == context_id: + return row + return None + + def add_context_item(self, item: Dict[str, Any]) -> Dict[str, Any]: + return self.service.add_context_item(item) + + def list_context_shares(self, **kwargs: Any) -> List[Dict[str, Any]]: + del kwargs + return [] + + def get_team(self, org_id: str, team_id: str) -> Optional[Dict[str, Any]]: + del org_id + return self.service.get_team(team_id) + + class _LocalContextService: + org_id = "local" + + def __init__(self) -> None: + self.store = _LocalContextStore(self) + + def close(self) -> None: + return + + def _state(self) -> Dict[str, Any]: + return _read_local_context_state() + + def _save(self, state: Dict[str, Any]) -> None: + _write_local_context_state(state) + + def get_context_manager(self, team_id: str) -> Dict[str, Any]: + return { + "manager_id": f"context-manager:{team_id}", + "owner_user_id": _ui_user_id(), + "display_name": "Dhee Context Manager", + "team_id": team_id, + } + + def get_team(self, team_id: str) -> Optional[Dict[str, Any]]: + state = self._state() + teams = state.get("teams") or {} + if team_id in teams: + return teams[team_id] + for row in (state.get("folders") or {}).values(): + if isinstance(row, dict) and row.get("team_id") == team_id: + return { + "team_id": team_id, + "name": team_id, + "project_id": row.get("project_id") or "local", + } + return None + + def list_context_items(self) -> List[Dict[str, Any]]: + path = Path(_ui_repo()) / ".dhee" / "context" / "entries.jsonl" + rows: List[Dict[str, Any]] = [] + if not path.exists(): + return rows + try: + for line in path.read_text(encoding="utf-8").splitlines(): + if not line.strip(): + continue + try: + item = json.loads(line) + except json.JSONDecodeError: + continue + if not isinstance(item, dict): + continue + cid = str(item.get("context_id") or item.get("id") or "") + rows.append({ + "context_id": cid or hashlib.sha1(line.encode("utf-8")).hexdigest()[:12], + "title": item.get("title") or item.get("summary") or "Repo context", + "content": item.get("content") or item.get("body") or item.get("summary") or "", + "summary": item.get("summary") or item.get("content") or "", + "scope": item.get("scope") or "repo", + "kind": item.get("kind") or item.get("type") or "note", + "project_id": item.get("project_id"), + "team_id": item.get("team_id"), + "tags": item.get("tags") or [], + "metadata": item.get("metadata") or {}, + }) + except OSError: + return [] + return rows + + def add_context_item(self, item: Dict[str, Any]) -> Dict[str, Any]: + context_id = str(item.get("context_id") or f"ctx-{hashlib.sha1(json.dumps(item, sort_keys=True, default=str).encode('utf-8')).hexdigest()[:12]}") + row = {**item, "context_id": context_id, "id": context_id, "updated_at": _now_iso()} + path = Path(_ui_repo()) / ".dhee" / "context" / "entries.jsonl" + path.parent.mkdir(parents=True, exist_ok=True) + with path.open("a", encoding="utf-8") as fh: + fh.write(json.dumps(row, sort_keys=True) + "\n") + return row + + def add_context(self, **kwargs: Any) -> Dict[str, Any]: + return self.add_context_item(kwargs) + + def propose_context(self, **kwargs: Any) -> Dict[str, Any]: + return self.add_context_item({**kwargs, "status": "proposed"}) + + def approve_proposal(self, context_id: str, reviewer_user_id: Optional[str] = None) -> Dict[str, Any]: + return {"context_id": context_id, "status": "approved", "reviewer_user_id": reviewer_user_id} + + def reject_proposal(self, context_id: str, reviewer_user_id: Optional[str] = None) -> Dict[str, Any]: + return {"context_id": context_id, "status": "rejected", "reviewer_user_id": reviewer_user_id} + + def inbox_for_viewer(self, **kwargs: Any) -> Dict[str, Any]: + del kwargs + return {"proposals": [], "findings": []} + + def resolve_finding(self, finding_id: str, resolved_by: Optional[str] = None) -> Dict[str, Any]: + return {"finding_id": finding_id, "resolved_by": resolved_by, "status": "resolved"} + + def list_backlinks(self, context_id: str, limit: int = 50) -> List[Dict[str, Any]]: + del context_id, limit + return [] + + def set_integration(self, **kwargs: Any) -> Dict[str, Any]: + return {"integration_id": hashlib.sha1(json.dumps(kwargs, sort_keys=True, default=str).encode("utf-8")).hexdigest()[:12], **kwargs} + + def create_workspace(self, name: str, root_path: Optional[str] = None, default_branch: str = "main") -> Dict[str, Any]: + state = self._state() + ws_id = _ensure_default_workspace(state) + state["workspaces"][ws_id].update({ + "id": ws_id, + "name": name or "My Workspace", + "root_path": _abs_user_path(root_path) or _ui_repo(), + "default_branch": default_branch, + "updated_at": _now_iso(), + }) + self._save(state) + return state["workspaces"][ws_id] + + def reset_workspace(self) -> Dict[str, int]: + state = self._state() + counts = { + "projects": len(state.get("projects") or {}), + "teams": len(state.get("teams") or {}), + "folders": len(state.get("folders") or {}), + } + self._save(_empty_state()) + return counts + + def create_project(self, project_id: Optional[str], name: str, description: str = "") -> Dict[str, Any]: + state = self._state() + projects = state.setdefault("projects", {}) + pid = project_id or re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-") or "local" + project = {"project_id": pid, "name": name, "description": description, "updated_at": _now_iso()} + projects[pid] = project + self._save(state) + return project + + def delete_project(self, project_id: str) -> Dict[str, Any]: + state = self._state() + (state.get("projects") or {}).pop(project_id, None) + self._save(state) + return {"project_id": project_id} + + def create_project_team(self, project_id: str, team_id: Optional[str], name: str, description: str = "") -> Dict[str, Any]: + state = self._state() + teams = state.setdefault("teams", {}) + tid = team_id or re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-") or "local-dev" + team = {"team_id": tid, "project_id": project_id, "name": name, "description": description, "updated_at": _now_iso()} + teams[tid] = team + self._save(state) + return team + + def _add_folder(self, *, project_id: Optional[str], team_id: Optional[str], local_path: Optional[str], repo_url: Optional[str], label: Optional[str], kind: str) -> Dict[str, Any]: + state = self._state() + workspace_id = _ensure_default_workspace(state) + path = _abs_user_path(local_path) or repo_url or _ui_repo() + mapping_id = _folder_node_id(path).split(":", 1)[-1] + row = { + "mapping_id": mapping_id, + "path": path, + "local_path": _abs_user_path(local_path) or None, + "repo_url": repo_url, + "label": label or _folder_label(path), + "kind": kind, + "project_id": project_id, + "team_id": team_id, + "workspace_id": workspace_id, + "shared": True, + "linked_at": _now_iso(), + "source": "ui", + } + state.setdefault("folders", {})[path] = row + self._save(state) + return {"mapping": row, "folder": row, "mapping_id": mapping_id} + + def add_team_folder(self, team_id: str, local_path: Optional[str] = None, repo_url: Optional[str] = None, label: Optional[str] = None, kind: str = "folder") -> Dict[str, Any]: + team = self.get_team(team_id) or {} + return self._add_folder(project_id=team.get("project_id"), team_id=team_id, local_path=local_path, repo_url=repo_url, label=label, kind=kind) + + def add_project_folder(self, project_id: str, local_path: Optional[str] = None, repo_url: Optional[str] = None, label: Optional[str] = None, kind: str = "folder") -> Dict[str, Any]: + return self._add_folder(project_id=project_id, team_id=None, local_path=local_path, repo_url=repo_url, label=label, kind=kind) + + def remove_project_folder(self, mapping_id: str) -> Dict[str, Any]: + state = self._state() + folders = state.get("folders") or {} + for path, row in list(folders.items()): + if isinstance(row, dict) and str(row.get("mapping_id") or _folder_node_id(path).split(":", 1)[-1]) == mapping_id: + folders.pop(path, None) + self._save(state) + return {"mapping_id": mapping_id} + raise ValueError(f"folder mapping not found: {mapping_id}") + + def add_team_collaborator(self, team_id: str, target_team_id: str) -> Dict[str, Any]: + return { + "team": self.get_team(team_id) or {"team_id": team_id}, + "target_team": self.get_team(target_team_id) or {"team_id": target_team_id}, + "collaborating_team_ids": [target_team_id], + } + + def run_ast_extraction(self, project_id: str, team_id: Optional[str] = None) -> Dict[str, Any]: + state = self._state() + folders = [ + row for row in (state.get("folders") or {}).values() + if isinstance(row, dict) + and (not project_id or row.get("project_id") in {project_id, None}) + and (not team_id or row.get("team_id") == team_id) + ] + files_seen = 0 + for row in folders: + root = _abs_user_path(row.get("local_path") or row.get("path")) + if not root or not os.path.isdir(root): + continue + for _base, dirs, files in os.walk(root): + dirs[:] = [d for d in dirs if d not in {".git", "node_modules", ".venv", "__pycache__"}] + files_seen += len(files) + if files_seen >= 1000: + break + return { + "project_id": project_id, + "team_id": team_id, + "folders_seen": len(folders), + "files_seen": files_seen, + "files_extracted": 0, + "files_cached": files_seen, + "nodes_upserted": 0, + "edges_upserted": 0, + "errors": [], + } + + def _enterprise_service() -> _LocalContextService: + return _LocalContextService() + + def _resolve_repo_pointer() -> Dict[str, Any]: + cwd = Path(os.environ.get("DHEE_UI_REPO") or os.getcwd()).resolve() + home = Path.home().resolve() + for candidate in [cwd, *cwd.parents]: + if candidate == home: + break + cfg = candidate / ".dhee" / "config.json" + if cfg.is_file(): + try: + data = json.loads(cfg.read_text(encoding="utf-8")) + return {"repo_root": str(candidate), **(data if isinstance(data, dict) else {})} + except Exception: # noqa: BLE001 + return {} + digest = hashlib.sha1(str(candidate).encode("utf-8")).hexdigest()[:16] + private_cfg = Path.home() / ".dhee" / "repo_orgs" / f"{digest}.json" + if private_cfg.is_file(): + try: + data = json.loads(private_cfg.read_text(encoding="utf-8")) + return data if isinstance(data, dict) else {} + except Exception: # noqa: BLE001 + return {} + return {} + + @app.get("/api/me") + def api_me() -> Dict[str, Any]: + pointer = _resolve_repo_pointer() + org_id = ( + pointer.get("org_id") + or os.environ.get("DHEE_UI_ORG_ID") + or "default" + ) + user_id = _ui_user_id() + team_id = pointer.get("team_id") + team_ids = [team_id] if team_id else [] + # role defaults to developer; manager flag flips when this user is the + # team's assigned context_manager.owner_user_id. + role = pointer.get("default_role") or "developer" + try: + svc = _enterprise_service() + try: + if team_id: + mgr = svc.get_context_manager(team_id) + if mgr and ( + mgr.get("owner_user_id") == user_id + or mgr.get("manager_id") == user_id + ): + role = "manager" + finally: + svc.close() + except Exception: # noqa: BLE001 + pass + return { + "live": True, + "user_id": user_id, + "org_id": org_id, + "project_id": pointer.get("project_id"), + "team_id": team_id, + "team_ids": team_ids, + "role": role, + "repo_root": str(pointer.get("repo_root") or _ui_repo()), + } + + @app.get("/api/continuity") + def api_continuity() -> Dict[str, Any]: + repo = _ui_repo() + pointer = _resolve_repo_pointer() + last_session: Optional[Dict[str, Any]] = None + error = "" + try: + from dhee.core.kernel import get_last_session + + last_session = get_last_session( + agent_id="claude-code", + repo=repo, + fallback_log_recovery=True, + user_id=_ui_user_id(), + requester_agent_id="dhee-ui", + ) + except Exception as exc: # noqa: BLE001 + error = str(exc) + try: + claude_sessions = _find_claude_sessions(repo, limit=5) + except Exception: # noqa: BLE001 + claude_sessions = [] + return { + "live": bool(last_session or claude_sessions), + "repo": repo, + "repo_config": pointer, + "last_session": last_session, + "claude_sessions": claude_sessions, + "error": error or None, + } + + # ── Local-context state file: workspaces + folders ─────────────── + # v1 schema (legacy): {"folders": {path: {...}}} + # v2 schema (now): {"schema_version": 2, + # "workspaces": {ws_id: {"name": ..., "created_at": ...}}, + # "folders": {path: {workspace_id: ws_id, ...}}} + # Reads accept both shapes. Writes always emit v2. Multi-workspace + # is supported in storage today; the create endpoint enforces a + # single-workspace cap so the UI stays simple — lift the cap by + # changing one constant when we're ready. + + LOCAL_CONTEXT_SCHEMA_VERSION = 2 + DEFAULT_WORKSPACE_ID = "default" + MAX_WORKSPACES = 1 # raise this when we ship multi-workspace UX + + def _local_context_state_path() -> Path: + return Path.home() / ".dhee" / "local_context_folders.json" + + def _empty_state() -> Dict[str, Any]: + return { + "schema_version": LOCAL_CONTEXT_SCHEMA_VERSION, + "workspaces": {}, + "folders": {}, + "projects": {}, + "teams": {}, + } + + def _read_local_context_state() -> Dict[str, Any]: + path = _local_context_state_path() + if not path.exists(): + return _empty_state() + try: + data = json.loads(path.read_text(encoding="utf-8")) + except Exception: # noqa: BLE001 + return _empty_state() + if not isinstance(data, dict): + return _empty_state() + + folders_raw = data.get("folders") + folders = folders_raw if isinstance(folders_raw, dict) else {} + + workspaces_raw = data.get("workspaces") + workspaces = workspaces_raw if isinstance(workspaces_raw, dict) else {} + + # v1 → v2 migration: any pre-existing folders implicitly join + # the default workspace. We auto-create that workspace here so + # the rest of the code can assume every folder has one. + if folders and not workspaces: + workspaces = { + DEFAULT_WORKSPACE_ID: { + "id": DEFAULT_WORKSPACE_ID, + "name": "My Workspace", + "created_at": _now_iso(), + } + } + + # Stamp every folder with a workspace_id so reads never have to + # guess. Doesn't persist until the next write — that's fine. + for fpath, frow in list(folders.items()): + if not isinstance(frow, dict): + continue + if not frow.get("workspace_id"): + frow["workspace_id"] = ( + next(iter(workspaces)) if workspaces else DEFAULT_WORKSPACE_ID + ) + + out = { + "schema_version": LOCAL_CONTEXT_SCHEMA_VERSION, + "workspaces": workspaces, + "folders": folders, + } + for key in ("projects", "teams", "collaborators"): + if isinstance(data.get(key), dict): + out[key] = data[key] + return out + + def _ensure_default_workspace(state: Dict[str, Any]) -> str: + """Make sure the state has at least one workspace; return its id. + + Single-workspace mode means: if no workspace exists yet, the + first folder add creates the default one. The cap is enforced + on explicit ``/api/workspace/create`` calls only; auto-creating + the implicit default never hits the cap. + """ + workspaces = state.get("workspaces") or {} + if not isinstance(workspaces, dict): + workspaces = {} + state["workspaces"] = workspaces + if workspaces: + return next(iter(workspaces)) + ws_id = DEFAULT_WORKSPACE_ID + workspaces[ws_id] = { + "id": ws_id, + "name": "My Workspace", + "created_at": _now_iso(), + } + return ws_id + + def _write_local_context_state(state: Dict[str, Any]) -> None: + path = _local_context_state_path() + path.parent.mkdir(parents=True, exist_ok=True) + # Always normalise on write so the disk format is exactly v2. + out = { + "schema_version": LOCAL_CONTEXT_SCHEMA_VERSION, + "workspaces": state.get("workspaces") or {}, + "folders": state.get("folders") or {}, + } + for key in ("projects", "teams", "collaborators"): + if isinstance(state.get(key), dict): + out[key] = state[key] + path.write_text(json.dumps(out, indent=2, sort_keys=True), encoding="utf-8") + + def _folder_node_id(path: str) -> str: + digest = hashlib.sha1(path.encode("utf-8")).hexdigest()[:14] + return f"folder:{digest}" + + def _session_node_id(session: Dict[str, Any]) -> str: + return str(session.get("id") or session.get("nativeSessionId") or hashlib.sha1( + json.dumps(session, sort_keys=True, default=str).encode("utf-8") + ).hexdigest()[:14]) + + def _folder_label(path: str) -> str: + return os.path.basename(path.rstrip(os.sep)) or path + + def _path_is_within(path: str, root: str) -> bool: + try: + return os.path.commonpath([path, root]) == root + except ValueError: + return False + + git_root_cache: Dict[str, str] = {} + + def _git_root_for_path(path: str) -> str: + resolved = _abs_user_path(path) + if not resolved: + return "" + probe = resolved if os.path.isdir(resolved) else os.path.dirname(resolved) + if not probe: + return "" + cached = git_root_cache.get(probe) + if cached is not None: + return cached + try: + result = subprocess.run( + ["git", "-C", probe, "rev-parse", "--show-toplevel"], + capture_output=True, + text=True, + check=False, + timeout=0.8, + ) + except Exception: # noqa: BLE001 + git_root_cache[probe] = "" + return "" + if result.returncode != 0: + git_root_cache[probe] = "" + return "" + git_root_cache[probe] = _abs_user_path((result.stdout or "").strip()) or "" + return git_root_cache[probe] + + def _best_configured_root(path: str, configured_paths: List[str]) -> str: + best = "" + best_len = -1 + for folder in configured_paths: + try: + common = os.path.commonpath([path, folder]) + except ValueError: + continue + if common == folder and len(folder) > best_len: + best = folder + best_len = len(folder) + return best + + def _root_folder_for_path(path: Optional[str], configured_paths: Optional[List[str]] = None) -> str: + resolved = _abs_user_path(path) + if not resolved: + return "" + git_root = _git_root_for_path(resolved) + if git_root: + return git_root + ui_repo = _abs_user_path(_ui_repo()) + if ui_repo and _path_is_within(resolved, ui_repo): + return ui_repo + configured_root = _best_configured_root(resolved, configured_paths or []) + return configured_root or resolved + + def _folder_context_manager(path: str) -> Dict[str, Any]: + label = _folder_label(path) + return { + "manager_id": f"context-manager:{_folder_node_id(path).split(':', 1)[-1]}", + "display_name": f"{label} Context Manager", + "folder_path": path, + "charter": "Own context quality, freshness, and sharing for this local folder.", + "status": "active", + } + + ACTIVE_GRACE_SECONDS = 30 * 60 # survives quiet turns without reviving old rows + + def _is_session_active(session: Dict[str, Any]) -> bool: + """Return whether a session should be shown in live-only surfaces. + + Older mirrored rows were sometimes left with ``state=active`` forever. + Treat the stored state as a hint, then require either a fresh update, + a current mirror marker, or a live native process/pid. This keeps + FOLDERS and ROUTER from showing stale historical sessions as live. + """ + state_value = str(session.get("state") or "").lower() + if state_value in ("paused", "stale", "ended", "completed", "killed"): + return False + + metadata = dict(session.get("metadata") or {}) + runtime = str(session.get("runtime_id") or session.get("runtime") or "").lower() + updated_at = session.get("updated_at") or session.get("updatedAt") + + if _recent_enough(updated_at, seconds=ACTIVE_GRACE_SECONDS): + return True + + # Claude's local registry gives us the real process id. Prefer that + # over cwd-level process checks, because one Claude process in a repo + # should not resurrect every old session that once used that folder. + if runtime in {"claude-code", "claude"} and _pid_alive(metadata.get("pid")): + return True + + return False + + def _local_context_graph_payload(*, active_only: bool = False) -> Dict[str, Any]: + db = _get_db() + state = _read_local_context_state() + configured = state.get("folders") or {} + workspaces = state.get("workspaces") or {} + configured_paths = [ + _abs_user_path(path) + for path in configured.keys() + if _abs_user_path(path) + ] + process_paths = [ + _abs_user_path(proc.get("cwd")) + for proc in _runtime_processes() + if str(proc.get("runtime_id") or "") in {"codex", "claude-code"} + ] + extra_paths = [path for path in [*configured_paths, *process_paths] if path] + sync = _mirror_runtime_sessions(db, extra_paths=extra_paths) + raw_sessions = [ + session + for session in list(sync.get("sessions") or []) + if str(session.get("state") or "") != "stale" + ] + if not raw_sessions: + raw_sessions = [ + session + for session in db.list_agent_sessions(user_id=_ui_user_id(), limit=40) + if str(session.get("state") or "") == "active" + or _recent_enough(session.get("updated_at"), seconds=86_400) + ] + if active_only: + raw_sessions = [s for s in raw_sessions if _is_session_active(s)] + sessions = [_session_summary(db, session) for session in raw_sessions] + folder_paths: List[str] = [] + seen_paths: set[str] = set() + + def add_folder(path: Optional[str]) -> None: + resolved = _abs_user_path(path) + if not resolved or resolved in seen_paths: + return + seen_paths.add(resolved) + folder_paths.append(resolved) + + # Only the UI repo and configured paths seed the folder set. Sessions + # whose cwd lives in a subfolder are clustered into their root folder + # (git root → ui repo → nearest configured root), so the canvas shows + # one node per project and all its sessions share a single context. + add_folder(_root_folder_for_path(_ui_repo(), configured_paths) or _ui_repo()) + for path in configured_paths: + add_folder(_root_folder_for_path(path, configured_paths) or path) + + nodes: List[Dict[str, Any]] = [] + edges: List[Dict[str, Any]] = [] + folders: Dict[str, Dict[str, Any]] = {} + session_counts: Dict[str, int] = Counter() + active_counts: Dict[str, int] = Counter() + latest_by_folder: Dict[str, str] = {} + folder_for_session: Dict[str, str] = {} + + for session in sessions: + cwd = _abs_user_path(session.get("cwd")) + if not cwd: + continue + folder = _root_folder_for_path(cwd, configured_paths) + if not folder: + folder = cwd + add_folder(folder) + folder_for_session[_session_node_id(session)] = folder + session_counts[folder] += 1 + if str(session.get("state") or "") == "active" or session.get("isCurrent"): + active_counts[folder] += 1 + updated = str(session.get("updatedAt") or "") + if updated and updated > latest_by_folder.get(folder, ""): + latest_by_folder[folder] = updated + + def saved_rows_for_root(root: str) -> List[Dict[str, Any]]: + rows: List[Dict[str, Any]] = [] + for saved_path, row in configured.items(): + resolved = _abs_user_path(saved_path) + if not resolved or not isinstance(row, dict): + continue + row_root = _root_folder_for_path(resolved, configured_paths) or resolved + if row_root == root: + rows.append(row) + return rows + + for path in folder_paths: + saved_rows = saved_rows_for_root(path) + if active_only and session_counts.get(path, 0) == 0 and not saved_rows: + continue + saved = saved_rows[0] if saved_rows else {} + shared = any(bool(row.get("shared")) for row in saved_rows) + linked = any(bool(row.get("linked")) for row in saved_rows) + folders[path] = { + "id": _folder_node_id(path), + "type": "folder", + "label": _folder_label(path), + "health": "healthy" if (shared or linked) else "watch", + "meta": { + "path": path, + "shared": shared, + "linked": linked, + "linked_at": saved.get("linked_at") if isinstance(saved, dict) else None, + "session_count": session_counts.get(path, 0), + "active_session_count": active_counts.get(path, 0), + "updated_at": latest_by_folder.get(path), + "source": "manual" if saved_rows else "session", + "context_manager": _folder_context_manager(path), + }, + } + + for path in sorted(folders): + nodes.append(folders[path]) + + for session in sessions: + session_id = _session_node_id(session) + folder = folder_for_session.get(session_id) + if not folder or folder not in folders: + continue + nodes.append({ + "id": session_id, + "type": "session", + "label": _session_title( + session.get("title"), + preview=session.get("preview"), + runtime=session.get("runtime"), + cwd=session.get("cwd"), + session_id=session.get("nativeSessionId") or session_id, + ), + "health": "healthy" if session.get("isCurrent") or session.get("state") == "active" else "watch", + "meta": { + "folder_path": folder, + "cwd": session.get("cwd"), + "runtime": session.get("runtime"), + "state": session.get("state"), + "model": session.get("model"), + "updated_at": session.get("updatedAt"), + "task_id": session.get("taskId"), + "preview": session.get("preview"), + "permission_mode": session.get("permissionMode"), + }, + }) + edges.append({"source": folders[folder]["id"], "target": session_id, "kind": "contains"}) + + shared_folder_ids = [row["id"] for row in folders.values() if (row.get("meta") or {}).get("shared")] + for idx in range(1, len(shared_folder_ids)): + edges.append({ + "source": shared_folder_ids[idx - 1], + "target": shared_folder_ids[idx], + "kind": "shares", + }) + + # Workspace summary — list every known workspace so the UI can + # render the workspace switcher (single-cap today, multi later). + workspace_list = [] + for ws_id, ws_row in (workspaces or {}).items(): + if not isinstance(ws_row, dict): + continue + ws_folders = [ + p for p, f in (configured or {}).items() + if isinstance(f, dict) and (f.get("workspace_id") or DEFAULT_WORKSPACE_ID) == ws_id + ] + workspace_list.append({ + "id": ws_id, + "name": ws_row.get("name") or "Workspace", + "created_at": ws_row.get("created_at"), + "folder_count": len(ws_folders), + }) + + return { + "live": True, + "org_id": "local", + "active_only": bool(active_only), + "workspaces": workspace_list, + "active_workspace_id": (workspace_list[0]["id"] if workspace_list else None), + "nodes": nodes, + "edges": edges, + "totals": { + "projects": 0, + "teams": len(sessions), + "repos": len(folders), + "context_items": 0, + "pending_proposals": 0, + "folders": len(folders), + "sessions": len(sessions), + "shared_folders": len(shared_folder_ids), + }, + "raw": { + "mode": "local_context", + "folders": list(folders.values()), + "sessions": sessions, + "shared_folder_paths": [ + str((row.get("meta") or {}).get("path") or "") + for row in folders.values() + if (row.get("meta") or {}).get("shared") + ], + "context_index": [], + "pending_proposals": [], + "context_managers_by_team": {}, + }, + } + + @app.get("/api/local-context") + def api_local_context() -> Dict[str, Any]: + return _local_context_graph_payload() + + @app.post("/api/local-context/folders") + def api_local_context_folder_add(payload: LocalContextFolderPayload) -> Dict[str, Any]: + """Add a folder for shared context. + + Two-step flow that matches the CLI: + + 1. If the path is inside a git repo, call ``repo_link.link()``. + That creates ``${o}`),n=n.replace(/\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g,(r,o,l)=>{const s=(l||o).trim(),a=t?t(o.trim()):null;return a?`${s}`:`${s}`}),n=n.replace(/\[([^\]]+)\]\(([^)]+)\)/g,(r,o,l)=>`${o}`),n=n.replace(/\*\*([^*]+)\*\*/g,"$1"),n=n.replace(/(^|[^*])\*([^*]+)\*/g,"$1$2"),n}function Cg({source:e,wikiResolve:t}){const n=(e||"").replace(/\r\n/g,`
+`).split(`
+`),r=[];let o=0;for(;o${ti(d.join(`
+`))}`);continue}if(/^### /.test(l)){r.push(`${Cn(a.join(" "),t)}`);continue}if(/^\s*[-*]\s/.test(l)){const a=[];for(;o
${Cn(s.join(` +`),t)}
`)}return i.jsx("div",{className:"md-root",style:{fontFamily:"var(--font)",fontSize:13.5,lineHeight:1.55,color:"var(--ink)"},dangerouslySetInnerHTML:{__html:r.join("")}})}const Ki={title:"",content:"",scope:"team",kind:"note",project_id:"",team_id:"",tags:""},bg=["user","company","global_team","project","team","agent"],Ou={items:[],next_cursor:null,active_only:!1,totals:{tokens_saved:0,estimated_cost_saved_usd:0,router_calls:0,sessions:0}},$u={live:!1,items:[],totals:{contexts:0,used_contexts:0,usage_count:0,tokens_served:0,proven_tokens_saved:0,theoretical_api_value_usd:0,realized_cost_saved_usd:0}};function _g(e){return{...e,tags:Array.isArray(e.tags)?e.tags:[]}}function Du(e){return(e==null?void 0:e.role)==="manager"||(e==null?void 0:e.role)==="admin"?e.team_id?{...Ki,scope:"team",team_id:e.team_id,project_id:e.project_id||""}:e.project_id?{...Ki,scope:"project",project_id:e.project_id}:{...Ki,scope:"company"}:{...Ki,scope:"user",user_id:e==null?void 0:e.user_id}}function Eg(e){return{title:e.title||"Untitled context",content:e.content||e.summary||"",scope:e.scope||"team",kind:e.kind||"note",project_id:e.project_id||"",team_id:e.team_id||"",tags:(e.tags||[]).join(", ")}}function Tg(e){return{title:ba(e),content:e.content||"",scope:"memory",kind:e.tier,project_id:"",team_id:"",tags:(e.tags||[]).join(", ")}}function Mu(e,t,n){return(e==null?void 0:e.role)==="admin"||(e==null?void 0:e.role)==="manager"?!0:((t==null?void 0:t.scope)||(n==null?void 0:n.scope))==="user"?!(t!=null&&t.user_id)||t.user_id===(e==null?void 0:e.user_id):!1}function Iu(e){return e==="pending_review"?"var(--accent)":e==="rejected"||e==="inactive"?"var(--rose)":"var(--green)"}function Ll(e){return e.split(",").map(t=>t.trim()).filter(Boolean)}function zg(e){return e.team_id?e.team_id:e.project_id?e.project_id:e.user_id?"mine":e.scope}function Rg(e){return e==="user"?"Mine":e==="company"?"Company":e==="global_team"?"Global Teams":e==="project"?"Projects":e==="team"?"Teams":e==="agent"?"Agents":e}function Bu(e){return e.replace(/[-_]+/g," ").replace(/\s+/g," ").trim().replace(/\b\w/g,t=>t.toUpperCase())}function ba(e){var n;return(e.content||"").split(/\r?\n/).map(r=>r.trim()).find(Boolean)||""||((n=e.tags)==null?void 0:n[0])||`${e.tier} memory`}function Ng(e){var l;const t=ba(e),n=t.match(/^([^>]{3,72})\s*>\s*.+$/);if(n!=null&&n[1])return n[1].trim();const r=[t,e.source,...e.tags||[]].join(" ").toLowerCase();if(r.includes("repository guideline")||r.includes("agents.md"))return"Repository Guidelines";if(r.startsWith("edited ")||r.includes("/users/")||r.includes("/tmp/"))return"File Edits";if(r.includes("session")||r.includes("continuity"))return"Session Continuity";const o=(l=e.tags)==null?void 0:l.find(s=>s&&s!==e.tier);return o?Bu(o):`${Bu(e.tier)} Memory`}function Pg(e){const t=ba(e),n=t.split(/\s*>\s*/);return(n.length>1?n.slice(1).join(" > "):t).slice(0,72)||"Memory"}function on(e){return!e||e<=0?"0":new Intl.NumberFormat("en",{notation:"compact",maximumFractionDigits:1}).format(e)}function On(e){const t=Math.max(0,Number(e||0));return t>0&&t<.01?"<$0.01":new Intl.NumberFormat("en-US",{style:"currency",currency:"USD",maximumFractionDigits:t>=10?0:2}).format(t)}function Fg(e){const t=e.pricing;if(!t)return"PAYG input-token estimate";const n=t.input_cost_per_million,r=t.model_family||e.model||"model",o=t.provider||e.runtime||e.agent||"provider",l=typeof n=="number"?`$${n}/1M input tokens`:"input-token rate";return`${o} · ${r} · ${l}`}function Lg(e,t){const n=(t==null?void 0:t.usage_count)??e.usage_count??0,r=(t==null?void 0:t.proven_tokens_saved)??0,o=[`${e.kind} · ${zg(e)}`,`${n} use${n===1?"":"s"}`];return o.push(r>0?`${on(r)} proven saved`:"no proven $"),o.join(" · ")}function Og(e){const t=String(e.runtime||e.agent||"").toLowerCase();return t==="codex"?"var(--indigo)":t==="claude-code"||t==="claude"?"var(--accent)":"var(--green)"}function $g(e){const t=(e.title||"").trim();return t||(e.cwd||e.repo_root||"").split("/").filter(Boolean).pop()||e.session_id||"Session"}function Dg({onMemoryCountChange:e,viewer:t,orgGraph:n,onInboxChanged:r}){var wn,Ut,Z,ae,Se,le,Ee,Lt,Qn;const[o,l]=v.useState([]),[s,a]=v.useState([]),[d,c]=v.useState(null),[g,m]=v.useState(()=>Du(t||null)),[x,S]=v.useState(!1),[E,T]=v.useState(""),[H,h]=v.useState(null),[u,f]=v.useState(null),[p,j]=v.useState(!0),[_,P]=v.useState(null),[z,Q]=v.useState(Ou),[R,J]=v.useState($u),[X,K]=v.useState({}),[G,M]=v.useState(""),V=v.useRef({}),ye=async()=>{var w,b,k;try{const[O,I,ne,ve]=await Promise.all([B.listMemories().catch(Ue=>({live:!1,engrams:[],count:0,error:String(Ue)})),B.contextItems({limit:500}).catch(Ue=>({live:!1,items:[],error:String(Ue)})),B.routerSessions({active:!1,limit:50}).catch(()=>Ou),B.contextUsage({limit:500}).catch(()=>$u)]),Ke=(w=I.items)!=null&&w.length||!((b=n==null?void 0:n.raw)!=null&&b.context_index)?I.items||[]:n.raw.context_index,st=new Map((ve.items||[]).map(Ue=>[Ue.context_id,Ue]));l(Ke.map(_g).map(Ue=>{const Yn=st.get(Ue.context_id);return Yn?{...Ue,usage_count:Yn.usage_count,last_used_at:Yn.last_used_at,token_cost:Yn.token_cost}:Ue})),a(O.engrams||[]),Q(ne),J(ve),j(!!(O.live||I.live||n!=null&&n.live)),f(I.error||O.error||null),e==null||e(((k=O.engrams)==null?void 0:k.length)||0)}catch(O){f(O instanceof Error?O.message:String(O)),j(!1)}};v.useEffect(()=>{ye();const w=window.setInterval(()=>void ye(),6e3);return()=>window.clearInterval(w)},[]),v.useEffect(()=>{if(d)return;const w=decodeURIComponent(window.location.hash||""),b=w.startsWith("#vault/")?w.replace("#vault/","").trim():"",k=b?o.find(O=>O.team_id===b):null;if(k){c({kind:"context",id:k.context_id});return}if(o[0]){c({kind:"context",id:o[0].context_id});return}s[0]&&c({kind:"memory",id:s[0].id})},[o,s,d]);const C=(d==null?void 0:d.kind)==="context"&&o.find(w=>w.context_id===d.id)||null,A=(d==null?void 0:d.kind)==="memory"&&s.find(w=>w.id===d.id)||null;v.useEffect(()=>{if(C){m(Eg(C)),S(!1);return}if(A){m(Tg(A)),S(!1);return}(d==null?void 0:d.kind)==="new"&&(m(Du(t||null)),S(!0))},[C,A,d==null?void 0:d.kind,t]),v.useEffect(()=>{if(!C){P(null);return}let w=!0;return B.backlinks(C.context_id).then(b=>{w&&P(b)}).catch(()=>{w&&P(null)}),()=>{w=!1}},[C==null?void 0:C.context_id]);const W=v.useMemo(()=>{const w=E.trim().toLowerCase();return w?o.filter(b=>[b.title,b.summary,b.content,b.kind,b.scope,b.team_id,b.project_id,...b.tags||[]].filter(Boolean).join(" ").toLowerCase().includes(w)):o},[o,E]),ee=v.useMemo(()=>{const w=new Map;for(const b of bg)w.set(b,[]);for(const b of W){const k=b.scope||"team";w.set(k,[...w.get(k)||[],b])}return w},[W]),ie=v.useMemo(()=>{const w=E.trim().toLowerCase();return w?s.filter(b=>[b.content,b.source,b.tier,...b.tags||[]].filter(Boolean).join(" ").toLowerCase().includes(w)):s},[s,E]),D=v.useMemo(()=>{const w=new Map;for(const b of ie){const k=Ng(b);w.set(k,[...w.get(k)||[],b])}return new Map([...w.entries()].sort(([b],[k])=>b.localeCompare(k)))},[ie]),fe=v.useMemo(()=>{const w=[];for(const[b,k]of ee.entries())k.length!==0&&w.push({id:`context:${b}`,kind:"context",label:Rg(b),count:k.length,rows:k});for(const[b,k]of D.entries())k.length!==0&&w.push({id:`memory:${b}`,kind:"memory",label:b,count:k.length,rows:k});return w},[ee,D]),se=v.useMemo(()=>{const w=[];for(const b of fe)if(w.push({id:`section:${b.id}`,type:"section",sectionId:b.id}),!!X[b.id])if(b.kind==="context")for(const k of b.rows)w.push({id:`context-item:${k.context_id}`,type:"context",sectionId:b.id,item:k});else for(const k of b.rows)w.push({id:`memory-item:${k.id}`,type:"memory",sectionId:b.id,memory:k});return w},[X,fe]);v.useEffect(()=>{E.trim()&&K({})},[E]),v.useEffect(()=>{if(!se.length){G&&M("");return}(!G||!se.some(w=>w.id===G))&&M(se[0].id)},[G,se]),v.useEffect(()=>{var w;G&&((w=V.current[G])==null||w.focus())},[G]);const me=(w,b)=>{K(k=>({...k,[w]:typeof b=="boolean"?b:!k[w]}))},$=w=>{c({kind:"context",id:w.context_id}),window.location.hash=`#vault/item/${w.context_id}`},de=w=>{c({kind:"memory",id:w.id})},ce=w=>{M(w)},he=(w,b)=>{const k=se.findIndex(I=>I.id===w);if(k<0)return;const O=se[Math.max(0,Math.min(se.length-1,k+b))];O&&ce(O.id)},_e=(w,b)=>{if(w.key==="ArrowDown"){w.preventDefault(),he(b.id,1);return}if(w.key==="ArrowUp"){w.preventDefault(),he(b.id,-1);return}if(w.key==="Home"){w.preventDefault(),se[0]&&ce(se[0].id);return}if(w.key==="End"){w.preventDefault();const k=se[se.length-1];k&&ce(k.id);return}if(w.key==="ArrowRight"&&b.type==="section"){if(w.preventDefault(),!X[b.sectionId])me(b.sectionId,!0);else{const k=se.find(O=>O.sectionId===b.sectionId&&O.type!=="section");k&&ce(k.id)}return}if(w.key==="ArrowLeft"){w.preventDefault(),b.type==="section"?X[b.sectionId]&&me(b.sectionId,!1):ce(`section:${b.sectionId}`);return}(w.key==="Enter"||w.key===" ")&&b.type==="section"&&(w.preventDefault(),me(b.sectionId))},N=w=>{const b=o.find(k=>k.title.toLowerCase()===w.toLowerCase());return b?`#vault/item/${b.context_id}`:null},oe=()=>{c({kind:"new",id:"new"})},q=async()=>{if(!g.title.trim()||!g.content.trim()){f("Title and content are required.");return}h("save"),f(null);const w={title:g.title.trim(),content:g.content,scope:g.scope,kind:g.kind||"note",project_id:g.project_id||(t==null?void 0:t.project_id)||void 0,team_id:g.team_id||(t==null?void 0:t.team_id)||void 0,tags:Ll(g.tags),metadata:{source:"sankhya-vault"}};try{if(Mu(t||null,C,g)){const b=await B.upsertContext({...w,context_id:C==null?void 0:C.context_id,user_id:g.scope==="user"?t==null?void 0:t.user_id:void 0});c({kind:"context",id:b.item.context_id})}else{const b=await B.proposeContext({...w,proposed_by_user_id:(t==null?void 0:t.user_id)||"developer",supersedes_id:C==null?void 0:C.context_id});c({kind:"context",id:b.proposal.context_id}),await(r==null?void 0:r())}await ye(),S(!1)}catch(b){f(b instanceof Error?b.message:String(b))}finally{h(null)}},te=async w=>{if(C){h(w);try{w==="approve"?await B.approveProposal(C.context_id,(t==null?void 0:t.user_id)||"manager"):await B.rejectProposal(C.context_id,(t==null?void 0:t.user_id)||"manager"),await ye(),await(r==null?void 0:r())}catch(b){f(b instanceof Error?b.message:String(b))}finally{h(null)}}},Ae=(d==null?void 0:d.kind)==="memory",Ft=Mu(t||null,C,g),xe=v.useMemo(()=>[...z.items||[]].sort((b,k)=>{const O=(k.tokens_saved||0)-(b.tokens_saved||0);return O!==0?O:String(k.updated_at||"").localeCompare(String(b.updated_at||""))}).filter(b=>b.tokens_saved>0).slice(0,4),[z.items]),Me=v.useMemo(()=>new Map((R.items||[]).map(w=>[w.context_id,w])),[R.items]),je=C&&Me.get(C.context_id)||null,Fe=v.useMemo(()=>[...R.items||[]].filter(w=>(w.usage_count||0)>0).sort((w,b)=>{const k=(b.usage_count||0)-(w.usage_count||0);return k!==0?k:(b.proven_tokens_saved||0)-(w.proven_tokens_saved||0)}).slice(0,5),[R.items]);return i.jsxs("div",{style:{display:"flex",height:"100%",minHeight:0},children:[i.jsxs("aside",{style:{width:282,borderRight:"1px solid var(--border)",background:"white",display:"flex",flexDirection:"column",flexShrink:0},children:[i.jsxs("div",{style:{padding:14,borderBottom:"1px solid var(--border)"},children:[i.jsxs("div",{style:{display:"flex",alignItems:"center",justifyContent:"space-between",gap:8,marginBottom:10},children:[i.jsxs("div",{children:[i.jsx("div",{style:{fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)",letterSpacing:"0.08em",textTransform:"uppercase"},children:"Context"}),i.jsx("div",{style:{fontSize:14,fontWeight:600,color:"var(--ink)"},children:"Manager"})]}),i.jsx("button",{onClick:oe,style:{padding:"5px 8px",border:"1px solid var(--accent)",background:"var(--accent-dim)",color:"var(--accent)",fontFamily:"var(--mono)",fontSize:10,borderRadius:3},children:"NEW"})]}),i.jsx("input",{value:E,onChange:w=>T(w.target.value),placeholder:"search context or memory",style:{width:"100%",boxSizing:"border-box",border:"1px solid var(--border)",background:"var(--surface)",color:"var(--ink)",padding:"8px 9px",fontSize:12}}),i.jsxs("div",{style:{marginTop:8},children:[i.jsx(Bg,{rows:Fe,totals:R.totals,onSelect:w=>{c({kind:"context",id:w}),window.location.hash=`#vault/item/${w}`}}),i.jsx(Ag,{rows:xe,totalTokens:((wn=z.totals)==null?void 0:wn.tokens_saved)||0,totalCost:((Ut=z.totals)==null?void 0:Ut.realized_cost_saved_usd)??((Z=z.totals)==null?void 0:Z.estimated_cost_saved_usd)??0,apiValue:((ae=z.totals)==null?void 0:ae.theoretical_api_value_usd)??((Se=z.totals)==null?void 0:Se.estimated_cost_saved_usd)??0,totalSessions:((le=z.totals)==null?void 0:le.sessions)||0,budget:z.budget})]})]}),i.jsx("div",{style:{flex:1,overflowY:"auto",padding:10},role:"tree","aria-label":"Context categories",children:fe.map(w=>{const b={id:`section:${w.id}`,type:"section",sectionId:w.id},k=!!X[w.id],O=w.kind==="context"?w.rows.some(I=>(d==null?void 0:d.kind)==="context"&&d.id===I.context_id):w.rows.some(I=>(d==null?void 0:d.kind)==="memory"&&d.id===I.id);return i.jsx(Ig,{label:w.label,count:w.count,open:k,active:O,focused:G===b.id,buttonRef:I=>{V.current[b.id]=I},onFocus:()=>M(b.id),onToggle:()=>me(w.id),onKeyDown:I=>_e(I,b),children:w.kind==="context"?w.rows.map(I=>{const ne={id:`context-item:${I.context_id}`,type:"context",sectionId:w.id};return i.jsx(Au,{treeId:ne.id,buttonRef:ve=>{V.current[ne.id]=ve},focused:G===ne.id,active:(d==null?void 0:d.kind)==="context"&&d.id===I.context_id,dot:Iu(I.proposal_status||I.status),title:I.title,meta:Lg(I,Me.get(I.context_id)),onFocus:()=>M(ne.id),onKeyDown:ve=>_e(ve,ne),onClick:()=>$(I)},I.context_id)}):w.rows.map(I=>{const ne={id:`memory-item:${I.id}`,type:"memory",sectionId:w.id};return i.jsx(Au,{treeId:ne.id,buttonRef:ve=>{V.current[ne.id]=ve},focused:G===ne.id,active:(d==null?void 0:d.kind)==="memory"&&d.id===I.id,dot:"var(--indigo)",title:Pg(I),meta:`${I.tier} · ${I.tokens||0} tok`,onFocus:()=>M(ne.id),onKeyDown:ve=>_e(ve,ne),onClick:()=>de(I)},I.id)})},w.id)})})]}),i.jsxs("main",{style:{flex:1,minWidth:0,display:"grid",gridTemplateColumns:"minmax(0, 1fr) 320px",background:"var(--bg)"},children:[i.jsxs("section",{style:{minWidth:0,display:"flex",flexDirection:"column"},children:[i.jsxs("header",{style:{height:52,borderBottom:"1px solid var(--border)",display:"flex",alignItems:"center",justifyContent:"space-between",padding:"0 18px",background:"white",gap:12},children:[i.jsxs("div",{style:{minWidth:0},children:[i.jsxs("div",{style:{fontFamily:"var(--mono)",fontSize:9,letterSpacing:"0.08em",color:"var(--ink3)",textTransform:"uppercase"},children:[A?"Legacy memory":g.scope||"context",p?"":" · offline"]}),i.jsx("div",{style:{fontSize:16,fontWeight:600,color:"var(--ink)",overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"},children:g.title||"New context item"})]}),i.jsxs("div",{style:{display:"flex",gap:8,flexShrink:0},children:[(C==null?void 0:C.proposal_status)==="pending_review"&&((t==null?void 0:t.role)==="manager"||(t==null?void 0:t.role)==="admin")?i.jsxs(i.Fragment,{children:[i.jsx(Qi,{label:"APPROVE",tone:"green",busy:H==="approve",onClick:()=>void te("approve")}),i.jsx(Qi,{label:"REJECT",tone:"rose",busy:H==="reject",onClick:()=>void te("reject")})]}):null,Ae?null:i.jsxs(i.Fragment,{children:[i.jsx(Qi,{label:x?"PREVIEW":"EDIT",onClick:()=>S(w=>!w)}),i.jsx(Qi,{label:Ft?"SAVE":"REQUEST",tone:Ft?"accent":"indigo",busy:H==="save",onClick:()=>void q()})]})]})]}),i.jsxs("div",{style:{flex:1,minHeight:0,overflow:"auto",padding:18,display:"grid",gridTemplateColumns:x?"minmax(0, 1fr) minmax(0, 1fr)":"minmax(0, 760px)",gap:16,alignContent:"start"},children:[x&&!Ae?i.jsxs("div",{style:{display:"grid",gap:10,alignContent:"start"},children:[i.jsx("input",{value:g.title,onChange:w=>m(b=>({...b,title:w.target.value})),placeholder:"Context title",style:bn}),i.jsxs("div",{style:{display:"grid",gridTemplateColumns:"1fr 1fr",gap:8},children:[i.jsxs("select",{value:g.scope,onChange:w=>m(b=>({...b,scope:w.target.value})),style:bn,children:[i.jsx("option",{value:"company",children:"company"}),i.jsx("option",{value:"project",children:"project"}),i.jsx("option",{value:"global_team",children:"global_team"}),i.jsx("option",{value:"team",children:"team"}),i.jsx("option",{value:"user",children:"user"}),i.jsx("option",{value:"agent",children:"agent"})]}),i.jsx("input",{value:g.kind,onChange:w=>m(b=>({...b,kind:w.target.value})),placeholder:"kind: runbook / policy / decision",style:bn})]}),i.jsxs("div",{style:{display:"grid",gridTemplateColumns:"1fr 1fr",gap:8},children:[i.jsx("input",{value:g.project_id,onChange:w=>m(b=>({...b,project_id:w.target.value})),placeholder:"project id",style:bn}),i.jsx("input",{value:g.team_id,onChange:w=>m(b=>({...b,team_id:w.target.value})),placeholder:"team id",style:bn})]}),i.jsx("input",{value:g.tags,onChange:w=>m(b=>({...b,tags:w.target.value})),placeholder:"tags, comma separated",style:bn}),i.jsx("textarea",{value:g.content,onChange:w=>m(b=>({...b,content:w.target.value})),rows:20,placeholder:"Write markdown context here...",style:{...bn,minHeight:420,resize:"vertical",lineHeight:1.55,fontFamily:"var(--mono)"}})]}):null,i.jsx("article",{style:{border:"1px solid var(--border)",background:"white",padding:18,minHeight:420,boxShadow:"0 10px 28px rgba(20,16,10,0.04)"},children:i.jsx(Cg,{source:g.content||"_No context selected._",wikiResolve:N})})]})]}),i.jsxs("aside",{style:{borderLeft:"1px solid var(--border)",background:"white",padding:16,overflowY:"auto",display:"flex",flexDirection:"column",gap:14},children:[i.jsxs(_n,{label:"Scope",children:[i.jsx($r,{children:g.scope}),g.kind?i.jsx($r,{children:g.kind}):null,C!=null&&C.proposal_status?i.jsx($r,{color:Iu(C.proposal_status),children:C.proposal_status}):null]}),i.jsxs(_n,{label:"Ownership",children:[i.jsx(Ge,{k:"org",v:t==null?void 0:t.org_id}),i.jsx(Ge,{k:"project",v:g.project_id||(t==null?void 0:t.project_id)}),i.jsx(Ge,{k:"team",v:g.team_id||(t==null?void 0:t.team_id)}),i.jsx(Ge,{k:"viewer",v:t==null?void 0:t.user_id}),i.jsx(Ge,{k:"role",v:(t==null?void 0:t.role)||"developer"})]}),i.jsxs(_n,{label:"Health",children:[i.jsx(Ge,{k:"quality",v:C==null?void 0:C.quality_score}),i.jsx(Ge,{k:"freshness",v:C==null?void 0:C.freshness_score}),i.jsx(Ge,{k:"confidence",v:C==null?void 0:C.confidence}),i.jsx(Ge,{k:"token cost",v:C==null?void 0:C.token_cost}),i.jsx(Ge,{k:"updated",v:(C==null?void 0:C.updated_at)||(A==null?void 0:A.created)})]}),C?i.jsxs(_n,{label:"Usage",children:[i.jsx(Ge,{k:"uses",v:(je==null?void 0:je.usage_count)??C.usage_count??0}),i.jsx(Ge,{k:"last used",v:(je==null?void 0:je.last_used_at)??C.last_used_at}),i.jsx(Ge,{k:"tokens served",v:(je==null?void 0:je.tokens_served)??0}),i.jsx(Ge,{k:"proven saved",v:(je==null?void 0:je.proven_tokens_saved)??0}),i.jsx(Ge,{k:"proven $",v:On(je==null?void 0:je.realized_cost_saved_usd)}),i.jsx(Ge,{k:"evidence",v:(Ee=je==null?void 0:je.evidence)!=null&&Ee.has_direct_savings_evidence?"direct attribution":"usage only"})]}):null,i.jsx(_n,{label:"Tags",children:Ll(g.tags).length?Ll(g.tags).map(w=>i.jsx($r,{children:w},w)):i.jsx("span",{style:{color:"var(--ink3)",fontSize:12},children:"none"})}),i.jsx(_n,{label:"Backlinks",children:(Lt=_==null?void 0:_.backlinks)!=null&&Lt.length?_.backlinks.map(w=>i.jsx("button",{onClick:()=>c({kind:"context",id:w.src}),style:Mg,children:w.src_title||w.src},`${w.src}:${w.edge_type}`)):i.jsx("span",{style:{color:"var(--ink3)",fontSize:12},children:"none"})}),i.jsx(_n,{label:"Shares",children:(Qn=_==null?void 0:_.shares)!=null&&Qn.length?_.shares.map((w,b)=>i.jsx($r,{children:String(w.scope||w.team_id||"share")},b)):i.jsx("span",{style:{color:"var(--ink3)",fontSize:12},children:"private"})}),u?i.jsx("div",{style:{border:"1px solid var(--rose)",color:"var(--rose)",background:"var(--rose-dim)",padding:10,fontFamily:"var(--mono)",fontSize:10,lineHeight:1.5},children:u}):null]})]})]})}const bn={width:"100%",boxSizing:"border-box",border:"1px solid var(--border)",background:"white",color:"var(--ink)",padding:"8px 9px",fontSize:12},Mg={display:"block",width:"100%",textAlign:"left",border:"1px solid var(--border)",background:"var(--surface)",color:"var(--ink2)",padding:"7px 8px",fontSize:12,cursor:"pointer"};function Ig({label:e,count:t,open:n,active:r,focused:o,buttonRef:l,onFocus:s,onToggle:a,onKeyDown:d,children:c}){return i.jsxs("div",{style:{marginBottom:6},children:[i.jsxs("button",{ref:l,type:"button",role:"treeitem","aria-expanded":n,"aria-selected":r,tabIndex:o?0:-1,onFocus:s,onClick:a,onKeyDown:d,style:{width:"100%",border:`1px solid ${r?"var(--accent)":"var(--border)"}`,background:r?"var(--accent-dim)":"var(--surface)",color:"var(--ink)",borderRadius:4,padding:"7px 8px",cursor:"pointer",display:"grid",gridTemplateColumns:"12px minmax(0, 1fr) auto",alignItems:"center",gap:8,textAlign:"left",fontFamily:"var(--mono)",fontSize:10,letterSpacing:"0.04em",textTransform:"uppercase",outline:o?"2px solid var(--accent-dim)":"none"},children:[i.jsx("span",{style:{color:"var(--ink3)"},children:n?"v":">"}),i.jsx("span",{style:{overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"},children:e}),i.jsx("span",{style:{color:"var(--ink3)"},children:t})]}),n?i.jsx("div",{role:"group",style:{display:"grid",gap:4,margin:"4px 0 8px 14px"},children:c}):null]})}function Bg({rows:e,totals:t,onSelect:n}){return i.jsxs("div",{style:{border:"1px solid var(--border)",background:"white",borderRadius:4,padding:8,marginBottom:8},children:[i.jsxs("div",{style:{display:"flex",alignItems:"baseline",justifyContent:"space-between",gap:8},children:[i.jsx("span",{style:{fontFamily:"var(--mono)",fontSize:9,color:"var(--ink3)",letterSpacing:"0.04em",textTransform:"uppercase"},children:"Frequent context"}),i.jsxs("span",{style:{fontSize:13,fontWeight:700,color:"var(--ink)"},children:[on((t==null?void 0:t.usage_count)||0)," uses"]})]}),i.jsxs("div",{style:{fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)",marginTop:2,lineHeight:1.35},children:[on((t==null?void 0:t.tokens_served)||0)," served ·"," ",on((t==null?void 0:t.proven_tokens_saved)||0)," proven saved ·"," ",On(t==null?void 0:t.realized_cost_saved_usd)]}),i.jsx("div",{style:{display:"grid",gap:5,marginTop:8},children:e.length?e.map(r=>i.jsxs("button",{type:"button",onClick:()=>n(r.context_id),style:{border:"0",borderTop:"1px solid var(--border)",background:"transparent",padding:"6px 0 0",textAlign:"left",cursor:"pointer",display:"grid",gridTemplateColumns:"minmax(0, 1fr) auto",gap:8},children:[i.jsxs("span",{style:{minWidth:0},children:[i.jsx("span",{style:{display:"block",color:"var(--ink)",fontSize:11,overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"},title:r.title,children:r.title}),i.jsxs("span",{style:{display:"block",fontFamily:"var(--mono)",color:"var(--ink3)",fontSize:9,marginTop:2},children:[r.usage_count," uses · ",on(r.tokens_served)," served"]})]}),i.jsxs("span",{style:{textAlign:"right",fontFamily:"var(--mono)"},children:[i.jsx("span",{style:{display:"block",color:"var(--green)",fontSize:11},children:on(r.proven_tokens_saved)}),i.jsx("span",{style:{display:"block",color:"var(--ink3)",fontSize:9},children:On(r.realized_cost_saved_usd)})]})]},r.context_id)):i.jsx("div",{style:{borderTop:"1px solid var(--border)",paddingTop:7,fontSize:11,color:"var(--ink3)",lineHeight:1.4},children:"No context has been injected yet."})}),i.jsx("div",{style:{borderTop:"1px solid var(--border)",marginTop:8,paddingTop:6,color:"var(--ink3)",fontSize:10,lineHeight:1.35},children:"Per-context dollars are shown only when Dhee has direct attribution."})]})}function Ag({rows:e,totalTokens:t,totalCost:n,apiValue:r,totalSessions:o,budget:l}){return i.jsxs("div",{style:{border:"1px solid var(--border)",background:"white",borderRadius:4,padding:8},children:[i.jsxs("div",{style:{display:"flex",alignItems:"baseline",justifyContent:"space-between",gap:8},children:[i.jsx("span",{style:{fontFamily:"var(--mono)",fontSize:9,color:"var(--ink3)",letterSpacing:"0.04em",textTransform:"uppercase"},children:"Budget-capped savings"}),i.jsx("span",{style:{fontSize:14,fontWeight:700,color:"var(--green)"},children:On(n)})]}),i.jsxs("div",{style:{fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)",marginTop:2},children:[on(t)," input tokens avoided across ",o," sessions"]}),i.jsxs("div",{style:{fontFamily:"var(--mono)",fontSize:9,color:"var(--ink3)",marginTop:2,lineHeight:1.35},children:["API value ",On(r),l!=null&&l.monthly_budget_usd?`; monthly cap ${On(l.monthly_budget_usd)}`:""]}),i.jsx("div",{style:{display:"grid",gap:5,marginTop:8},children:e.length?e.map(s=>{const a=Og(s);return i.jsxs("div",{style:{display:"grid",gridTemplateColumns:"minmax(0, 1fr) auto",gap:8,borderTop:"1px solid var(--border)",paddingTop:6},children:[i.jsxs("div",{style:{minWidth:0},children:[i.jsxs("div",{style:{display:"flex",alignItems:"center",gap:6,minWidth:0},children:[i.jsx("span",{style:{width:6,height:6,borderRadius:99,background:a,flexShrink:0}}),i.jsx("span",{style:{fontSize:11,color:"var(--ink)",overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"},children:$g(s)})]}),i.jsxs("div",{style:{fontFamily:"var(--mono)",fontSize:9,color:a,marginTop:2},children:[s.runtime||s.agent||"agent"," · ",s.router_calls," calls"]})]}),i.jsxs("div",{style:{textAlign:"right"},title:Fg(s),children:[i.jsx("div",{style:{fontSize:12,fontWeight:700,color:"var(--ink)"},children:On(s.estimated_cost_saved_usd)}),i.jsxs("div",{style:{fontFamily:"var(--mono)",fontSize:9,color:"var(--ink3)"},children:[on(s.tokens_saved)," tok"]})]})]},s.session_id)}):i.jsx("div",{style:{borderTop:"1px solid var(--border)",paddingTop:7,fontSize:11,color:"var(--ink3)",lineHeight:1.4},children:"No session-level savings recorded yet."})})]})}function Au({treeId:e,buttonRef:t,focused:n,active:r,dot:o,title:l,meta:s,onFocus:a,onKeyDown:d,onClick:c}){return i.jsxs("button",{ref:t,type:"button","data-tree-id":e,role:"treeitem","aria-selected":r,tabIndex:n?0:-1,onFocus:a,onKeyDown:d,onClick:c,style:{textAlign:"left",border:`1px solid ${r?"var(--accent)":"transparent"}`,background:r?"var(--accent-dim)":"transparent",color:"var(--ink)",padding:"7px 8px",borderRadius:4,cursor:"pointer",display:"grid",gridTemplateColumns:"8px minmax(0, 1fr)",gap:8,alignItems:"start",outline:n?"2px solid var(--accent-dim)":"none"},children:[i.jsx("span",{style:{width:6,height:6,borderRadius:99,background:o,marginTop:5}}),i.jsxs("span",{style:{minWidth:0},children:[i.jsx("span",{style:{display:"block",overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap",fontSize:12},children:l}),i.jsx("span",{style:{display:"block",fontFamily:"var(--mono)",fontSize:9,color:"var(--ink3)",marginTop:2},children:s})]})]})}function Qi({label:e,onClick:t,tone:n="default",busy:r}){const o=n==="accent"?"var(--accent)":n==="indigo"?"var(--indigo)":n==="green"?"var(--green)":n==="rose"?"var(--rose)":"var(--ink2)";return i.jsx("button",{onClick:t,disabled:r,style:{padding:"7px 10px",border:`1px solid ${o}`,background:n==="default"?"white":"var(--surface)",color:o,fontFamily:"var(--mono)",fontSize:10,letterSpacing:"0.06em",borderRadius:3,cursor:r?"wait":"pointer"},children:r?"...":e})}function _n({label:e,children:t}){return i.jsxs("section",{style:{display:"grid",gap:8},children:[i.jsx("div",{style:{fontFamily:"var(--mono)",fontSize:9,letterSpacing:"0.08em",color:"var(--ink3)",textTransform:"uppercase"},children:e}),i.jsx("div",{style:{display:"flex",flexWrap:"wrap",gap:6},children:t})]})}function $r({children:e,color:t="var(--ink2)"}){return i.jsx("span",{style:{display:"inline-flex",border:"1px solid var(--border)",background:"var(--surface)",color:t,padding:"3px 7px",borderRadius:3,fontFamily:"var(--mono)",fontSize:10},children:e})}function Ge({k:e,v:t}){return t==null||t===""?null:i.jsxs("div",{style:{display:"grid",gridTemplateColumns:"76px minmax(0, 1fr)",gap:6,width:"100%",fontSize:12},children:[i.jsx("span",{style:{fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)"},children:e}),i.jsx("span",{style:{color:"var(--ink2)",wordBreak:"break-word"},children:String(t)})]})}function Ug({projectIndex:e,memories:t,tokensSaved:n,onAddMemory:r,onSelectSession:o,onCreateWorkspace:l,onLaunchSession:s,onOpenWorkspace:a,onOpenTasks:d}){var ie;const[c,g]=v.useState(""),[m,x]=v.useState("task"),[S,E]=v.useState("codex"),[T,H]=v.useState("standard"),[h,u]=v.useState(""),[f,p]=v.useState(""),[j,_]=v.useState(!1),[P,z]=v.useState(""),[Q,R]=v.useState(!1),[J,X]=v.useState(null),K=v.useRef(null);v.useEffect(()=>{var D;(D=K.current)==null||D.focus()},[]);const G=(e==null?void 0:e.workspaces)||[],M=v.useMemo(()=>G.find(D=>D.id===(h||(e==null?void 0:e.currentWorkspaceId)))||G[0]||null,[e==null?void 0:e.currentWorkspaceId,h,G]),V=v.useMemo(()=>{var D,fe;return((D=M==null?void 0:M.projects)==null?void 0:D.find(se=>se.id===(f||(e==null?void 0:e.currentProjectId))))||((fe=M==null?void 0:M.projects)==null?void 0:fe[0])||null},[M,e==null?void 0:e.currentProjectId,f]),ye=v.useMemo(()=>{var D,fe,se,me;return((D=V==null?void 0:V.sessions)==null?void 0:D.find($=>$.id===(e==null?void 0:e.currentSessionId)))||((fe=V==null?void 0:V.sessions)==null?void 0:fe[0])||((se=M==null?void 0:M.sessions)==null?void 0:se.find($=>$.id===(e==null?void 0:e.currentSessionId)))||((me=M==null?void 0:M.sessions)==null?void 0:me[0])||null},[V,M,e==null?void 0:e.currentSessionId]);v.useEffect(()=>{!h&&(e!=null&&e.currentWorkspaceId)&&u(e.currentWorkspaceId)},[e==null?void 0:e.currentWorkspaceId,h]),v.useEffect(()=>{!f&&(e!=null&&e.currentProjectId)&&p(e.currentProjectId)},[e==null?void 0:e.currentProjectId,f]),v.useEffect(()=>{M&&V&&!M.projects.some(D=>D.id===f)&&p(V.id)},[M,V,f]);const C=c.split(` +`).map(D=>D.trim()).filter(Boolean),A=async()=>{if(!(!C.length||Q)){R(!0),X(null);try{if(m==="memory")for(const D of C)await r(D);else for(const D of C)await s(D,S,M==null?void 0:M.id,S==="claude-code"?T:void 0,V==null?void 0:V.id);g("")}catch(D){X(String(D))}finally{R(!1)}}},W=async()=>{if(!(!P.trim()||Q)){R(!0),X(null);try{await l(P.trim()),z(""),_(!1)}catch(D){X(String(D))}finally{R(!1)}}},ee=D=>({padding:"6px 10px",border:"1px solid var(--border)",background:D?"var(--ink)":"white",color:D?"white":"var(--ink2)",fontFamily:"var(--mono)",fontSize:9});return i.jsxs("div",{style:{height:"100%",display:"flex",flexDirection:"column",overflow:"hidden"},children:[i.jsxs("div",{style:{height:48,borderBottom:"1px solid var(--border)",padding:"0 24px",display:"flex",alignItems:"center",justifyContent:"space-between",flexShrink:0},children:[i.jsx("div",{style:{display:"flex",gap:10,alignItems:"center",minWidth:0},children:i.jsxs("span",{style:{fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)"},children:[(M==null?void 0:M.label)||(M==null?void 0:M.name)||"workspace",V?` / ${V.name}`:""]})}),i.jsxs("div",{style:{display:"flex",gap:18,alignItems:"center",fontFamily:"var(--mono)",fontSize:10},children:[i.jsx("button",{onClick:d,style:{color:"var(--ink3)"},children:"tasks"}),i.jsxs("span",{style:{color:"var(--ink3)"},children:[t," engrams"]})]})]}),i.jsxs("div",{style:{flex:1,overflow:"auto",padding:28,display:"grid",gridTemplateColumns:"minmax(0, 1fr) 280px",gap:24},children:[i.jsxs("div",{style:{border:"1px solid var(--border)",background:"transparent",padding:24,display:"flex",flexDirection:"column",minHeight:0},children:[i.jsxs("div",{style:{display:"flex",justifyContent:"space-between",gap:12,alignItems:"center",marginBottom:16,flexWrap:"wrap"},children:[i.jsxs("div",{style:{display:"flex",gap:8,alignItems:"center",flexWrap:"wrap"},children:[i.jsx("button",{onClick:()=>x("task"),style:ee(m==="task"),children:"create task"}),i.jsx("button",{onClick:()=>x("memory"),style:ee(m==="memory"),children:"save memory"}),m==="task"&&i.jsxs(i.Fragment,{children:[i.jsx("button",{onClick:()=>E("codex"),style:ee(S==="codex"),children:"codex"}),i.jsx("button",{onClick:()=>E("claude-code"),style:ee(S==="claude-code"),children:"claude-code"}),S==="claude-code"&&i.jsxs(i.Fragment,{children:[i.jsx("button",{onClick:()=>H("standard"),style:ee(T==="standard"),children:"standard"}),i.jsx("button",{onClick:()=>H("full-access"),style:ee(T==="full-access"),children:"full access"})]})]})]}),i.jsx("button",{onClick:a,style:{padding:"7px 10px",border:"1px solid var(--border)",fontFamily:"var(--mono)",fontSize:9,color:"var(--ink3)"},children:"open workspace"})]}),m==="task"&&i.jsxs("div",{style:{display:"grid",gap:10,marginBottom:14},children:[i.jsxs("div",{style:{display:"flex",gap:8,alignItems:"center",flexWrap:"wrap"},children:[i.jsx("span",{style:{fontFamily:"var(--mono)",fontSize:9,color:"var(--ink3)"},children:"workspace"}),i.jsx("select",{value:(M==null?void 0:M.id)||"",onChange:D=>u(D.target.value),style:{border:"1px solid var(--border)",padding:"7px 10px",background:"white",minWidth:220},children:G.map(D=>i.jsx("option",{value:D.id,children:D.label||D.name},D.id))})]}),(ie=M==null?void 0:M.projects)!=null&&ie.length?i.jsxs("div",{style:{display:"flex",gap:8,alignItems:"center",flexWrap:"wrap"},children:[i.jsx("span",{style:{fontFamily:"var(--mono)",fontSize:9,color:"var(--ink3)"},children:"project"}),M.projects.map(D=>i.jsx("button",{onClick:()=>p(D.id),style:{...ee(D.id===(V==null?void 0:V.id)),background:D.id===(V==null?void 0:V.id)?"var(--accent)":"white"},children:D.name},D.id))]}):null]}),i.jsx("textarea",{ref:K,value:c,onChange:D=>g(D.target.value),onKeyDown:D=>{(D.metaKey||D.ctrlKey)&&D.key==="Enter"&&(D.preventDefault(),A())},placeholder:m==="task"?`- broadcast backend contract changes +- compare project scope rules +- create follow-up task for frontend stream`:`- backend project now emits model version updates +- paper asset is chunked and queryable +- avoid reprocessing shared results`,style:{width:"100%",flex:1,border:"1px solid var(--border)",padding:"18px 20px",fontSize:22,lineHeight:1.55,background:"white",resize:"none",minHeight:420}}),i.jsxs("div",{style:{display:"flex",justifyContent:"space-between",alignItems:"center",marginTop:14},children:[i.jsxs("div",{style:{fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)"},children:[C.length," point",C.length===1?"":"s"]}),i.jsx("button",{onClick:()=>void A(),style:{padding:"10px 16px",border:"1px solid var(--ink)",background:"var(--ink)",color:"white",fontFamily:"var(--mono)",fontSize:10},children:Q?"saving…":m==="task"?"create task":"save memory"})]}),J&&i.jsx("div",{style:{marginTop:12,fontSize:11,color:"var(--rose)"},children:J})]}),i.jsxs("div",{style:{display:"flex",flexDirection:"column",gap:12},children:[i.jsxs("div",{onClick:a,style:{border:"1px solid var(--border)",background:"white",padding:16,cursor:"pointer"},children:[i.jsx("div",{style:{marginBottom:8,fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)"},children:"CURRENT WORKSPACE"}),i.jsx("div",{style:{fontSize:16,fontWeight:600},children:(M==null?void 0:M.label)||(M==null?void 0:M.name)||"No workspace"}),i.jsx("div",{style:{marginTop:6,fontFamily:"var(--mono)",fontSize:9,color:"var(--ink3)"},children:(M==null?void 0:M.workspacePath)||"Select or create a workspace"}),V&&i.jsxs("div",{style:{marginTop:10,fontFamily:"var(--mono)",fontSize:9,color:"var(--ink3)"},children:[V.name," · default ",V.defaultRuntime||"codex"]}),ye&&i.jsx("button",{onClick:D=>{D.stopPropagation(),o(ye.id,ye.taskId||null)},style:{marginTop:12,padding:"7px 10px",border:"1px solid var(--border)",fontFamily:"var(--mono)",fontSize:9,color:"var(--ink3)"},children:"open current session"})]}),i.jsx("button",{onClick:()=>_(!0),style:{padding:"12px 14px",border:"1px solid var(--border)",background:"white",fontFamily:"var(--mono)",fontSize:10,textAlign:"left"},children:"+ add workspace"})]})]}),j&&i.jsx("div",{style:{position:"fixed",inset:0,background:"rgba(0,0,0,0.18)",display:"flex",alignItems:"center",justifyContent:"center",zIndex:40},onClick:()=>_(!1),children:i.jsxs("div",{onClick:D=>D.stopPropagation(),style:{width:460,maxWidth:"calc(100vw - 32px)",border:"1px solid var(--border)",background:"white",padding:20},children:[i.jsx("div",{style:{marginBottom:14,fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)"},children:"ADD WORKSPACE"}),i.jsxs("div",{style:{display:"grid",gap:10},children:[i.jsx("input",{value:P,onChange:D=>z(D.target.value),placeholder:"Workspace name",style:{border:"1px solid var(--border)",padding:"11px 12px",background:"white"}}),i.jsx("div",{style:{fontFamily:"var(--mono)",fontSize:9,color:"var(--ink3)",lineHeight:1.5},children:"A workspace is a collection of projects. Add projects and their folders after creating it."}),i.jsxs("div",{style:{display:"flex",justifyContent:"flex-end",gap:8,marginTop:4},children:[i.jsx("button",{onClick:()=>_(!1),style:{padding:"10px 12px",border:"1px solid var(--border)",background:"white",fontFamily:"var(--mono)",fontSize:10},children:"cancel"}),i.jsx("button",{onClick:()=>void W(),style:{padding:"10px 12px",border:"1px solid var(--ink)",background:"var(--ink)",color:"white",fontFamily:"var(--mono)",fontSize:10},children:Q?"creating…":"create workspace"})]})]})]})})]})}const el={fontFamily:"var(--mono)",fontSize:10,letterSpacing:"0.04em",textTransform:"uppercase"};function Mt(e){return Array.isArray(e)?e.filter(Boolean):[]}function Y(e,t,n=void 0){return!e||typeof e!="object"?n:e[t]??n}function ze(e){const t=Number(e||0);return new Intl.NumberFormat("en",{notation:Math.abs(t)>=1e4?"compact":"standard",maximumFractionDigits:Math.abs(t)>=1e4?1:0}).format(t)}function Wg(e){const t=String(e||"");if(!t)return"not linked";const n=t.split("/").filter(Boolean);return n.length>3?`.../${n.slice(-3).join("/")}`:t}function _a(e){if(!e)return"no timestamp";const t=new Date(e).getTime();if(Number.isNaN(t))return String(e);const n=Date.now()-t;return n<6e4?"just now":n<36e5?`${Math.floor(n/6e4)}m ago`:n<864e5?`${Math.floor(n/36e5)}h ago`:`${Math.floor(n/864e5)}d ago`}function $o(e){const t=String(e||"").toLowerCase();return t.includes("reject")||t.includes("fail")||t.includes("stale")?"var(--rose)":t.includes("pending")||t.includes("candidate")||t.includes("derived")?"var(--accent)":t.includes("promoted")||t.includes("active")||t.includes("ok")?"var(--green)":t.includes("evidence")||t.includes("digest")?"var(--indigo)":"var(--ink3)"}function Ci(e){const[t,n]=v.useState(null),[r,o]=v.useState(""),[l,s]=v.useState(!0),a=async()=>{s(!0),o("");try{n(await e())}catch(d){o(String(d))}finally{s(!1)}};return v.useEffect(()=>{a()},[]),{data:t,error:r,loading:l,refresh:a}}function bi({eyebrow:e,title:t,subtitle:n,children:r,action:o}){return i.jsx("div",{style:{height:"100%",overflowY:"auto",background:"var(--surface)"},children:i.jsxs("div",{style:{minHeight:"100%",padding:24,display:"flex",flexDirection:"column",gap:18},children:[i.jsxs("div",{style:{display:"flex",alignItems:"flex-start",justifyContent:"space-between",gap:20,borderBottom:"1px solid var(--border)",paddingBottom:18},children:[i.jsxs("div",{style:{maxWidth:760},children:[i.jsx("div",{style:{...el,color:"var(--accent)",marginBottom:8},children:e}),i.jsx("h1",{style:{fontSize:30,lineHeight:1.08,fontWeight:700,letterSpacing:0},children:t}),i.jsx("p",{style:{marginTop:8,color:"var(--ink2)",fontSize:14,lineHeight:1.55},children:n})]}),o]}),r]})})}function He({label:e,children:t,style:n}){return i.jsxs("section",{style:{background:"white",border:"1px solid var(--border)",padding:16,minWidth:0,...n},children:[e?i.jsx("div",{style:{...el,color:"var(--ink3)",marginBottom:12},children:e}):null,t]})}function Ye({label:e,value:t,tone:n}){return i.jsxs(He,{style:{minHeight:94},children:[i.jsx("div",{style:{fontSize:26,lineHeight:1,fontWeight:700,color:n||"var(--ink)"},children:t}),i.jsx("div",{style:{marginTop:8,color:"var(--ink3)",fontSize:12},children:e})]})}function tt({children:e,tone:t}){return i.jsx("span",{style:{...el,display:"inline-flex",alignItems:"center",minHeight:22,padding:"3px 8px",color:t||"var(--ink2)",background:"var(--surface2)",border:"1px solid var(--border)"},children:e})}function tl({rows:e,empty:t,render:n}){return e.length?i.jsx("div",{style:{display:"grid",gap:10},children:e.map(n)}):i.jsx("div",{style:{color:"var(--ink3)",fontSize:13},children:t})}function _i({loading:e,error:t}){return e?i.jsx(He,{children:"Loading Dhee state..."}):t?i.jsx(He,{children:i.jsx("span",{style:{color:"var(--rose)"},children:t})}):null}function Hg({onNavigate:e}){const{data:t,error:n,loading:r,refresh:o}=Ci(B.commandCenter),l=Y(t,"router",{}),s=Y(t,"context",{}),a=Y(t,"learnings",{}),d=Y(t,"inbox",{}),c=Y(t,"active_task",null),g=Mt(Y(t,"router_sessions",[])),m=Y(a,"totals",{}),x=Y(d,"totals",{});return i.jsxs(bi,{eyebrow:"COMMAND CENTER",title:"The current truth before the agent sees anything.",subtitle:"Start here to see task continuity, context health, routed savings, review queues, and the next best action for this repo.",action:i.jsx("button",{onClick:o,style:At,children:"refresh"}),children:[i.jsx(_i,{loading:r,error:n}),t?i.jsxs(i.Fragment,{children:[i.jsxs("div",{style:{display:"grid",gridTemplateColumns:"repeat(4, minmax(0, 1fr))",gap:12},children:[i.jsx(Ye,{label:"tokens avoided",value:ze(Y(l,"sessionTokensSaved",0)),tone:"var(--green)"}),i.jsx(Ye,{label:"router calls",value:ze(Y(l,"totalCalls",0)),tone:"var(--accent)"}),i.jsx(Ye,{label:"repo context",value:ze(Y(Y(s,"totals",{}),"repo_entries",0)),tone:"var(--indigo)"}),i.jsx(Ye,{label:"learning candidates",value:ze(Y(m,"candidate",0)),tone:"var(--accent)"})]}),i.jsxs("div",{style:{display:"grid",gridTemplateColumns:"1.1fr 0.9fr",gap:14},children:[i.jsx(He,{label:"ACTIVE WORK",children:c?i.jsxs("div",{children:[i.jsx("div",{style:{fontSize:22,lineHeight:1.2,fontWeight:700},children:String(Y(c,"title","Active task"))}),i.jsxs("div",{style:{marginTop:8,display:"flex",gap:8,flexWrap:"wrap"},children:[i.jsx(tt,{tone:$o(Y(c,"status")),children:String(Y(c,"status","active"))}),i.jsx(tt,{children:String(Y(c,"harness","agent"))})]})]}):i.jsx("div",{style:{color:"var(--ink3)"},children:"No active task yet. Start from a linked repo to let Dhee compile state."})}),i.jsxs(He,{label:"NEXT ACTION",children:[i.jsx("div",{style:{fontSize:18,fontWeight:650,lineHeight:1.35},children:String(Y(t,"next_action","Start a routed agent task"))}),i.jsxs("div",{style:{marginTop:14,display:"flex",gap:8,flexWrap:"wrap"},children:[i.jsx("button",{onClick:()=>e("handoff"),style:At,children:"handoff"}),i.jsx("button",{onClick:()=>e("router"),style:Do,children:"firewall"}),i.jsx("button",{onClick:()=>e("learnings"),style:Do,children:"learnings"})]})]})]}),i.jsxs("div",{style:{display:"grid",gridTemplateColumns:"1fr 1fr 1fr",gap:14},children:[i.jsx(He,{label:"LIVE SESSIONS",children:i.jsx(tl,{rows:g.slice(0,5),empty:"No routed sessions yet.",render:S=>i.jsx(Hr,{title:String(S.title||S.session_id||"session"),meta:`${S.agent||S.runtime||"agent"} - ${ze(S.tokens_saved)} tokens`,tone:$o(S.state)},String(S.session_id))})}),i.jsxs(He,{label:"REVIEW QUEUE",children:[i.jsx(Hr,{title:"proposals",meta:ze(Y(x,"proposals",0)),tone:"var(--accent)"}),i.jsx(Hr,{title:"findings",meta:ze(Y(x,"findings",0)),tone:"var(--rose)"}),i.jsx(Hr,{title:"conflicts",meta:ze(Y(x,"conflicts",0)),tone:"var(--indigo)"})]}),i.jsxs(He,{label:"ADDRESSABLE CONTEXT",children:[(Mt(Y(t,"dhee_aliases",[])).length,null),(Y(t,"dhee_aliases",[])||[]).map(S=>i.jsx("div",{style:{fontFamily:"var(--mono)",fontSize:11,padding:"5px 0",color:"var(--ink2)"},children:S},S))]})]})]}):null]})}function Vg(){const{data:e,error:t,loading:n,refresh:r}=Ci(B.handoffUi),o=Y(e,"continuity",{}),l=Y(o,"last_session",{})||{},s=Mt(Y(e,"tasks",[])),a=Mt(Y(e,"sessions",[])),d=Mt(Y(l,"files_touched",Y(l,"filesTouched",[]))),c=Mt(Y(l,"decisions",[])),g=Mt(Y(l,"todos",[]));return i.jsxs(bi,{eyebrow:"HANDOFF HUB",title:"Resume without replaying the transcript.",subtitle:"Dhee turns the latest work into task state: decisions, files, blockers, commands, tests, resume confidence, and the next step.",action:i.jsx("button",{onClick:r,style:At,children:"refresh"}),children:[i.jsx(_i,{loading:n,error:t}),e?i.jsxs("div",{style:{display:"grid",gridTemplateColumns:"1.1fr 0.9fr",gap:14},children:[i.jsxs(He,{label:"LATEST HANDOFF",children:[i.jsx("div",{style:{fontSize:24,lineHeight:1.15,fontWeight:700},children:String(Y(l,"task_summary","No handoff saved yet"))}),i.jsxs("div",{style:{marginTop:12,display:"flex",gap:8,flexWrap:"wrap"},children:[i.jsxs(tt,{tone:"var(--green)",children:["confidence ",Math.round(Number(Y(e,"resume_confidence",0))*100),"%"]}),i.jsx(tt,{children:_a(Y(l,"updated")||Y(l,"ended_at"))}),i.jsx(tt,{children:String(Y(l,"agent_id",Y(l,"source","dhee")))})]}),i.jsx("pre",{style:mp,children:String(Y(e,"command",""))})]}),i.jsx(He,{label:"RESUME INVENTORY",children:i.jsx(Jg,{rows:[["tasks",s.length],["sessions",a.length],["files",d.length],["decisions",c.length],["todos",g.length]]})}),i.jsx(He,{label:"DECISIONS",style:{gridColumn:"span 1"},children:i.jsx(Uu,{rows:c,empty:"No decisions captured yet."})}),i.jsx(He,{label:"FILES TOUCHED",children:i.jsx(Uu,{rows:d.map(m=>Wg(String(m))),empty:"No files in the latest handoff."})})]}):null]})}function Kg(){const{data:e,error:t,loading:n,refresh:r}=Ci(()=>B.proofReplay(120)),o=Mt(Y(e,"items",[])),l=Y(e,"totals",{});return i.jsxs(bi,{eyebrow:"PROOF REPLAY",title:"Replay the context decisions, not just the chat.",subtitle:"See the expansion trace: what Dhee digested, hid, expanded, injected, promoted, rejected, or derived from local records.",action:i.jsx("button",{onClick:r,style:At,children:"refresh"}),children:[i.jsx(_i,{loading:n,error:t}),i.jsxs("div",{style:{display:"grid",gridTemplateColumns:"repeat(4, minmax(0, 1fr))",gap:12},children:[i.jsx(Ye,{label:"events",value:ze(Y(l,"events",o.length))}),i.jsx(Ye,{label:"digests",value:ze(Y(l,"digests",0)),tone:"var(--green)"}),i.jsx(Ye,{label:"expansion trace",value:ze(Y(l,"expansions",0)),tone:"var(--accent)"}),i.jsx(Ye,{label:"evidence",value:ze(Y(l,"evidence",0)),tone:"var(--indigo)"}),i.jsx(Ye,{label:"derived rows",value:ze(Y(l,"derived",0))})]}),i.jsx(He,{label:"DECISION TIMELINE",children:i.jsx(tl,{rows:o,empty:"No context decisions recorded yet.",render:(s,a)=>i.jsx(Xg,{index:a,title:String(s.title||"Decision"),meta:`${s.source||"dhee"} - ${_a(s.time)}`,detail:String(s.detail||""),kind:String(s.kind||"event"),derived:!!s.derived},String(s.id||a))})})]})}function Qg(){const{data:e,error:t,loading:n,refresh:r}=Ci(()=>B.learningsUi(160)),[o,l]=v.useState(""),s=Mt(Y(e,"items",[])),a=Y(e,"totals",{}),d=async(c,g)=>{l(c);try{g==="promote"?await B.promoteLearning(c,{approved_by:"dhee-ui"}):await B.rejectLearning(c,{reason:"rejected in Dhee UI"}),await r()}finally{l("")}};return i.jsxs(bi,{eyebrow:"LEARNING INBOX",title:"Only evidence-backed learnings get promoted.",subtitle:"Clear pending review candidates from agent work. Dhee should learn from success, avoided failure, repeated utility, or explicit approval.",action:i.jsx("button",{onClick:r,style:At,children:"refresh"}),children:[i.jsx(_i,{loading:n,error:t}),i.jsxs("div",{style:{display:"grid",gridTemplateColumns:"repeat(4, minmax(0, 1fr))",gap:12},children:[i.jsx(Ye,{label:"candidates",value:ze(Y(a,"candidate",0)),tone:"var(--accent)"}),i.jsx(Ye,{label:"promoted",value:ze(Y(a,"promoted",0)),tone:"var(--green)"}),i.jsx(Ye,{label:"rejected",value:ze(Y(a,"rejected",0)),tone:"var(--rose)"}),i.jsx(Ye,{label:"all learnings",value:ze(Y(a,"all",s.length))})]}),i.jsx(He,{label:"LEARNING REVIEW",children:i.jsx(tl,{rows:s,empty:"No learning candidates yet.",render:c=>{const g=String(c.id||""),m=String(c.status||"candidate");return i.jsxs("div",{style:Zg,children:[i.jsxs("div",{style:{minWidth:0},children:[i.jsxs("div",{style:{display:"flex",gap:8,flexWrap:"wrap",marginBottom:8},children:[i.jsx(tt,{tone:$o(m),children:m}),i.jsx(tt,{children:String(c.evidence_gate||"needs approval")}),i.jsx(tt,{children:String(c.source_harness||c.source_agent_id||"agent")})]}),i.jsx("div",{style:{fontSize:17,fontWeight:700,lineHeight:1.25},children:String(c.title||g)}),i.jsx("div",{style:{marginTop:6,color:"var(--ink2)",lineHeight:1.55},children:String(c.body||"")})]}),i.jsxs("div",{style:{display:"flex",gap:8,flexShrink:0},children:[i.jsx("button",{disabled:!g||o===g||m==="promoted",onClick:()=>d(g,"promote"),style:At,children:"promote"}),i.jsx("button",{disabled:!g||o===g||m==="rejected",onClick:()=>d(g,"reject"),style:Do,children:"reject"})]})]},g)}})})]})}function Yg(){const{data:e,error:t,loading:n,refresh:r}=Ci(B.portabilityUi),[o,l]=v.useState(!1),[s,a]=v.useState(""),[d,c]=v.useState(null),[g,m]=v.useState(""),x=Y(e,"counts",{}),S=Mt(Y(e,"packs",[])),E=(Y(e,"contract",[])||[]).filter(Boolean),T=async()=>{l(!0),m("");try{await B.exportPackUi({}),await r()}catch(h){m(String(h))}finally{l(!1)}},H=async()=>{m(""),c(null);try{c(await B.importPackDryRunUi({input_path:s}))}catch(h){m(String(h))}};return i.jsxs(bi,{eyebrow:"PORTABILITY & TRUST",title:"Local memory should be inspectable, signed, and movable.",subtitle:"Dhee keeps export/import as a product surface, not an afterthought. No lock-in tricks, no hidden hosted dependency.",action:i.jsx("button",{onClick:r,style:At,children:"refresh"}),children:[i.jsx(_i,{loading:n,error:t}),i.jsxs("div",{style:{display:"grid",gridTemplateColumns:"repeat(4, minmax(0, 1fr))",gap:12},children:[i.jsx(Ye,{label:"memories",value:ze(Y(x,"memories",0))}),i.jsx(Ye,{label:"artifacts",value:ze(Y(x,"artifacts",0)),tone:"var(--indigo)"}),i.jsx(Ye,{label:"repo context",value:ze(Y(x,"repo_context_entries",0)),tone:"var(--green)"}),i.jsx(Ye,{label:"packs found",value:ze(S.length),tone:"var(--accent)"})]}),g?i.jsx(He,{children:i.jsx("span",{style:{color:"var(--rose)"},children:g})}):null,i.jsxs("div",{style:{display:"grid",gridTemplateColumns:"0.9fr 1.1fr",gap:14},children:[i.jsxs(He,{label:"PORTABLE SUBSTRATE",children:[i.jsx("div",{style:{display:"flex",gap:8,flexWrap:"wrap"},children:E.map(h=>i.jsx(tt,{tone:"var(--green)",children:h},h))}),i.jsx("button",{disabled:o,onClick:T,style:{...At,marginTop:16},children:o?"exporting...":"export .dheemem"})]}),i.jsxs(He,{label:"IMPORT DRY RUN",children:[i.jsxs("div",{style:{display:"flex",gap:10},children:[i.jsx("input",{value:s,onChange:h=>a(h.target.value),placeholder:"/path/to/backup.dheemem",style:qg}),i.jsx("button",{disabled:!s.trim(),onClick:H,style:At,children:"dry run"})]}),d?i.jsx("pre",{style:mp,children:JSON.stringify(Y(d,"result",d),null,2)}):null]})]}),i.jsx(He,{label:"RECENT PACKS",children:i.jsx(tl,{rows:S,empty:"No .dheemem packs found yet.",render:h=>i.jsx(Hr,{title:String(h.name||h.path),meta:`${h.verified?"verified":"unverified"} - ${ze(Number(h.size_bytes||0))} bytes - ${_a(h.updated_at)}`,tone:h.verified?"var(--green)":"var(--accent)"},String(h.path))})})]})}function Ev({onOpenContext:e}){return i.jsxs("div",{style:{position:"absolute",left:68,top:14,zIndex:8,display:"flex",gap:10,alignItems:"center",pointerEvents:"auto"},children:[i.jsx(tt,{tone:"var(--green)",children:"REPO BRAIN"}),i.jsx(tt,{children:"dhee://state/current"}),i.jsx(tt,{children:"dhee://handoff/latest"}),e?i.jsx("button",{onClick:e,style:Do,children:"context vault"}):null]})}function Uu({rows:e,empty:t}){return e.length?i.jsx("div",{style:{display:"grid",gap:8},children:e.map((n,r)=>i.jsx("div",{style:{padding:"8px 0",borderBottom:"1px solid var(--border)",color:"var(--ink2)"},children:String(n)},r))}):i.jsx("div",{style:{color:"var(--ink3)"},children:t})}function Jg({rows:e}){return i.jsx("div",{style:{display:"grid",gap:8},children:e.map(([t,n])=>i.jsxs("div",{style:{display:"flex",justifyContent:"space-between",gap:20},children:[i.jsx("span",{style:{color:"var(--ink3)"},children:t}),i.jsx("strong",{children:ze(n)})]},t))})}function Hr({title:e,meta:t,tone:n}){return i.jsxs("div",{style:{display:"flex",gap:10,alignItems:"flex-start",padding:"7px 0",borderBottom:"1px solid var(--border)"},children:[i.jsx("span",{style:{width:8,height:8,marginTop:6,background:n||"var(--ink3)",flexShrink:0}}),i.jsxs("div",{style:{minWidth:0},children:[i.jsx("div",{style:{fontSize:13,fontWeight:650,overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"},children:e}),i.jsx("div",{style:{fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)",marginTop:2},children:t})]})]})}function Xg({index:e,title:t,meta:n,detail:r,kind:o,derived:l}){return i.jsxs("div",{style:{display:"grid",gridTemplateColumns:"44px 1fr",gap:14,padding:"12px 0",borderBottom:"1px solid var(--border)"},children:[i.jsx("div",{style:{...el,color:"var(--ink3)"},children:String(e+1).padStart(2,"0")}),i.jsxs("div",{children:[i.jsxs("div",{style:{display:"flex",gap:8,flexWrap:"wrap",marginBottom:6},children:[i.jsx(tt,{tone:$o(o),children:o}),l?i.jsx(tt,{tone:"var(--accent)",children:"derived"}):i.jsx(tt,{tone:"var(--green)",children:"recorded"}),i.jsx(tt,{children:n})]}),i.jsx("div",{style:{fontSize:16,fontWeight:700},children:t}),r?i.jsx("div",{style:{marginTop:4,color:"var(--ink2)",lineHeight:1.55},children:r}):null]})]})}const At={border:"1px solid var(--ink)",background:"var(--ink)",color:"white",padding:"8px 12px",fontFamily:"var(--mono)",fontSize:10,letterSpacing:"0.04em",textTransform:"uppercase"},Do={...At,color:"var(--ink)",background:"white",borderColor:"var(--border2)"},qg={minHeight:36,flex:1,border:"1px solid var(--border2)",background:"white",padding:"0 10px",fontFamily:"var(--mono)",fontSize:11},mp={marginTop:14,border:"1px solid var(--border)",background:"var(--surface2)",padding:12,fontFamily:"var(--mono)",fontSize:11,whiteSpace:"pre-wrap",overflowX:"auto"},Zg={display:"grid",gridTemplateColumns:"1fr auto",gap:18,padding:"14px 0",borderBottom:"1px solid var(--border)",alignItems:"start"},Gg={border:"1px solid var(--border)",background:"var(--bg)",borderRadius:8,padding:18,width:"min(760px, 100%)",boxSizing:"border-box",display:"flex",flexWrap:"wrap",gap:18,boxShadow:"0 10px 28px rgba(20,16,10,0.06)"},Wu={fontFamily:"var(--mono)",fontSize:9,letterSpacing:"0.08em",textTransform:"uppercase",color:"var(--ink3)"},ev={borderRadius:5,cursor:"pointer",fontFamily:"var(--mono)",fontSize:10,padding:"8px 11px",whiteSpace:"nowrap"};function tv(e="secondary",t){const n=e==="primary";return{...ev,border:`1px solid ${n?"var(--ink)":"var(--border)"}`,background:n?"var(--ink)":"white",color:n?"white":"var(--accent)",opacity:t?.55:1,cursor:t?"not-allowed":"pointer"}}function hp({title:e="Set up a developer workspace",eyebrow:t="First run",body:n="Connect a repo folder, then start Codex or Claude Code from that folder so Dhee can mirror sessions and context.",actions:r=[],commands:o=["dhee onboard --root .","dhee doctor"],aside:l}){return i.jsxs("section",{style:Gg,children:[i.jsxs("div",{style:{flex:"1 1 300px",minWidth:0},children:[i.jsx("div",{style:Wu,children:t}),i.jsx("h2",{style:{margin:"5px 0 7px",fontSize:22,lineHeight:1.15,color:"var(--ink)",letterSpacing:0},children:e}),i.jsx("div",{style:{color:"var(--ink2)",fontSize:12.5,lineHeight:1.55,maxWidth:680},children:n}),r.length?i.jsx("div",{style:{display:"flex",gap:8,flexWrap:"wrap",marginTop:14},children:r.map(s=>i.jsx("button",{type:"button",onClick:s.onClick,disabled:s.disabled,style:tv(s.tone,s.disabled),children:s.label},s.label))}):null]}),i.jsxs("div",{style:{flex:"1 1 260px",border:"1px solid var(--border)",background:"var(--surface)",borderRadius:6,padding:12,minWidth:0},children:[i.jsx("div",{style:{...Wu,marginBottom:8},children:"Terminal path"}),i.jsx("div",{style:{display:"grid",gap:7},children:o.map(s=>i.jsx("code",{style:{display:"block",border:"1px solid var(--border)",background:"white",borderRadius:4,padding:"8px 9px",fontFamily:"var(--mono)",fontSize:10,color:"var(--ink)",lineHeight:1.45,overflowWrap:"anywhere"},children:s},s))}),l?i.jsx("div",{style:{marginTop:10},children:l}):null]})]})}const Dr=[{key:"day",label:"Daily",short:"24h",ms:24*60*60*1e3},{key:"week",label:"Weekly",short:"7d",ms:7*24*60*60*1e3},{key:"month",label:"Monthly",short:"30d",ms:30*24*60*60*1e3},{key:"year",label:"Yearly",short:"365d",ms:365*24*60*60*1e3}],Hu={items:[],next_cursor:null,active_only:!1,totals:{tokens_saved:0,estimated_cost_saved_usd:0,router_calls:0,sessions:0}};function vn(e){return e==null?"0":new Intl.NumberFormat("en",{notation:Math.abs(e)>=1e4?"compact":"standard",maximumFractionDigits:Math.abs(e)>=1e4?1:0}).format(e)}function Mn(e){return new Intl.NumberFormat("en-US").format(Math.max(0,Number(e||0)))}function Vr(e){const t=Math.max(0,Number(e||0));return t>0&&t<.01?"<$0.01":new Intl.NumberFormat("en-US",{style:"currency",currency:"USD",maximumFractionDigits:t>=100?0:2}).format(t)}function Xn(e){if(!e)return 0;const t=new Date(e).getTime();return Number.isNaN(t)?0:t}function Ea(e){const t=Xn(e);if(!t)return"n/a";const n=Date.now()-t;return n<6e4?"just now":n<36e5?`${Math.floor(n/6e4)}m ago`:n<864e5?`${Math.floor(n/36e5)}h ago`:`${Math.floor(n/864e5)}d ago`}function Ta(e){if(!e)return"n/a";const t=e.split("/").filter(Boolean);return t.length<=2?e:".../"+t.slice(-2).join("/")}function gp(e){var r;const t=typeof e=="string"?e:e.agent||e.runtime||((r=e.agents)==null?void 0:r[0])||"unknown",n=String(t||"").toLowerCase();return n.includes("codex")?"codex":n.includes("claude")?"claude-code":n||"unknown"}function nv(e){const t=gp(e||"");return t==="codex"?"Codex":t==="claude-code"?"Claude Code":e||"Unknown"}function za(e){const t=gp(e||"");return t==="codex"?"var(--indigo)":t==="claude-code"?"var(--accent)":"var(--ink3)"}function Ra(e){var t;return Number(((t=e.pricing)==null?void 0:t.input_cost_per_million)||0)>0}function Na(e){return e.tokens_saved>0&&!Ra(e)?"unpriced":Vr(e.estimated_cost_saved_usd)}function rv(e){const t=String(e.state||"").toLowerCase();return!!e.active&&(t==="active"||t==="running"||t==="live")}function vp(e){const t=e.pricing;if(!t||!Ra(e))return(t==null?void 0:t.note)||"No official provider/model rate mapped yet.";const n=t.provider||e.runtime||e.agent||"provider",r=t.model_family||e.model||"model";return`${n} ${r}: $${t.input_cost_per_million}/1M input tokens`}function yp(e,t){if(!e)return Number.POSITIVE_INFINITY;const r=Number(e[t==="day"?"daily_budget_usd":t==="week"?"weekly_budget_usd":t==="year"?"yearly_budget_usd":"monthly_budget_usd"]||0);return r>0?r:Number.POSITIVE_INFINITY}function Vu(e,t,n){return e.reduce((r,o)=>(r.tokens+=o.tokens_saved||0,r.apiValue+=Number(o.estimated_cost_saved_usd||0),r.calls+=o.router_calls||0,r.sessions+=1,r.cost=Math.min(r.apiValue,yp(t,n)),r),{tokens:0,apiValue:0,cost:0,calls:0,sessions:0})}function Ku(){const e=new URLSearchParams(window.location.search),t=String(e.get("view")||"").toLowerCase(),n=window.location.pathname.replace(/^\/+|\/+$/g,"").toLowerCase();return t==="router/sessionshistory"||t==="router/session-history"||t==="router/history"||n==="router/sessionshistory"?"history":"live"}function iv(e){const t=new URLSearchParams(window.location.search);t.set("view",e==="history"?"router/sessionshistory":"router");const n=t.toString(),r=`${window.location.pathname}${n?`?${n}`:""}${window.location.hash||""}`;window.history.pushState({},"",r),window.dispatchEvent(new Event("popstate"))}function ov({onOpenFolders:e,onOpenSetup:t}){return i.jsx("div",{style:{height:"100%",overflowY:"auto",background:"var(--surface)"},children:i.jsx(lv,{onOpenFolders:e,onOpenSetup:t})})}function lv({onOpenFolders:e,onOpenSetup:t}){const n=v.useRef(null),[r,o]=v.useState(Hu),[l,s]=v.useState(Hu),[a,d]=v.useState("week"),[c,g]=v.useState(()=>Ku()),[m,x]=v.useState(""),[S,E]=v.useState(!1),[T,H]=v.useState(null),h=async(K=!1)=>{K||E(!0),H(null);try{const[G,M]=await Promise.all([B.routerSessions({active:!1,limit:100}),B.routerSessions({active:!0,limit:50})]);o(G),s(M)}catch(G){H(String(G))}finally{K||E(!1)}};v.useEffect(()=>{h(!1);const K=window.setInterval(()=>void h(!0),15e3);return()=>window.clearInterval(K)},[]),v.useEffect(()=>{const K=()=>g(Ku());return window.addEventListener("popstate",K),()=>window.removeEventListener("popstate",K)},[]),v.useEffect(()=>{var K,G;(G=(K=n.current)==null?void 0:K.parentElement)==null||G.scrollTo({top:0,behavior:"auto"})},[c]);const u=v.useMemo(()=>[...l.items].filter(rv).sort((K,G)=>Xn(G.updated_at)-Xn(K.updated_at)),[l.items]),f=v.useMemo(()=>{const K=Dr.find(M=>M.key===a)||Dr[1],G=Date.now()-K.ms;return[...r.items].filter(M=>Xn(M.updated_at||M.started_at)>=G).sort((M,V)=>Xn(V.updated_at)-Xn(M.updated_at))},[r.items,a]),p=c==="history"?f.find(K=>K.session_id===m)||null:u.find(K=>K.session_id===m)||null,j=r.budget||l.budget,_=Vu(f,j,a),P=Vu(u,j,"day"),z=l.items.length>0||r.items.length>0,Q=Dr.find(K=>K.key===a)||Dr[1],R=yp(j,a),J=Number.isFinite(R)&&_.apiValue>R,X=K=>{g(K),iv(K)};return i.jsxs("div",{ref:n,style:{padding:"clamp(10px, 3vw, 18px)",display:"grid",gap:14,minWidth:0,width:"100%",boxSizing:"border-box"},children:[i.jsxs("section",{style:{border:"1px solid var(--border)",background:"var(--bg)",borderRadius:8,padding:16,minWidth:0,boxSizing:"border-box"},children:[i.jsxs("div",{style:{display:"flex",flexWrap:"wrap",gap:14,alignItems:"start",justifyContent:"space-between",marginBottom:14},children:[i.jsxs("div",{style:{flex:"1 1 240px",minWidth:0},children:[i.jsx(Hn,{children:"Context Firewall"}),i.jsx("h1",{style:{margin:"2px 0 0",fontSize:26,lineHeight:1.1,color:"var(--ink)",letterSpacing:0},children:c==="history"?"Firewall session history":"Live context firewall"}),i.jsx("p",{style:{margin:"6px 0 0",color:"var(--ink3)",fontSize:12,maxWidth:780},children:c==="history"?"Every completed and recent local agent session, with pointer-backed evidence and avoided raw context.":"Running Claude Code and Codex sessions, with raw output kept behind digests until the agent asks to expand."})]}),i.jsxs("div",{style:{display:"flex",gap:8,justifyContent:"flex-start",flexWrap:"wrap",flex:"0 1 auto"},children:[i.jsx("button",{onClick:()=>X(c==="history"?"live":"history"),style:{border:"1px solid var(--accent)",background:c==="history"?"white":"var(--accent-dim)",borderRadius:5,color:"var(--accent)",cursor:"pointer",fontFamily:"var(--mono)",fontSize:10,padding:"8px 11px"},children:c==="history"?"LIVE FIREWALL":"SESSION HISTORY"}),i.jsx("button",{onClick:()=>h(!1),disabled:S,style:{border:"1px solid var(--border)",background:"white",borderRadius:5,color:S?"var(--ink3)":"var(--accent)",cursor:S?"wait":"pointer",fontFamily:"var(--mono)",fontSize:10,padding:"8px 11px"},children:S?"SYNCING":"REFRESH"})]})]}),i.jsx("div",{style:{display:"flex",gap:7,flexWrap:"wrap",marginBottom:12},children:Dr.map(K=>{const G=K.key===a;return i.jsxs("button",{onClick:()=>d(K.key),style:{border:`1px solid ${G?"var(--accent)":"var(--border)"}`,background:G?"var(--accent-dim)":"white",color:G?"var(--accent)":"var(--ink2)",borderRadius:5,padding:"6px 10px",fontFamily:"var(--mono)",fontSize:10,cursor:"pointer"},children:[K.label,i.jsx("span",{style:{color:"var(--ink3)",marginLeft:6},children:K.short})]},K.key)})}),i.jsxs("div",{style:{display:"grid",gridTemplateColumns:"repeat(auto-fit, minmax(118px, 1fr))",gap:10},children:[i.jsx(an,{label:`${Q.label} API value`,value:Vr(_.apiValue),sub:"official input-rate estimate",accent:"var(--green)"}),i.jsx(an,{label:"Budget-capped savings",value:Vr(_.cost),sub:J?`capped at ${Vr(R)}`:"same as API value for this range",accent:"var(--green)"}),i.jsx(an,{label:`${Q.label} raw tokens avoided`,value:vn(_.tokens),sub:`${Mn(_.tokens)} avoided input tokens`,accent:"var(--green)"}),i.jsx(an,{label:"Live governed sessions",value:Mn(P.sessions),sub:`${vn(P.tokens)} active-session savings`,accent:"var(--accent)"})]})]}),T?i.jsxs("div",{style:{border:"1px solid var(--rose)",background:"white",color:"var(--rose)",padding:"10px 12px",borderRadius:6,fontFamily:"var(--mono)",fontSize:11},children:["context firewall data unavailable: ",T]}):null,!S&&!T&&!z?i.jsx(hp,{body:"Point Dhee at a repo folder, then start an agent task from that folder. The context firewall will fill with digests, evidence pointers, and expansions after the first mirrored Codex or Claude Code run.",actions:[...e?[{label:"ADD REPO FOLDER",onClick:e,tone:"primary"}]:[],...t?[{label:"START TASK",onClick:t}]:[]]}):null,c==="history"?i.jsx(Qu,{title:"Session history",sub:`${f.length} sessions in the last ${Q.short} · ${vn(_.tokens)} tokens · ${Vr(_.apiValue)} API value`,action:i.jsx("button",{onClick:()=>X("live"),style:{border:"1px solid var(--border)",background:"white",borderRadius:5,color:"var(--accent)",cursor:"pointer",fontFamily:"var(--mono)",fontSize:10,padding:"7px 10px",whiteSpace:"nowrap"},children:"LIVE FIREWALL"}),children:i.jsx(av,{rows:f,selectedId:(p==null?void 0:p.session_id)||"",onSelect:x,loading:S})}):i.jsx(Qu,{title:"Live governed sessions",sub:`${u.length} active local agent session${u.length===1?"":"s"} · click a session to inspect routing, evidence, and savings`,action:i.jsx("button",{onClick:()=>X("history"),style:{border:"1px solid var(--border)",background:"white",borderRadius:5,color:"var(--accent)",cursor:"pointer",fontFamily:"var(--mono)",fontSize:10,padding:"7px 10px",whiteSpace:"nowrap"},children:"HISTORY"}),children:u.length===0?i.jsx(xp,{children:"No active Claude Code or Codex sessions detected."}):i.jsx("div",{style:{display:"grid",gap:8},children:u.map(K=>i.jsx(sv,{row:K,selected:(p==null?void 0:p.session_id)===K.session_id,onSelect:()=>x(G=>G===K.session_id?"":K.session_id)},K.session_id))})})]})}function sv({row:e,selected:t,onSelect:n}){const r=za(e.agent||e.runtime),o=e.live_usage;return i.jsxs("div",{style:{width:"100%",border:`1px solid ${t?r:"var(--border)"}`,background:t?"var(--surface)":"white",borderRadius:6,overflow:"hidden"},children:[i.jsx("button",{type:"button","aria-expanded":t,onClick:n,style:{width:"100%",textAlign:"left",background:"transparent",border:0,padding:12,cursor:"pointer"},children:i.jsxs("div",{style:{display:"grid",gridTemplateColumns:"minmax(0, 1fr) repeat(3, minmax(86px, max-content)) 22px",gap:16,alignItems:"center"},children:[i.jsxs("div",{style:{minWidth:0},children:[i.jsx(Pa,{agent:e.agent||e.runtime||"unknown"}),i.jsx("div",{style:{fontSize:15,fontWeight:600,color:"var(--ink)",whiteSpace:"nowrap",textOverflow:"ellipsis",overflow:"hidden",marginTop:4},title:e.title,children:e.title||e.session_id}),i.jsxs("div",{style:{fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)",marginTop:3},title:e.cwd||e.repo_root,children:[Ta(e.repo_root||e.cwd)," - updated ",Ea(e.updated_at)]})]}),i.jsx(co,{label:"saved",value:vn(e.tokens_saved)}),i.jsx(co,{label:"API value",value:Na(e)}),i.jsx(co,{label:"live tokens",value:o!=null&&o.available?vn(o.total_tokens):"n/a"}),i.jsx("div",{style:{fontFamily:"var(--mono)",fontSize:18,lineHeight:1,color:t?r:"var(--ink3)",textAlign:"right"},"aria-hidden":"true",children:t?"-":"+"})]})}),t?i.jsx("div",{style:{borderTop:"1px solid var(--border)",padding:"12px 12px 14px",background:"white"},children:i.jsx(dv,{row:e,showHeader:!1})}):null]})}function av({rows:e,selectedId:t,onSelect:n,loading:r}){return e.length===0?i.jsx(xp,{children:r?"Loading sessions...":"No sessions in this range."}):i.jsx("div",{style:{border:"1px solid var(--border)",borderRadius:6,overflowX:"auto",background:"white"},children:i.jsxs("table",{style:{width:"100%",borderCollapse:"collapse",fontFamily:"var(--mono)",fontSize:11},children:[i.jsx("thead",{children:i.jsxs("tr",{style:{background:"var(--surface)"},children:[i.jsx(En,{children:"Session"}),i.jsx(En,{children:"Agent"}),i.jsx(En,{children:"State"}),i.jsx(En,{children:"Updated"}),i.jsx(En,{align:"right",children:"Tokens saved"}),i.jsx(En,{align:"right",children:"API value"}),i.jsx(En,{align:"right",children:"Calls"})]})}),i.jsx("tbody",{children:e.map(o=>{const l=t===o.session_id;return i.jsxs("tr",{onClick:()=>n(o.session_id),style:{borderTop:"1px solid var(--border)",background:l?"oklch(0.98 0.02 262)":"white",cursor:"pointer"},children:[i.jsxs(Tn,{title:o.title||o.session_id,children:[i.jsx("div",{style:{color:"var(--ink)",fontWeight:l?700:500,maxWidth:420,overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"},children:o.title||o.session_id}),i.jsx("div",{style:{color:"var(--ink3)",marginTop:2,maxWidth:420,overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"},title:o.cwd||o.repo_root,children:Ta(o.repo_root||o.cwd)})]}),i.jsx(Tn,{children:i.jsx(Pa,{agent:o.agent||o.runtime||"unknown"})}),i.jsx(Tn,{children:i.jsx(cv,{state:o.state,active:o.active})}),i.jsx(Tn,{children:Ea(o.updated_at)}),i.jsx(Tn,{align:"right",children:Mn(o.tokens_saved)}),i.jsx(Tn,{align:"right",title:vp(o),children:Na(o)}),i.jsx(Tn,{align:"right",children:Mn(o.router_calls)})]},o.session_id)})})]})})}function dv({row:e,showHeader:t=!0}){var o;const n=e.live_usage,r=Object.entries(e.tool_breakdown||{}).sort((l,s)=>s[1]-l[1]);return i.jsxs("div",{style:{display:"grid",gap:10},children:[t?i.jsxs("div",{children:[i.jsx(Pa,{agent:e.agent||e.runtime||"unknown"}),i.jsx("h2",{style:{margin:"6px 0 4px",fontSize:18,lineHeight:1.25,color:"var(--ink)",letterSpacing:0,display:"-webkit-box",WebkitLineClamp:3,WebkitBoxOrient:"vertical",overflow:"hidden"},title:e.title||e.session_id,children:e.title||e.session_id}),i.jsxs("div",{style:{fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)",overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"},title:e.cwd||e.repo_root||void 0,children:[e.model||"model unavailable"," · ",Ta(e.cwd||e.repo_root)]})]}):null,i.jsxs("div",{style:{display:"grid",gridTemplateColumns:"repeat(auto-fit, minmax(150px, 1fr))",gap:8},children:[i.jsx(an,{label:"tokens saved",value:vn(e.tokens_saved),sub:`${Mn(e.tokens_saved)} avoided`,accent:"var(--green)"}),i.jsx(an,{label:"API value",value:Na(e),sub:Ra(e)?"API value":"model unpriced",accent:"var(--green)"}),i.jsx(an,{label:"router calls",value:Mn(e.router_calls),sub:"cached reads",accent:"var(--ink2)"}),i.jsx(an,{label:"live tokens",value:n!=null&&n.available?vn(n.total_tokens):"n/a",sub:n!=null&&n.available?"native telemetry":"not captured",accent:za(e.agent||e.runtime)})]}),i.jsxs("div",{style:{border:"1px solid var(--border)",borderRadius:6,padding:10,background:"white"},children:[i.jsx(Hn,{children:"Pricing"}),i.jsx("div",{style:{fontSize:12,color:"var(--ink)",marginTop:5},children:vp(e)}),(o=e.pricing)!=null&&o.source?i.jsx("a",{href:e.pricing.source,target:"_blank",rel:"noreferrer",style:{display:"inline-block",marginTop:7,fontFamily:"var(--mono)",fontSize:10,color:"var(--accent)"},children:"official pricing source"}):null]}),n!=null&&n.available?i.jsx(uv,{row:e}):null,i.jsxs("div",{style:{border:"1px solid var(--border)",borderRadius:6,padding:10,background:"white"},children:[i.jsx(Hn,{children:"Read savings by tool"}),r.length===0?i.jsx("div",{style:{color:"var(--ink3)",fontSize:12,marginTop:7},children:"No cached reads yet."}):i.jsx("div",{style:{display:"grid",gap:6,marginTop:8},children:r.map(([l,s])=>i.jsxs("div",{style:{display:"flex",justifyContent:"space-between",gap:10,fontFamily:"var(--mono)",fontSize:11},children:[i.jsx("span",{style:{color:"var(--ink2)"},children:l}),i.jsxs("span",{style:{color:"var(--ink)"},children:[Mn(s)," calls"]})]},l))})]})]})}function uv({row:e}){const t=e.live_usage;if(!(t!=null&&t.available))return i.jsxs("div",{style:{border:"1px solid var(--border)",borderRadius:6,padding:12,background:"white"},children:[i.jsx(Hn,{children:"Live token usage"}),i.jsx("div",{style:{color:"var(--ink3)",fontSize:12,marginTop:8},children:"No exact live token report captured for this session yet."})]});const n=[["Input",t.input_tokens],["Cached input",t.cached_input_tokens],["Output",t.output_tokens],["Reasoning",t.reasoning_output_tokens],["Last turn",t.last_turn_tokens],["Context",t.context_window]];return i.jsxs("div",{style:{border:"1px solid var(--border)",borderRadius:6,padding:12,background:"white"},children:[i.jsxs("div",{style:{display:"flex",justifyContent:"space-between",gap:12},children:[i.jsx(Hn,{children:"Live token usage"}),i.jsx("span",{style:{fontFamily:"var(--mono)",fontSize:10,color:"var(--green)",whiteSpace:"nowrap"},children:"exact"})]}),i.jsx("div",{style:{display:"grid",gridTemplateColumns:"repeat(2, minmax(0, 1fr))",gap:9,marginTop:10},children:n.map(([r,o])=>i.jsx(co,{label:r,value:vn(o)},r))}),i.jsxs("div",{style:{fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)",marginTop:10},children:[t.source||"native telemetry"," - updated ",Ea(t.updated_at||e.updated_at)]})]})}function Qu({title:e,sub:t,action:n,children:r}){return i.jsxs("section",{style:{border:"1px solid var(--border)",background:"var(--bg)",borderRadius:8,padding:16,minWidth:0,boxSizing:"border-box"},children:[i.jsxs("div",{style:{display:"flex",justifyContent:"space-between",gap:12,alignItems:"baseline",marginBottom:12},children:[i.jsxs("div",{style:{minWidth:0},children:[i.jsx(Hn,{children:e}),t?i.jsx("div",{style:{marginTop:4,color:"var(--ink3)",fontSize:12,overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"},title:t,children:t}):null]}),n?i.jsx("div",{style:{flexShrink:0},children:n}):null]}),r]})}function an({label:e,value:t,sub:n,accent:r}){return i.jsxs("div",{style:{border:"1px solid var(--border)",background:"white",borderRadius:6,padding:11,minWidth:0},children:[i.jsx(Hn,{children:e}),i.jsx("div",{style:{marginTop:7,fontFamily:"var(--mono)",fontSize:22,lineHeight:1.05,fontWeight:700,color:r,overflow:"hidden",textOverflow:"ellipsis"},children:t}),n?i.jsx("div",{style:{color:"var(--ink3)",fontSize:11,marginTop:4},children:n}):null]})}function co({label:e,value:t}){return i.jsxs("div",{style:{minWidth:80},children:[i.jsx("div",{style:{fontFamily:"var(--mono)",fontSize:9,color:"var(--ink3)",textTransform:"uppercase",letterSpacing:"0.06em",marginBottom:3},children:e}),i.jsx("div",{style:{fontFamily:"var(--mono)",fontSize:14,fontWeight:700,color:"var(--ink)",whiteSpace:"nowrap"},children:t})]})}function Pa({agent:e}){const t=za(e);return i.jsxs("span",{style:{display:"inline-flex",alignItems:"center",gap:6,fontFamily:"var(--mono)",fontSize:10,color:t,textTransform:"uppercase",letterSpacing:"0.06em"},children:[i.jsx("span",{style:{width:7,height:7,borderRadius:999,background:t,flexShrink:0}}),nv(e)]})}function cv({state:e,active:t}){const n=t?"var(--green)":"var(--ink3)";return i.jsx("span",{style:{border:`1px solid ${n}`,color:n,borderRadius:4,padding:"1px 6px",fontSize:10},children:t?"active":e||"n/a"})}function xp({children:e}){return i.jsx("div",{style:{border:"1px dashed var(--border)",color:"var(--ink3)",background:"white",borderRadius:6,padding:18,textAlign:"center",fontSize:12},children:e})}function Hn({children:e}){return i.jsx("div",{style:{fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)",letterSpacing:"0.08em",textTransform:"uppercase",fontWeight:700},children:e})}function En({children:e,align:t}){return i.jsx("th",{style:{padding:"8px 10px",textAlign:t||"left",color:"var(--ink2)",fontWeight:700,letterSpacing:"0.04em",borderBottom:"1px solid var(--border)",whiteSpace:"nowrap"},children:e})}function Tn({children:e,align:t,title:n}){return i.jsx("td",{title:n,style:{padding:"8px 10px",textAlign:t||"left",color:"var(--ink2)",verticalAlign:"middle"},children:e})}function fv({tasks:e,projectIndex:t,onSelectTask:n,onSelectSession:r,tweaks:o}){var x,S,E,T,H,h,u,f;const l={green:"var(--green)",indigo:"var(--indigo)",orange:"var(--accent)",rose:"var(--rose)"},s=((x=t==null?void 0:t.workspaces)==null?void 0:x.find(p=>p.id===(t==null?void 0:t.currentWorkspaceId)))||((S=t==null?void 0:t.workspaces)==null?void 0:S[0])||null,a=((E=s==null?void 0:s.projects)==null?void 0:E.find(p=>p.id===(t==null?void 0:t.currentProjectId)))||((T=s==null?void 0:s.projects)==null?void 0:T[0])||null,d=((H=a==null?void 0:a.sessions)==null?void 0:H.find(p=>p.id===(t==null?void 0:t.currentSessionId)))||((h=a==null?void 0:a.sessions)==null?void 0:h[0])||((u=s==null?void 0:s.sessions)==null?void 0:u.find(p=>p.id===(t==null?void 0:t.currentSessionId)))||((f=s==null?void 0:s.sessions)==null?void 0:f[0])||null,c=e.find(p=>p.id===(d==null?void 0:d.taskId))||e[0]||null,g=e.filter(p=>p.id!==(c==null?void 0:c.id)),m=p=>i.jsxs("button",{onClick:()=>n(p.id),style:{display:"grid",gridTemplateColumns:"12px minmax(0, 1fr) 18px",alignItems:"center",gap:14,padding:"14px 0",borderBottom:"1px solid var(--border)",textAlign:"left",background:"transparent"},children:[i.jsx("span",{style:{width:10,height:10,background:l[p.color]||"var(--accent)",display:"inline-block"}}),i.jsxs("span",{style:{minWidth:0},children:[i.jsx("div",{style:{fontSize:16,fontWeight:560,overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"},children:p.title}),i.jsxs("div",{style:{marginTop:4,fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)",display:"flex",gap:10,flexWrap:"wrap"},children:[o.showTimestamps&&i.jsx("span",{children:p.created}),i.jsxs("span",{children:[p.messages.length," msgs"]}),p.harness&&i.jsx("span",{children:p.harness})]})]}),i.jsx("span",{style:{color:"var(--ink3)",fontSize:18},children:"→"})]},p.id);return i.jsxs("div",{style:{height:"100%",display:"flex",flexDirection:"column",overflow:"hidden"},children:[i.jsxs("div",{style:{height:48,borderBottom:"1px solid var(--border)",padding:"0 24px",display:"flex",alignItems:"center",justifyContent:"space-between",flexShrink:0},children:[i.jsx("div",{style:{fontFamily:"var(--mono)",fontSize:11,color:"var(--ink3)",letterSpacing:"0.08em"},children:"TASKS"}),i.jsxs("div",{style:{fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)"},children:[e.length," tracked tasks"]})]}),i.jsxs("div",{style:{flex:1,overflow:"auto",padding:24,display:"grid",gap:20},children:[d&&i.jsxs("div",{onClick:()=>r(d.id,d.taskId||null),style:{border:"1px solid var(--green)",background:"white",padding:18,cursor:"pointer"},children:[i.jsxs("div",{style:{display:"flex",alignItems:"center",gap:8,marginBottom:10,flexWrap:"wrap"},children:[i.jsx("span",{style:{width:9,height:9,background:"var(--green)",display:"inline-block"}}),i.jsx("span",{style:{fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)"},children:"LIVE TASK"}),i.jsx("span",{style:{fontFamily:"var(--mono)",fontSize:10,color:"var(--accent)"},children:d.runtime})]}),i.jsx("div",{style:{fontSize:24,fontWeight:650,lineHeight:1.2},children:(c==null?void 0:c.title)||d.title}),i.jsx("div",{style:{marginTop:8,fontSize:13,color:"var(--ink2)",lineHeight:1.5},children:d.preview||"Current mirrored session is ready to continue."})]}),i.jsxs("div",{style:{border:"1px solid var(--border)",background:"white",padding:18},children:[i.jsx("div",{style:{marginBottom:12,fontFamily:"var(--mono)",fontSize:10,color:"var(--ink3)"},children:"TASK HISTORY"}),i.jsxs("div",{style:{display:"grid",gap:0},children:[g.length===0&&i.jsx("div",{style:{padding:"36px 0",textAlign:"center",fontFamily:"var(--mono)",fontSize:11,color:"var(--ink3)"},children:"No task history yet."}),g.map(m)]})]})]})]})}function pv({url:e,title:t,lines:n}){const[r,o]=v.useState(!0);return i.jsxs("div",{style:{border:"1px solid var(--border)",marginTop:8,background:"white"},children:[i.jsxs("div",{onClick:()=>o(l=>!l),style:{borderBottom:r?"1px solid var(--border)":"none",padding:"6px 10px",display:"flex",alignItems:"center",gap:8,background:"var(--surface)",cursor:"pointer"},children:[i.jsx("span",{style:{fontFamily:"var(--mono)",fontSize:9,color:"var(--ink3)",letterSpacing:1},children:"BROWSER"}),i.jsx("span",{style:{flex:1,fontFamily:"var(--mono)",fontSize:10,color:"var(--ink2)",overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"},children:e}),i.jsx("span",{style:{fontSize:10,color:"var(--ink3)"},children:r?"▲":"▼"})]}),r&&i.jsxs("div",{style:{padding:"10px 12px"},children:[i.jsx("div",{style:{fontWeight:600,fontSize:13,marginBottom:8},children:t}),n.map((l,s)=>i.jsxs("div",{style:{display:"flex",gap:7,marginBottom:3},children:[i.jsx("span",{style:{color:"var(--accent)",fontFamily:"var(--mono)",fontSize:9,marginTop:2,flexShrink:0},children:"→"}),i.jsx("span",{style:{color:"var(--ink2)",fontSize:12.5,lineHeight:1.4},children:l})]},s))]})]})}function mv({query:e,files:t}){return i.jsxs("div",{style:{border:"1px solid var(--border)",marginTop:8,background:"white"},children:[i.jsxs("div",{style:{borderBottom:"1px solid var(--border)",padding:"6px 10px",display:"flex",gap:8,alignItems:"center",background:"var(--surface)"},children:[i.jsx("span",{style:{fontFamily:"var(--mono)",fontSize:9,color:"var(--ink3)",letterSpacing:1},children:"GREP"}),i.jsxs("span",{style:{fontFamily:"var(--mono)",fontSize:10,color:"var(--accent)"},children:['"',e,'"']}),i.jsxs("span",{style:{marginLeft:"auto",fontFamily:"var(--mono)",fontSize:9,color:"var(--ink3)"},children:[t.length," matches"]})]}),i.jsx("div",{style:{fontFamily:"var(--mono)",fontSize:11.5},children:t.map((n,r)=>i.jsxs("div",{style:{padding:"8px 12px",borderBottom:r
+ {command}
+
+ ))}
+