gemcode 0.3.76__py3-none-any.whl → 0.3.77__py3-none-any.whl

gemcode/agent.py

@@ -1,5 +1,5 @@
 """
-Root LlmAgent definition (Claude Code: agent config + tool list, analogous to tools.ts + prompts).
+Root LlmAgent definition (agent config + tool list, analogous to a tools registry + prompts).
 
 See `session_runtime.py` for Runner/session wiring (outer layer).
 See `tool_registry.py` for tool categories (read vs mutating vs shell).
@@ -64,7 +64,7 @@ def _chain_before_model_callbacks(*callbacks):
 
 def _load_gemini_md(project_root: Path) -> str:
   """
-  Load GEMINI.md / .gemcode/NOTES.md from a Claude Code–style hierarchy.
+  Load GEMINI.md / .gemcode/NOTES.md from a interactive CLI–style hierarchy.
 
   Priority (later entries override earlier ones, all are concatenated):
     1. ~/.gemcode/GEMINI.md           — user-global instructions (all projects)
@@ -89,7 +89,7 @@ def _load_gemini_md(project_root: Path) -> str:
       return ""
     try:
       raw = p.read_text(encoding="utf-8", errors="replace")[:_FILE_CAP]
-      # Strip HTML comments (like Claude Code does — saves tokens)
+      # Strip HTML comments (saves tokens)
       return _COMMENT_RE.sub("", raw).strip()
     except OSError:
       return ""
@@ -140,7 +140,7 @@ def _get_git_context(root) -> str:
   """
   Run a quick git snapshot at session start — branch, recent commits, diff-stat.
   Returns a formatted string or empty string if not a git repo.
-  Mirrors OpenClaude's getGitStatus() pattern.
+  Mirrors Reference UI getGitStatus() pattern.
   """
   import subprocess
   import shutil
@@ -232,18 +232,18 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
   if max_session_tokens:
     budget_line += f" · max_session_tokens={max_session_tokens:,}"
 
-  # ── Kairos ────────────────────────────────────────────────────────────────
-  # The user can run `gemcode kairos -C <project>` in a separate terminal to
+  # ── Kaira ────────────────────────────────────────────────────────────────
+  # The user can run `gemcode kaira -C <project>` in a separate terminal to
   # launch a long-lived scheduler. Jobs submitted to it run concurrently with
   # the current session. This is useful for background / parallel heavy work.
