gemcode 0.4.18__tar.gz → 0.4.19__tar.gz

{gemcode-0.4.18/src/gemcode.egg-info → gemcode-0.4.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.4.18
+Version: 0.4.19
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -220,6 +220,7 @@ All state lives under `.gemcode/` in the project root. No external services requ
 | IDE stdio | Editor integration over JSONL stdin/stdout |
 | Agent Mesh | In-process multi-agent orchestration (automatic) |
 | GemCode Runtime | Optional always-on background scheduler (`gemcode runtime`; alias `gemcode kaira`) |
+| HTTP API (`gemcode serve`) | Built-in web/custom UI backend on `http://127.0.0.1:3001` — chat SSE, sessions, panel, HITL |
 | A2A server | Cross-machine agent communication via Google A2A protocol |
 | Live audio (experimental) | Microphone-driven Gemini Live sessions |
 
@@ -273,6 +274,18 @@ export GOOGLE_API_KEY="your-key"
 gemcode -C /path/to/project
 ```
 
+### Connect a web or custom UI (optional)
+GemCode ships the **HTTP API** in the PyPI package; frontends are separate clients.
+
+```bash
+gemcode serve -C /path/to/project
+# default: http://127.0.0.1:3001 — point any UI at this URL (Settings → API URL)
+```
+
+From the REPL/TUI: `/serve` (background), `/serve status`, `/serve stop`, `/serve url`.
+
+Contract and routes: [`../docs/web-ui-contract.md`](../docs/web-ui-contract.md).
+
 ### One-shot run
 ```bash
 gemcode -C /path/to/project "Explain this repository"

{gemcode-0.4.18 → gemcode-0.4.19}/README.md

@@ -27,6 +27,7 @@ All state lives under `.gemcode/` in the project root. No external services requ
 | IDE stdio | Editor integration over JSONL stdin/stdout |
 | Agent Mesh | In-process multi-agent orchestration (automatic) |
 | GemCode Runtime | Optional always-on background scheduler (`gemcode runtime`; alias `gemcode kaira`) |
+| HTTP API (`gemcode serve`) | Built-in web/custom UI backend on `http://127.0.0.1:3001` — chat SSE, sessions, panel, HITL |
 | A2A server | Cross-machine agent communication via Google A2A protocol |
 | Live audio (experimental) | Microphone-driven Gemini Live sessions |
 
@@ -80,6 +81,18 @@ export GOOGLE_API_KEY="your-key"
 gemcode -C /path/to/project
 ```
 
+### Connect a web or custom UI (optional)
+GemCode ships the **HTTP API** in the PyPI package; frontends are separate clients.
+
+```bash
+gemcode serve -C /path/to/project
+# default: http://127.0.0.1:3001 — point any UI at this URL (Settings → API URL)
+```
+
+From the REPL/TUI: `/serve` (background), `/serve status`, `/serve stop`, `/serve url`.
+
+Contract and routes: [`../docs/web-ui-contract.md`](../docs/web-ui-contract.md).
+
 ### One-shot run
 ```bash
 gemcode -C /path/to/project "Explain this repository"

{gemcode-0.4.18 → gemcode-0.4.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gemcode"
-version = "0.4.18"
+version = "0.4.19"
 description = "Local-first coding agent on Google Gemini + ADK"
 readme = "README.md"
 requires-python = ">=3.11"

{gemcode-0.4.18 → gemcode-0.4.19}/src/gemcode/agent.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 import inspect
 from pathlib import Path
+from typing import Any
 
 from google.adk.agents.llm_agent import LlmAgent
 
@@ -25,7 +26,7 @@ from gemcode.config import GemCodeConfig
 from gemcode.context_budget import make_before_model_context_shrink_callback
 from gemcode.limits import make_before_model_limits_callback, make_before_model_token_budget_callback
 from gemcode.thinking import build_thinking_config
-from gemcode.tools import build_function_tools
+from gemcode.tools import build_function_tools, filter_tools_for_web_workspace_mode
 from gemcode.tool_prompt_manifest import build_tool_manifest
 from gemcode.skills import (
   build_skill_manifest_text,
@@ -380,6 +381,14 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
     "(cap via `GEMCODE_FLEET_REPORTS_AUTO_CONTINUE_MAX`, debounce `GEMCODE_FLEET_REPORTS_ENQUEUE_DEBOUNCE_S`)."
   )
 
+  web_serve_section = (
+    "- **Web / custom UI** — `gemcode serve -C <project>` (or `/serve` in the REPL) starts the built-in "
+    "HTTP API on `http://127.0.0.1:3001` by default. Any frontend (official web app, your own dashboard, "
+    "editor plugin) connects to `/api/*` — chat SSE, sessions, panel, preview ports, HITL approve, org/mesh, "
+    "runtime, terminal. The UI is optional and lives outside the PyPI package; GemCode is the server. "
+    "Contract: `docs/web-ui-contract.md`."
+  )
+
   # ── Git context ───────────────────────────────────────────────────────────
   git_ctx = _get_git_context(root)
   git_section = f"\n\n## Git context (snapshot at session start)\n{git_ctx}" if git_ctx else ""
@@ -427,6 +436,7 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
 - **Your tool palette can grow mid-session:** if the user enables a capability via a slash command, the runner rebuilds and you get new tools on the next turn.
 - **Memory system:** when `memory ON`, ADK automatically searches `.gemcode/memories.jsonl` and injects relevant past context before each turn. Facts the user tells you in one session can appear in future sessions. You do not need to manage memory explicitly — it is loaded automatically.
 {kaira_section}
+{web_serve_section}
 - **UI banner** phrases like "GemCode Pro" are terminal marketing, not a separate API tier.
 - **Env toggles** (`GEMCODE_ENABLE_COMPUTER_USE`, `GEMCODE_MODEL`, etc.) affect only the OS process that launched gemcode. Pasting `VAR=1` in chat does NOT reconfigure a running session—tell the user to export in their shell, use project `.env`, or restart the CLI.
 - **Working in subfolders** — call `list_directory(\"Desktop\")`, `glob_files(\"**/query.ts\")`, `read_file(\"testing/ai-edtech-app/src/app/page.tsx\")` directly. Never claim access is blocked unless a tool returned an explicit error.{git_section}{curated_section}{veomem_section}"""
@@ -717,7 +727,7 @@ def build_instruction(cfg: GemCodeConfig) -> str:
     else ""
   )
 
-  base = f"""You are GemCode — an alternative to Claude Code built on Google ADK and Gemini.
+  base = f"""You are GemCode — a local coding agent built on Google ADK and Gemini.
 You run locally via the GemCode CLI. You are the same agent the user launched — not a hosted portal.
 
 {_build_runtime_facts(cfg)}
@@ -1171,7 +1181,26 @@ You have two tools to persist project insights across sessions (auto-memory styl
   workspace_md = _load_agent_workspace_md(cfg.project_root)
   if workspace_md:
     base = f"{base}\n\n{workspace_md}"
+  web_mode = getattr(cfg, "_web_workspace_mode", None)
+  if web_mode in ("code", "agents"):
+    mode_note = (
+      "Agents mode emphasizes org_delegate, org_spawn, run_subtask, and mesh tools for multi-agent work. "
+      if web_mode == "agents"
+      else ""
+    )
+    base = (
+      f"{base}\n\n## Web IDE ({web_mode} mode)\n"
+      f"{mode_note}"
+      "You are running in the GemCode **web UI** with a live connection to the user's local workspace. "
+      "You **have** filesystem tools — use `read_file`, `list_directory`, `repo_map`, etc. "
+      "Never claim you cannot browse or read local files. "
+      "Each user message may include a **Web IDE context** block with the active editor file and workspace root — "
+      'honor it for phrases like "this file", "the current one", or whole-project analysis requests.'
+    )
   extra = _load_gemini_md(cfg.project_root)
+  web_prompt = getattr(cfg, "_web_system_prompt", None)
+  if isinstance(web_prompt, str) and web_prompt.strip():
+    base = f"{base}\n\n## User preferences (web UI)\n{web_prompt.strip()}"
   if extra.strip():
     return f"{base}\n\n## Project instructions (gemcode.md)\n{extra}"
   return base
@@ -1207,6 +1236,10 @@ def build_root_agent(
     tools = list(_tools)
   else:
     tools = build_function_tools(cfg)
+    tools = filter_tools_for_web_workspace_mode(
+      tools,
+      getattr(cfg, "_web_workspace_mode", None),
+    )
   if getattr(cfg, "enable_memory", False):
     # ADK preload_memory injects retrieved memories into the next llm_request.
     from google.adk.tools import preload_memory
@@ -1214,18 +1247,23 @@ def build_root_agent(
 
   # ADK built-in interactive + artifact tools — always available when ADK supports them.
   # In super mode, ``get_user_choice`` auto-picks the first option (no UI).
+  function_tool_count = len(tools)
   try:
     from gemcode.tools.user_choice import append_user_choice_load_artifacts_exit_loop
 
     append_user_choice_load_artifacts_exit_loop(cfg, tools)
   except Exception:
     pass
+  mixes_adk_builtin_with_functions = (
+    len(tools) > function_tool_count and function_tool_count > 0
+  )
 
-  # Agent auto-notes: write project insights to .gemcode/notes.md (project notes file)
+  # Notes tools write to the repo — chat mode stays conversational.
   try:
     from gemcode.tools.notes import build_notes_tools
     notes_tools = build_notes_tools(cfg.project_root)
-    tools = [*tools, *notes_tools]
+    if getattr(cfg, "_web_workspace_mode", None) != "chat":
+      tools = [*tools, *notes_tools]
   except Exception:
     pass
 
@@ -1268,11 +1306,13 @@ def build_root_agent(
     # Unknown values: stay conservative.
     enable_for_run = bool(getattr(cfg, "enable_deep_research", False))
 
-  if enable_for_run and is_gemini_3:
+  if mixes_adk_builtin_with_functions or (
+    enable_for_run and is_gemini_3 and comb_mode != "never"
+  ):
     from google.genai import types
 
-    # Gemini "tool context circulation" enables built-in tools results to
-    # be combined with your client-side function tools in the same workflow.
+    # Gemini requires this when ADK built-in tools (load_artifacts, get_user_choice, …)
+    # are combined with GemCode function tools in the same turn.
     tool_cfg = types.ToolConfig(include_server_side_tool_invocations=True)
 
   if thinking_cfg is not None or tool_cfg is not None:
@@ -1283,6 +1323,28 @@ def build_root_agent(
       tool_config=tool_cfg,
     )
 
+  web_temp = getattr(cfg, "_web_temperature", None)
+  web_max = getattr(cfg, "_web_max_output_tokens", None)
+  if web_temp is not None or web_max is not None:
+    from google.genai import types
+
+    gen_kwargs: dict[str, Any] = {}
+    if gen_cfg is not None:
+      if getattr(gen_cfg, "thinking_config", None) is not None:
+        gen_kwargs["thinking_config"] = gen_cfg.thinking_config
+      if getattr(gen_cfg, "tool_config", None) is not None:
+        gen_kwargs["tool_config"] = gen_cfg.tool_config
+    elif thinking_cfg is not None:
+      gen_kwargs["thinking_config"] = thinking_cfg
+    if tool_cfg is not None:
+      gen_kwargs["tool_config"] = tool_cfg
+    if web_temp is not None:
+      gen_kwargs["temperature"] = float(web_temp)
+    if web_max is not None:
+      gen_kwargs["max_output_tokens"] = int(web_max)
+    if gen_kwargs:
+      gen_cfg = types.GenerateContentConfig(**gen_kwargs)
+
   # ── ADK multi-agent tree (LLM-controlled transfer) ───────────────────────
   sub_agents = []
   if getattr(cfg, "enable_adk_agent_transfer", True) and _tools is None:

{gemcode-0.4.18 → gemcode-0.4.19}/src/gemcode/callbacks.py

@@ -35,6 +35,15 @@ _ERROR_KIND_PERMISSION_DENIED = "permission_denied"
 _ERROR_KIND_CIRCUIT_BREAKER = "circuit_breaker"
 _ERROR_KIND_TOOL_EXCEPTION = "tool_exception"
 _ERROR_KIND_PERMISSION_BLOCK = "permission_block"
+
+
+def _interactive_hitl_enabled(cfg: GemCodeConfig) -> bool:
+  """True when in-run y/n (or web Approve/Deny) should gate mutating/shell tools."""
+  if getattr(cfg, "interactive_permission_ask", False):
+    return True
+  if getattr(cfg, "_gemcode_web_sse", False) or getattr(cfg, "_web_interactive_hitl", False):
+    return True
+  return False
 _BT_CC = "gemcode:bt_cc"
 _BT_LD = "gemcode:bt_ld"
 _BT_LG = "gemcode:bt_lg"
@@ -259,7 +268,7 @@ def make_before_tool_callback(cfg: GemCodeConfig):
       if not cfg.yes_to_all:
         # In-run HITL: request ADK tool confirmation and pause execution until
         # the user approves in the current terminal session.
-        if getattr(cfg, "interactive_permission_ask", False):
+        if _interactive_hitl_enabled(cfg):
           # After one approval this ADK session, optional skip (see GEMCODE_HITL_STICKY_SESSION).
           if _hitl_sticky_enabled(tool_context):
             return None
@@ -310,7 +319,7 @@ def make_before_tool_callback(cfg: GemCodeConfig):
           "error_kind": _ERROR_KIND_PERMISSION_DENIED,
         }
       if not cfg.yes_to_all:
-        if getattr(cfg, "interactive_permission_ask", False):
+        if _interactive_hitl_enabled(cfg):
           if _hitl_sticky_enabled(tool_context):
             return None
           tc_state = _tool_confirmation_state(tool_context)

{gemcode-0.4.18 → gemcode-0.4.19}/src/gemcode/cli.py

@@ -598,6 +598,13 @@ def main() -> None:
     print(f"Saved to {credentials_path()}", file=sys.stderr)
     return
 
+  # HTTP API for web UIs and other clients: `gemcode serve`
+  if len(sys.argv) > 1 and sys.argv[1] == "serve":
+    from gemcode.web.server import main as serve_main
+
+    serve_main(sys.argv[2:])
+    return
+
   # Quick command bypass (no prompt parsing): list available Gemini models.
   if (
     len(sys.argv) > 1

{gemcode-0.4.18 → gemcode-0.4.19}/src/gemcode/invoke.py

@@ -90,6 +90,80 @@ def _is_simple_prompt(prompt: str) -> bool:
   return False
 
 
+def _is_simple_prompt_for_cfg(cfg: GemCodeConfig, prompt: str, attachment_paths) -> bool:
+  """Code/Agents mode in the web UI always gets full workspace enrichment."""
+  if getattr(cfg, "_web_workspace_mode", None) in ("code", "agents"):
+    return False
+  if attachment_paths:
+    return False
+  return _is_simple_prompt(prompt)
+
+
+def prepare_turn_prompt(
+    cfg: "GemCodeConfig",
+    prompt: str,
+    *,
+    session_id: str,
+    attachment_paths: Sequence[Path | str] | None = None,
+    consume_fleet_reports: bool = True,
+) -> str:
+  """Apply the same prompt enrichment as ``run_turn`` before invoking the runner."""
+  is_simple = _is_simple_prompt_for_cfg(cfg, prompt, attachment_paths)
+
+  if not is_simple:
+    try:
+      from gemcode.agent_mesh import ensure_mesh
+      mesh = ensure_mesh(cfg)
+      mesh.start()
+    except Exception:
+      pass
+
+    try:
+      if not getattr(cfg, "_intelligence_bootstrapped", False):
+        object.__setattr__(cfg, "_intelligence_bootstrapped", True)
+        from gemcode.agent_intelligence import first_session_bootstrap
+        first_session_bootstrap(cfg)
+    except Exception:
+      pass
+
+  try:
+    object.__setattr__(cfg, "_active_session_id", session_id)
+  except Exception:
+    pass
+
+  if consume_fleet_reports and not is_simple:
+    try:
+      from gemcode.fleet_reports import drain_for_prompt
+      preamble = drain_for_prompt(cfg.project_root)
+      if preamble:
+        prompt = preamble + "\n\n---\n\n" + (prompt or "")
+    except Exception:
+      pass
+
+  if not is_simple:
+    try:
+      from gemcode.agent_intelligence import enhance_turn
+      prompt = enhance_turn(cfg, prompt)
+    except Exception:
+      pass
+
+    try:
+      from gemcode.codebase_awareness import build_awareness_context
+      if getattr(cfg, "_web_workspace_mode", None) != "chat":
+        awareness = build_awareness_context(cfg.project_root)
+        if awareness:
+          prompt = awareness + "\n\n" + prompt
+    except Exception:
+      pass
+
+  try:
+    object.__setattr__(cfg, "_risk_score", _compute_risk_score(prompt, attachment_paths))
+  except Exception:
+    pass
+
+  return prompt
+
+
 async def run_turn(
     runner: Runner,
     *,
@@ -104,7 +178,9 @@ async def run_turn(
   """Execute one user message; collect all Events (caller aggregates text)."""
 
   # ── Fast path: skip heavy machinery for simple prompts ──────────────────
-  is_simple = _is_simple_prompt(prompt) and not attachment_paths
+  is_simple = _is_simple_prompt_for_cfg(cfg, prompt, attachment_paths) if cfg is not None else (
+    _is_simple_prompt(prompt) and not attachment_paths
+  )
 
   # ── Mesh + bootstrap (only on first call or complex prompts) ────────────
   if cfg is not None and not is_simple:
@@ -151,9 +227,10 @@ async def run_turn(
       # Codebase awareness: inject persistent project understanding
       try:
         from gemcode.codebase_awareness import build_awareness_context
-        awareness = build_awareness_context(cfg.project_root)
-        if awareness:
-          prompt = awareness + "\n\n" + prompt
+        if getattr(cfg, "_web_workspace_mode", None) != "chat":
+          awareness = build_awareness_context(cfg.project_root)
+          if awareness:
+            prompt = awareness + "\n\n" + prompt
       except Exception:
         pass
 

{gemcode-0.4.18 → gemcode-0.4.19}/src/gemcode/org.py

@@ -26,8 +26,10 @@ def resolve_fleet_root(start_root: Path) -> Path:
   we still want org tools to operate on the shared `.gemcode/org.json` at the
   parent project root.
 
-  Strategy: walk up ancestors until we find `.gemcode/org.json`. If none is found,
-  fall back to the provided start_root.
+  Strategy: walk up from ``start_root`` and return the **nearest** ancestor whose
+  ``.gemcode/`` directory contains ``org.json``, ``habits.json``, or
+  ``fleet_reports.jsonl``. This keeps workspace-local habits/reports from being
+  shadowed by a distant ``org.json`` (e.g. in the user home directory).
   """
   try:
     cur = start_root.resolve()
@@ -35,12 +37,16 @@ def resolve_fleet_root(start_root: Path) -> Path:
     cur = start_root
   try:
     while True:
-      if (cur / ".gemcode" / "org.json").is_file():
+      gem = cur / ".gemcode"
+      if (gem / "org.json").is_file():
+        return cur
+      if (gem / "habits.json").is_file():
+        return cur
+      if (gem / "fleet_reports.jsonl").is_file():
         return cur
       if cur == cur.parent:
         break
-      nxt = cur.parent
-      cur = nxt
+      cur = cur.parent
   except Exception:
     return start_root
   return start_root

{gemcode-0.4.18 → gemcode-0.4.19}/src/gemcode/repl_commands.py

@@ -56,6 +56,22 @@ def format_doctor_lines(cfg: GemCodeConfig) -> list[str]:
   lines.append(
       f"  gemcode_version: {os.environ.get('GEMCODE_VERSION', get_version())}"
   )
+  try:
+    from gemcode.web.serve_state import DEFAULT_SERVE_PORT, is_serve_running, serve_base_url
+
+    running, info = is_serve_running(cfg.project_root, port=DEFAULT_SERVE_PORT)
+    url = (info or {}).get("url") or serve_base_url("127.0.0.1", DEFAULT_SERVE_PORT)
+    if running:
+      lines.append(f"  web_api: running at {url}")
+      health = (info or {}).get("health") if isinstance(info, dict) else None
+      if isinstance(health, dict) and health.get("has_api_key") is False:
+        lines.append("  web_api_key: MISSING (set GOOGLE_API_KEY or gemcode login)")
+    else:
+      lines.append(
+          f"  web_api: not running (try `/serve` or `gemcode serve -C \"{cfg.project_root}\"`)"
+      )
+  except Exception:
+    pass
   return lines
 
 
@@ -234,6 +250,7 @@ SLASH_COMMANDS: list[tuple[str, str]] = [
     # NOTE: /file /image /img are aliases of /attach; keep alias working but do not list them here.
     ("kaira",       "Background jobs — gemcode runtime (alias: gemcode kaira)"),
     ("runtime",     "Fleet socket status · gemcode runtime · attach/connect"),
+    ("serve",       "HTTP API for web/custom UIs — gemcode serve on :3001"),
     ("bus",         "Runtime bus — send/publish lightweight messages over IPC"),
     ("inbox",       "Bus inbox filters for this UI (to/topics)"),
     ("fleet",       "Fleet inbox — /fleet show | digest (habits / mesh reports)"),
@@ -331,6 +348,7 @@ def slash_help_lines() -> list[str]:
       "Slash commands:",
       "  (CLI) gemcode -C DIR  Use a project folder as root (recommended vs. ~ )",
       "  (CLI) gemcode login   Save or change API key (~/.gemcode/credentials.json)",
+      "  (CLI) gemcode serve   HTTP API for web/custom UIs (default http://127.0.0.1:3001)",
       "",
       "  Project setup:",
       "  /attach <path>        Queue file(s) for the **next** message (PDF, images, …); /attach list|clear",
@@ -394,6 +412,7 @@ def slash_help_lines() -> list[str]:
       "  /login                How to run gemcode login (API key outside REPL)",
       "  /live-audio           How to run gemcode live-audio (mic → Gemini Live)",
       "  /doctor               Environment sanity check",
+      "  /serve [start|status|stop|url]  Start HTTP API for web UI (gemcode serve on :3001)",
       "  /version              Print GemCode version hint",
       "  /exit                 Exit the REPL",
       "",

{gemcode-0.4.18 → gemcode-0.4.19}/src/gemcode/repl_slash.py

@@ -2544,6 +2544,95 @@ async def process_repl_slash(
     out()
     return ReplSlashResult(skip_model_turn=True)
 
+  # ── /serve (built-in HTTP API for web UI) ───────────────────────────────
+  if name == "serve":
+    from gemcode.web.serve_state import (
+      DEFAULT_SERVE_PORT,
+      is_serve_running,
+      serve_base_url,
+      start_background_serve,
+      stop_background_serve,
+    )
+
+    args_s = (sc.args or "").strip().lower()
+    first = args_s.split()[0] if args_s else "start"
+    host = "127.0.0.1"
+    port = DEFAULT_SERVE_PORT
+
+    if first in ("help", "?"):
+      out("Web API (any UI can connect):")
+      out("  /serve              Start background server on http://127.0.0.1:3001")
+      out("  /serve status       Show whether the API is running")
+      out("  /serve stop         Stop the background server for this project")
+      out("  /serve url          Print API URL for the web UI")
+      out("")
+      out("Foreground (blocks terminal):")
+      out(f"  gemcode serve -C \"{cfg.project_root}\"")
+      out("")
+      out("Web UI: set API URL to http://127.0.0.1:3001 (default) or npm run dev proxies to it.")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if first in ("stop", "kill"):
+      result = stop_background_serve(cfg.project_root)
+      if result.get("stopped"):
+        out(f"[serve] stopped pid {result.get('pid') or '(unknown)'}")
+      else:
+        out(f"[serve] {result.get('message') or result.get('error') or 'not running'}")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if first in ("status", "ps"):
+      running, info = is_serve_running(cfg.project_root, host=host, port=port)
+      if running and info:
+        out("[serve] running")
+        out(f"  url: {info.get('url') or serve_base_url(host, port)}")
+        out(f"  project: {info.get('project_root') or cfg.project_root}")
+        if info.get("session_id"):
+          out(f"  session_id: {info.get('session_id')}")
+        if info.get("pid"):
+          out(f"  pid: {info.get('pid')}")
+        health = info.get("health") if isinstance(info.get("health"), dict) else None
+        if health:
+          out(f"  has_api_key: {health.get('has_api_key')}")
+      else:
+        out("[serve] not running — try `/serve` or `gemcode serve`")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if first in ("url", "link"):
+      running, info = is_serve_running(cfg.project_root, host=host, port=port)
+      url = (info or {}).get("url") or serve_base_url(host, port)
+      out(f"[serve] API URL: {url}")
+      out(f"[serve] CLI session_id: {session_id}")
+      out("Paste the URL into GemCode web UI → Settings → API URL if not using default.")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    # start (default)
+    result = start_background_serve(
+      cfg.project_root,
+      host=host,
+      port=port,
+      session_id=session_id,
+    )
+    if not result.get("ok"):
+      out(f"[serve] failed: {result.get('error') or 'unknown error'}")
+      if result.get("log"):
+        out(f"  log: {result.get('log')}")
+    elif result.get("already_running"):
+      out(f"[serve] already running at {result.get('url')}")
+    else:
+      out(f"[serve] started at {result.get('url')}")
+      if result.get("warming"):
+        out("[serve] warming up — retry /serve status in a moment")
+      if result.get("log"):
+        out(f"  log: {result.get('log')}")
+    out(f"[serve] session_id: {session_id}")
+    out("Open the web UI (npm run dev) — it proxies to port 3001 by default.")
+    out()
+    return ReplSlashResult(skip_model_turn=True)
+
   # ── /runtime ────────────────────────────────────────────────────────────
   if name == "runtime":
     from gemcode.kaira_ipc import fleet_manager_ipc_path_for_workspace

{gemcode-0.4.18 → gemcode-0.4.19}/src/gemcode/session_store.py

@@ -94,8 +94,7 @@ def list_sessions(project_root: Path, *, max_items: int = 20) -> list[dict[str,
     events     : int    — approximate turn count
     short_id   : str    — first 8 chars of id
   """
-  from gemcode.session_runtime import session_db_path
-  db = session_db_path(project_root)
+  db = project_root / ".gemcode" / "sessions.sqlite"
   rows = _read_sqlite_sessions(db)
   meta = _load_meta(project_root)