-  kairos_section = (
-    "- **Kairos background scheduler** — `gemcode kairos -C <project>` launches a "
+  kaira_section = (
+    "- **Kaira background scheduler** — `gemcode kaira -C <project>` launches a "
     "long-lived daemon that reads prompts from stdin and runs each as an isolated job "
-    "(up to N concurrently). Each job gets `kairos_sleep_ms(ms)` and "
-    "`kairos_enqueue_prompt(prompt, priority, session_id)` tools so the model can "
+    "(up to N concurrently). Each job gets `kaira_sleep_ms(ms)` and "
+    "`kaira_enqueue_prompt(prompt, priority, session_id)` tools so the model can "
     "schedule follow-up work itself. Useful for: bulk file processing, repeated "
     "polling loops, parallelising large independent tasks. "
-    "Tell the user to open a second terminal and run `gemcode kairos` if a task "
+    "Tell the user to open a second terminal and run `gemcode kaira` if a task "
     "would benefit from background parallelism."
   )
 
@@ -274,7 +274,7 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
 - **Capability routing** (`capability_mode={getattr(cfg, 'capability_mode', 'auto')}`): in `auto` mode, GemCode automatically enables deep_research when it detects research-intent keywords in your prompt each turn. You can also type `/research on`, `/embeddings on`, `/memory on`, `/computer on` at the prompt.
 - **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.
-{kairos_section}
+{kaira_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}"""
@@ -680,7 +680,7 @@ Concrete patterns:
 - Grepping different patterns → multiple `grep_content` in one response
 - `list_directory` + `glob_files` → both at once
 
-**Parallel sub-agent exploration (OpenClaude pattern):**
+**Parallel sub-agent exploration (reference terminal UI pattern):**
 When a task requires understanding several subsystems before acting:
 1. Spawn parallel `run_subtask` workers, one per subsystem
 2. Wait for all results to return in the same turn
@@ -844,7 +844,7 @@ Use `gh pr create` via `bash`. When asked to create a PR:
 All file tools use paths **relative to the project root** (where GemCode was started). The root may be the home folder — subfolders like `Desktop`, `Desktop/code`, `Documents` are inside the sandbox. Call `list_directory("Desktop")` or `glob_files("**/*name*.ts")` instead of assuming access is blocked. Only treat access as denied when a tool returns an explicit `error`.
 
 ## Agent notes (.gemcode/notes.md)
-You have two tools to persist project insights across sessions, like Claude Code's auto-memory:
+You have two tools to persist project insights across sessions (auto-memory style):
 
 - **`append_project_note(note)`** — write a note to `.gemcode/notes.md`. Use this proactively when you discover something worth remembering:
   - Build/test/lint commands you discover ("Build: `npm run build` — requires Node 20")
@@ -936,7 +936,7 @@ def build_root_agent(
   except Exception:
     pass
 
-  # Agent auto-notes: write project insights to .gemcode/notes.md (Claude Code MEMORY.md equivalent)
+  # Agent auto-notes: write project insights to .gemcode/notes.md (project notes file)
   try:
     from gemcode.tools.notes import build_notes_tools
     notes_tools = build_notes_tools(cfg.project_root)
@@ -964,7 +964,7 @@ def build_root_agent(
   if before_model is not None:
     cb_kwargs["before_model_callback"] = before_model
 
-  # Claude-like thinking: enabled by default (Gemini dynamic), but allow
+  # familiar thinking: enabled by default (Gemini dynamic), but allow
   # explicit overrides for disable/budgets/levels.
   gen_cfg = None
   thinking_cfg = build_thinking_config(cfg)

gemcode/autocompact.py

@@ -1,5 +1,5 @@
 """
-Claude Code–style autocompact for ADK/Gemini.
+interactive CLI–style autocompact for ADK/Gemini.
 
 GemCode already has:
 - bounded tool output (after_tool truncation)
@@ -41,7 +41,7 @@ def _autocompact_enabled(cfg: GemCodeConfig) -> bool:
 
 
 def _autocompact_threshold_chars(cfg: GemCodeConfig) -> int:
-  # Claude Code uses token windows; we use a character proxy budget since
+  # uses token windows; we use a character proxy budget since
   # Gemini tokenizers vary and ADK does not expose a cheap exact counter.
   max_chars = int(getattr(cfg, "max_context_chars", 0) or 0)
   if max_chars <= 0:

gemcode/callbacks.py

@@ -1,7 +1,7 @@
 """
 ADK callbacks: permissions, audit, tool failure circuit breaker, usage logging.
 
-Maps to Claude Code patterns:
+Maps to patterns:
 - before_tool / after_tool ≈ permission gates + telemetry around tool execution
 - after_model ≈ cost / usage hooks (see cost-tracker.ts role)
 - Session state for streak counters ≈ autoCompact failure tracking (MVP: tool errors)
@@ -60,7 +60,7 @@ def _truthy_env(name: str, *, default: bool = False) -> bool:
 
 
 def _maybe_tool_summary_enabled() -> bool:
-  # Mirrors Claude's "emit tool use summaries" gate conceptually.
+  # Mirrors optional "emit tool use summaries" gating.
   return _truthy_env("GEMCODE_EMIT_TOOL_USE_SUMMARIES", default=False)
 
 
@@ -344,7 +344,7 @@ def make_before_tool_callback(cfg: GemCodeConfig):
 
 
 def make_after_tool_callback(cfg: GemCodeConfig):
-  """Track consecutive tool failures in session state (Claude-style circuit breaker)."""
+  """Track consecutive tool failures in session state (conventional circuit breaker)."""
 
   def after_tool(
     tool: BaseTool,
@@ -548,7 +548,7 @@ def make_after_tool_callback(cfg: GemCodeConfig):
               summary[k] = v
       append_audit(cfg.project_root, summary)
       # Also print a concise, user-visible summary in CLI contexts.
-      # (Claude Code renders tool cards; this is the lightweight equivalent.)
+      # (renders tool cards; this is the lightweight equivalent.)
       try:
         # Full-screen TUIs get corrupted by stray stderr prints.
         if _truthy_env("GEMCODE_TUI_ACTIVE", default=False):
@@ -621,7 +621,7 @@ def make_after_model_callback(cfg: GemCodeConfig):
 
     # ── Expose live token stats to the TUI ───────────────────────────────────
     # The TUI reads cfg._last_turn_stats after each turn to display token counts
-    # and estimated cost in the footer (like OpenClaude's spinner token display).
+    # and estimated cost in the footer (like Reference UI spinner token display).
     try:
       in_tok  = d.get("prompt_token_count", 0) or 0
       out_tok = d.get("candidates_token_count", 0) or 0
@@ -762,7 +762,7 @@ def make_after_model_callback(cfg: GemCodeConfig):
 
 
 def make_on_tool_error_callback(cfg: GemCodeConfig):
-  """Turn tool exceptions into structured tool results (Claude-like is_error)."""
+  """Turn tool exceptions into structured tool results (familiar is_error)."""
 
   async def on_tool_error(
     *, tool: BaseTool, args: dict[str, Any], tool_context, error: Exception

gemcode/capability_routing.py

@@ -1,8 +1,8 @@
 """
-Capability-based routing (Claude Code style conceptually).
+Capability-based routing (style conceptually).
 
 This layer decides which *capabilities* to enable (deep research tools,
-embeddings retrieval, computer-use tools) and leaves the existing Claude-like
+embeddings retrieval, computer-use tools) and leaves the existing familiar
 outer/inner loops intact.
 
 It is intentionally conservative:

gemcode/cli.py

@@ -37,7 +37,7 @@ def _events_to_text(events) -> str:
 
 def _maybe_prompt_trust(cfg: GemCodeConfig) -> None:
   """
-  Claude Code–style workspace trust prompt.
+  interactive CLI–style workspace trust prompt.
 
   On first use in a project root, ask the user to trust the folder so file,
   shell, and git tools can run. If not trusted, we exit before any tool runs.
@@ -70,7 +70,7 @@ def _maybe_prompt_trust(cfg: GemCodeConfig) -> None:
 
 def _maybe_prompt_google_api_key() -> None:
   """
-  One-time interactive prompt for ``GOOGLE_API_KEY`` (like ``claude login`` / first-run).
+  One-time interactive prompt for ``GOOGLE_API_KEY`` (like ``gemcode login`` / first-run).
 
   Skipped when the key is already set, stdin is not a TTY, or
   ``GEMCODE_NO_LOGIN_PROMPT=1``.
@@ -125,7 +125,7 @@ def _initialize_gemcode_project(cfg: GemCodeConfig) -> None:
   Create ``<project>/.gemcode/`` and print a short banner the first time it appears.
 
   Runs after workspace trust + API key are satisfied so a bare ``gemcode`` REPL
-  feels like a guided first-run (Claude Code–style).
+  feels like a guided first-run (interactive CLI–style).
   """
   root = cfg.project_root.resolve()
   gem_dir = root / ".gemcode"
@@ -174,7 +174,7 @@ async def _run_prompt(
 
 async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> None:
   """
-  Interactive REPL mode (Claude Code-like): keep the session open for multiple turns.
+  Interactive REPL mode (multi-turn REPL): keep the session open for multiple turns.
   """
   load_cli_environment()
   _maybe_prompt_trust(cfg)
@@ -356,7 +356,7 @@ def main() -> None:
       return
     raise SystemExit("Usage: gemcode ide --stdio")
 
-  # Persist or rotate API key (Claude Code–style `claude login`).
+  # Persist or rotate API key (interactive CLI–style `gemcode login`).
   if len(sys.argv) > 1 and sys.argv[1] == "login":
     load_cli_environment()
     if not (hasattr(sys.stdin, "isatty") and sys.stdin.isatty()):
@@ -598,78 +598,78 @@ def main() -> None:
     print(f"\n[gemcode live-audio] session_id={session_id}", file=sys.stderr)
     return
 
-  # Kairos proactive scheduler daemon.
-  if len(sys.argv) > 1 and sys.argv[1] == "kairos":
-    kairos_parser = argparse.ArgumentParser(
-      prog="gemcode kairos",
-      description="Kairos-like proactive scheduler daemon (stdin -> queued jobs).",
+  # Kaira proactive scheduler daemon.
+  if len(sys.argv) > 1 and sys.argv[1] == "kaira":
+    kaira_parser = argparse.ArgumentParser(
+      prog="gemcode kaira",
+      description="Background proactive scheduler daemon (stdin -> queued jobs).",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "-C",
       "--directory",
       type=Path,
       default=Path.cwd(),
       help="Project root",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--session",
       default=None,
       help="Session id for SQLite-backed history (optional; defaults to a new uuid).",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--concurrency",
       type=int,
       default=2,
       help="Max number of concurrent queued jobs.",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--default-priority",
       type=int,
       default=0,
       help="Priority used for stdin-enqueued jobs.",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--yes",
       action="store_true",
       help="Allow write_file / search_replace (disables interactive HITL prompts).",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--interactive-ask",
       action="store_true",
       help="Prompt in-run for mutating tool confirmations (HITL).",
     )
-    kairos_parser.add_argument("--model", default=None, help="Override GEMCODE_MODEL")
-    kairos_parser.add_argument(
+    kaira_parser.add_argument("--model", default=None, help="Override GEMCODE_MODEL")
+    kaira_parser.add_argument(
       "--model-mode",
       default=None,
       help="Model mode: auto|fast|balanced|quality (overrides GEMCODE_MODEL_MODE).",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--deep-research",
       action="store_true",
       help="Enable deep research tools + routing.",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--maps-grounding",
       action="store_true",
       help="Opt-in to Google Maps grounding tool inside deep-research.",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--embeddings",
       action="store_true",
       help="Enable embeddings-based semantic retrieval.",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--capability-mode",
       default=None,
       help="Capability routing: auto|research|embeddings|computer|audio|all (enables tools and routes models).",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--tool-combination-mode",
       default=None,
       help="Gemini 3 tool context circulation: deep_research|always|never|auto",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--max-llm-calls",
       type=int,
       default=None,
@@ -677,7 +677,7 @@ def main() -> None:
       help="Cap model↔tool iterations for each job message (ADK RunConfig.max_llm_calls).",
     )
 
-    args = kairos_parser.parse_args(sys.argv[2:])
+    args = kaira_parser.parse_args(sys.argv[2:])
     load_cli_environment()
 
     cfg = GemCodeConfig(project_root=args.directory)
@@ -713,15 +713,15 @@ def main() -> None:
     require_google_api_key()
 
     session_id = args.session or str(uuid.uuid4())
-    from gemcode.kairos_daemon import KairosDaemon
+    from gemcode.kaira_daemon import KairaDaemon
 
-    daemon = KairosDaemon(
+    daemon = KairaDaemon(
       cfg=cfg,
       concurrency=args.concurrency,
       default_priority=args.default_priority,
     )
     asyncio.run(daemon.run_forever(session_id=session_id))
-    print(f"\n[gemcode kairos] session_id={session_id}", file=sys.stderr)
+    print(f"\n[gemcode kaira] session_id={session_id}", file=sys.stderr)
     return
 
   parser = argparse.ArgumentParser(prog="gemcode", description="Gemini + ADK coding agent")

gemcode/config.py

@@ -49,7 +49,7 @@ def _truthy_env(name: str, *, default: bool = False) -> bool:
 
 
 def token_budget_invocation_reset() -> dict:
-  """Reset per-user-message token budget tracker (matches new `query()` in Claude)."""
+  """Reset per-user-message token budget tracker when starting a new user turn."""
   import time
 
   t = int(time.time() * 1000)
@@ -285,9 +285,9 @@ class GemCodeConfig:
   # role-based routing from overriding their selection.
   model_overridden: bool = False
 
-  # Gemini thinking controls (Claude-like intent, Gemini-specific knobs).
+  # Gemini thinking controls (familiar intent, Gemini-specific knobs).
   #
-  # Claude Code enables thinking by default and only forces disable/budgets
+  # enables thinking by default and only forces disable/budgets
   # when explicitly configured. We match that by returning "None" unless the
   # user asks for explicit overrides below.
   #
@@ -333,7 +333,7 @@ class GemCodeConfig:
 
   # Plan mode: when ON, the agent explicitly writes out a numbered plan
   # BEFORE executing any tools, then checks the plan before reporting done.
-  # Like OpenClaude's EnterPlanMode — great for complex, multi-file tasks.
+  # Like Reference UI EnterPlanMode — great for complex, multi-file tasks.
   # Toggle at runtime with /plan on|off.
   plan_mode: bool = field(
     default_factory=lambda: _truthy_env("GEMCODE_PLAN_MODE", default=False)

gemcode/context_budget.py

@@ -1,5 +1,5 @@
 """
-Bounded tool output and soft prompt-size limits (Claude Code–style context hygiene).
+Bounded tool output and soft prompt-size limits (interactive CLI–style context hygiene).
 
 - Truncate oversized tool result dicts before they enter history (`after_tool`).
 - Before each LLM call, trim oldest text parts until estimated char total is under
@@ -169,7 +169,7 @@ def shrink_contents_text_inplace(contents: Any, max_total_chars: int) -> bool:
         # Choose a max string size that should reduce at least some of the excess.
         if excess >= max_len:
           # Extreme overage: clearing oldest tool payload is closer to
-          # Claude Code's microcompact behavior and guarantees progress.
+          # microcompact behavior and guarantees progress.
           cleared = {"[Old tool result content cleared]": True}
           if getattr(part, "tool_response", None) is not None:
             part.tool_response.response = cleared

gemcode/context_warning.py

@@ -1,8 +1,8 @@
 """
-Claude Code–style context pressure signals (cf. `autoCompact.ts` / `calculateTokenWarningState`).
+Context pressure signals for autocompact and warnings (token-based thresholds).
 
 Uses API `prompt_token_count` when available; thresholds are token-based with
-env overrides. Mirrors Claude’s buffer constants where practical.
+env overrides. Mirrors common buffer constants where practical.
 """
 
 from __future__ import annotations
@@ -11,7 +11,7 @@ import os
 
 from gemcode.config import GemCodeConfig
 
-# Claude `autoCompact.ts` defaults
+# Reference auto-compact defaults
 AUTOCOMPACT_BUFFER_TOKENS = 13_000
 WARNING_THRESHOLD_BUFFER_TOKENS = 20_000
 ERROR_THRESHOLD_BUFFER_TOKENS = 20_000
@@ -40,12 +40,12 @@ def get_effective_context_window_tokens(model: str) -> int:
 
 
 def get_reserved_summary_tokens(model: str) -> int:
-  """Claude reserves headroom for compaction summary output; we use a small cap."""
+  """Reserve headroom for compaction summary output; we use a small cap."""
   return min(_opt_int("GEMCODE_AUTOCOMPACT_RESERVED_OUTPUT_TOKENS", 20_000), 20_000)
 
 
 def get_effective_context_window_size_tokens(model: str) -> int:
-  """`effectiveContextWindow` ≈ window minus reserved output (Claude `getEffectiveContextWindowSize`)."""
+  """`effectiveContextWindow` ≈ window minus reserved output for summaries."""
   w = get_effective_context_window_tokens(model)
   return max(10_000, w - get_reserved_summary_tokens(model))
 
@@ -70,7 +70,7 @@ def calculate_context_warning_state(
     cfg: GemCodeConfig | None = None,
 ) -> dict[str, object]:
   """
-  Returns keys aligned with Claude’s `calculateTokenWarningState`:
+  Returns keys aligned with typical token-warning state helpers:
   - percent_left
   - is_above_warning_threshold
   - is_above_error_threshold

gemcode/credentials.py

@@ -1,4 +1,4 @@
-"""Persisted Google API credentials (Claude Code–style: save once, override via env)."""
+"""Persisted Google API credentials (interactive CLI–style: save once, override via env)."""
 
 from __future__ import annotations
 

gemcode/hooks.py

@@ -1,5 +1,5 @@
 """
-GemCode shell hooks — scriptable lifecycle events inspired by OpenClaude.
+GemCode shell hooks — scriptable lifecycle events inspired by reference terminal UI.
 
 Hooks are shell scripts stored under ``<project_root>/.gemcode/hooks/``.
 They receive a JSON payload on stdin and can:

gemcode/invoke.py

@@ -1,5 +1,5 @@
 """
-Single user turn (Claude Code: inner path ≈ `query()` invocation per message).
+Single user turn (inner path ≈ `query()` invocation per message).
 
 CLI and tests call `run_turn` with a Runner already bound to app + session service.
 """

gemcode/{kairos_daemon.py → kaira_daemon.py}

@@ -30,15 +30,15 @@ def _events_to_text(events) -> str:
 
 
 @dataclass(frozen=True)
-class KairosJob:
+class KairaJob:
   job_id: str
   prompt: str
   priority: int
   session_id: str
 
 
-class KairosDaemon:
-  """Kairos-like proactive scheduler (stdin -> priority queue -> job runners)."""
+class KairaDaemon:
+  """Background proactive scheduler (stdin -> priority queue -> job runners)."""
 
   def __init__(
     self,
@@ -47,16 +47,16 @@ class KairosDaemon:
     concurrency: int = 2,
     default_priority: int = 0,
     user_id: str = "local",
-    job_runner: Callable[[KairosJob], Awaitable[None]] | None = None,
+    job_runner: Callable[[KairaJob], Awaitable[None]] | None = None,
   ) -> None:
     self.cfg = cfg
     self.concurrency = max(1, int(concurrency))
     self.default_priority = int(default_priority)
     self.user_id = user_id
 
-    # Queue items are (sort_key, seq, KairosJob).
+    # Queue items are (sort_key, seq, KairaJob).
     self._queue: asyncio.PriorityQueue[
-      tuple[int, int, KairosJob]
+      tuple[int, int, KairaJob]
     ] = asyncio.PriorityQueue()
     self._seq = 0
     self._sem = asyncio.Semaphore(self.concurrency)
@@ -75,7 +75,7 @@ class KairosDaemon:
     job_id = f"job_{uuid.uuid4().hex[:10]}"
     pr = self.default_priority if priority is None else int(priority)
     self._seq += 1
-    job = KairosJob(
+    job = KairaJob(
       job_id=job_id,
       prompt=prompt,
       priority=pr,
@@ -85,7 +85,7 @@ class KairosDaemon:
     self._queue.put_nowait((-pr, self._seq, job))
     return job_id
 
-  async def _default_job_runner(self, job: KairosJob) -> None:
+  async def _default_job_runner(self, job: KairaJob) -> None:
     runner: Runner | None = None
     try:
       # Route model/capabilities based on this job's prompt, without mutating
@@ -94,7 +94,7 @@ class KairosDaemon:
       apply_capability_routing(job_cfg, job.prompt, context="prompt")
       job_cfg.model = pick_effective_model(job_cfg, job.prompt)
 
-      # For the initial MVP, we inject Kairos tools via `_build_extra_tools_for_job()`;
+      # For the initial MVP, we inject Kaira tools via `_build_extra_tools_for_job()`;
       # this keeps scheduling logic independent from tool declarations.
       extra_tools = self._build_extra_tools_for_job(job)
       runner = create_runner(job_cfg, extra_tools=extra_tools or None)
@@ -108,28 +108,28 @@ class KairosDaemon:
       )
       text = _events_to_text(events).strip()
       if text:
-        print(f"\n[kairos {job.job_id}] {text}\n", flush=True)
+        print(f"\n[kaira {job.job_id}] {text}\n", flush=True)
       else:
-        print(f"\n[kairos {job.job_id}] (no text output)\n", flush=True)
+        print(f"\n[kaira {job.job_id}] (no text output)\n", flush=True)
     finally:
       if runner is not None:
         await runner.close()
 
-  def _build_extra_tools_for_job(self, job: KairosJob) -> list | None:
+  def _build_extra_tools_for_job(self, job: KairaJob) -> list | None:
     """Inject per-job tools for the model to call."""
 
-    async def kairos_sleep_ms(duration_ms: int) -> dict:
+    async def kaira_sleep_ms(duration_ms: int) -> dict:
       """Pause this job for `duration_ms` (does not block other jobs)."""
       duration_ms = max(0, int(duration_ms))
       await asyncio.sleep(duration_ms / 1000.0)
       return {"slept_ms": duration_ms}
 
-    def kairos_enqueue_prompt(
+    def kaira_enqueue_prompt(
       prompt: str,
       priority: int = 0,
       session_id: str | None = None,
     ) -> dict:
-      """Enqueue a new Kairos job from the model.
+      """Enqueue a new Kaira job from the model.
 
       If `session_id` is not provided, it defaults to the current job's
       session_id.
@@ -142,13 +142,13 @@ class KairosDaemon:
       )
       return {"enqueued_job_id": enqueued_id}
 
-    return [kairos_sleep_ms, kairos_enqueue_prompt]
+    return [kaira_sleep_ms, kaira_enqueue_prompt]
 
-  async def _run_job_with_semaphore(self, job: KairosJob) -> None:
+  async def _run_job_with_semaphore(self, job: KairaJob) -> None:
     async with self._sem:
       await self._job_runner(job)
 
-  async def _run_job_and_release(self, job: KairosJob) -> None:
+  async def _run_job_and_release(self, job: KairaJob) -> None:
     try:
       await self._job_runner(job)
     finally:
@@ -166,7 +166,7 @@ class KairosDaemon:
   async def _stdin_loop(self, *, session_id: str) -> None:
     """Read stdin lines and enqueue each as a new job."""
     # Use a background thread so the asyncio loop stays responsive.
-    prompt_prefix = "kairos> "
+    prompt_prefix = "kaira> "
     while not self._stop_event.is_set():
       try:
         # Print prompt only in interactive terminals.

gemcode/limits.py

@@ -1,5 +1,5 @@
 """
-Pre-model limits (cf. Claude `calculateTokenWarningState` / blocking limit checks).
+Pre-model limits (token warning state / blocking limit checks).
 
 Uses session state updated in `callbacks.make_after_model_callback`.
 """

gemcode/mcp_loader.py

@@ -1,7 +1,7 @@
 """
 Optional MCP toolsets from `.gemcode/mcp.json`.
 
-Now supports all three ADK connection types — like Claude Code's MCP integration:
+Now supports all three ADK connection types — like MCP integration:
 
 Schema (example):
 {

gemcode/modality_tools.py

@@ -1,7 +1,7 @@
 """
 Modality tool injection for GemCode.
 
-Claude Code–style: outer loop + inner tool orchestration remains ADK-driven,
+interactive CLI–style: outer loop + inner tool orchestration remains ADK-driven,
 but we choose which tools to expose based on user flags / prompt heuristics.
 """
 

gemcode/model_routing.py

@@ -1,7 +1,7 @@
 """
 Model routing for GemCode.
 
-Goal: match Claude-style "multi modes" where users can select a model mode
+Goal: match conventional "multi modes" where users can select a model mode
 explicitly, or GemCode can choose a best-fit model automatically (no extra
 model call; heuristic only).
 """

gemcode/permissions.py

@@ -1,5 +1,5 @@
 """
-Permission rules engine — inspired by Claude Code's allow/deny pattern system.
+Permission rules engine — inspired by allow/deny pattern system.
 
 Users define rules in `.gemcode/settings.json` (project) or `~/.gemcode/settings.json` (global).
 Rules are evaluated for every tool call: deny first, then allow, then default.
@@ -25,7 +25,7 @@ Schema:
   }
 }
 
-Pattern syntax (same as Claude Code's permission rules):
+Pattern syntax (same as permission rules):
   - "bash"                   — matches ALL bash calls
   - "bash(*)"                — same as above
   - "bash(git *)"            — bash calls whose command starts with "git "

gemcode/plugins/terminal_hooks_plugin.py

@@ -1,5 +1,5 @@
 """
-ADK plugin: complements Claude-like stopHooks with GemCode terminal reasons,
+ADK plugin: complements familiar stopHooks with GemCode terminal reasons,
 optional memory ingestion, and post-turn hook execution.
 """