delos-cli 2.0.0__tar.gz → 2.0.2__tar.gz

{delos_cli-2.0.0 → delos_cli-2.0.2}/.gitignore

@@ -1,6 +1,5 @@
 knip.txt
 pentest-*
-lefthook.yml
 backend/.vscode
 backend/cosmos_env
 # Allow backend/.env (has safe localhost defaults), but ignore all other .env files
@@ -22,16 +21,26 @@ infrastructure/supabase/**/.env
 backend/.python-version
 /scripts/
 */scripts/
+!tooling/scripts/
 # Re-include the tools-catalog export script (CI drift test imports it)
 !backend/scripts/
 backend/scripts/*
 !backend/scripts/__init__.py
 !backend/scripts/export_tools_catalog.py
 !backend/scripts/check_supabase_models.py
+!backend/scripts/dump_openapi.py
+!backend/scripts/backfill_agent_issues.py
+!backend/scripts/backfill_directive_recurrence.py
+!backend/scripts/analyze_prompt_dumps.py
+!backend/scripts/check_route_response_types.py
+!backend/scripts/fly_source_recovery.py
+!backend/scripts/audit_sprite_regions.py
+!backend/scripts/migrate_vibe_sprites.py
 
 .claude/worktrees
 
 data/documents2
+data/logs
 **/**0
 _local
 .env.old
@@ -68,10 +77,24 @@ next-env.d.ts
 # production
 build
 
+# Vite/tsc build output. Global rather than per-app: the office add-ins each
+# went untracked-but-not-ignored until someone built them locally.
+dist/
+
 # misc
 .DS_Store
 *.pem
 
+# pnpm is the only package manager here, including the standalone services.
+# One recorded exception: cvn/whatsapp-bridge is an npm-managed runtime sidecar
+# (baileys needs the git-only `libsignal`, which blockExoticSubdeps rejects and
+# pnpm has no scoped exception for — pnpm/pnpm#11799); its lockfile is tracked
+# so the git ref stays pinned.
+package-lock.json
+!cvn/whatsapp-bridge/package-lock.json
+yarn.lock
+npm-shrinkwrap.json
+
 # debug
 npm-debug.log*
 yarn-debug.log*
@@ -108,6 +131,10 @@ yarn-error.log*
 # process-compose logs
 logs/
 
+# python tool caches
+.ruff_cache/
+.pytest_cache/
+
 /pentest/
 
 # terraform
@@ -166,6 +193,10 @@ __pycache__/
 .sprite
 /apps/web/supabase/snippets
 
-# delos-cli per-developer settings (engine/model/approvals). The shared
-# .delos/settings.json IS committed; this one is personal by design.
-.delos/settings.local.json
+# Supabase CLI local link state (project ref, pooler URL, remote versions).
+# Rewritten by every `supabase link`, and belongs to a machine, not to the repo.
+**/supabase/.temp/
+apps/workers-mobile/eas-asc-key.p8
+
+# backfill_fts.py keyset cursor (local run state)
+projects/0904_drivesearch/.fts-cursor.json

{delos_cli-2.0.0 → delos_cli-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: delos-cli
-Version: 2.0.0
+Version: 2.0.2
 Summary: Terminal REPL for the Delos agent — the Claude-Code-style CLI for Delos.
 Project-URL: Homepage, https://delos.so
 Project-URL: Repository, https://github.com/Delos-Intelligence/cosmos-saas
@@ -16,10 +16,10 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Terminals
 Classifier: Topic :: Utilities
-Requires-Python: ==3.12.*
+Requires-Python: ==3.14.*
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: prompt-toolkit>=3.0.47
 Requires-Dist: questionary>=2.0.1
@@ -70,13 +70,13 @@ Conversations are scoped to the directory you launch from — running
 
 ### In the REPL
 
-| Action | Key |
-|---|---|
-| Send a message | `Enter` |
-| New line | `Alt+Enter` |
-| Stop the agent mid-answer | `Esc` (or `/stop`) |
-| Quit | `Ctrl+D` (or `/quit`) |
-| Scroll | mouse wheel · `PageUp` / `PageDown` · `End` to follow again |
+| Action                    | Key                                                         |
+| ------------------------- | ----------------------------------------------------------- |
+| Send a message            | `Enter`                                                     |
+| New line                  | `Alt+Enter`                                                 |
+| Stop the agent mid-answer | `Esc` (or `/stop`)                                          |
+| Quit                      | `Ctrl+D` (or `/quit`)                                       |
+| Scroll                    | mouse wheel · `PageUp` / `PageDown` · `End` to follow again |
 
 ### Slash commands
 
@@ -87,6 +87,8 @@ Conversations are scoped to the directory you launch from — running
 /delete               delete the current chat and go back to the picker
 /resume               back to the picker without deleting
 /stop                 interrupt the agent
+/usage                show plan usage limits and remaining credits
+/context              show what fills the agent's context window
 /quit                 exit
 ```
 
@@ -104,7 +106,7 @@ See `apps/vscode/DEVELOPING.md` in the monorepo for the protocol reference.
 
 ## Requirements
 
-- Python 3.12
+- Python 3.14
 - A [Delos](https://delos.so) account
 
 ## Uninstall

{delos_cli-2.0.0 → delos_cli-2.0.2}/README.md

@@ -39,13 +39,13 @@ Conversations are scoped to the directory you launch from — running
 
 ### In the REPL
 
-| Action | Key |
-|---|---|
-| Send a message | `Enter` |
-| New line | `Alt+Enter` |
-| Stop the agent mid-answer | `Esc` (or `/stop`) |
-| Quit | `Ctrl+D` (or `/quit`) |
-| Scroll | mouse wheel · `PageUp` / `PageDown` · `End` to follow again |
+| Action                    | Key                                                         |
+| ------------------------- | ----------------------------------------------------------- |
+| Send a message            | `Enter`                                                     |
+| New line                  | `Alt+Enter`                                                 |
+| Stop the agent mid-answer | `Esc` (or `/stop`)                                          |
+| Quit                      | `Ctrl+D` (or `/quit`)                                       |
+| Scroll                    | mouse wheel · `PageUp` / `PageDown` · `End` to follow again |
 
 ### Slash commands
 
@@ -56,6 +56,8 @@ Conversations are scoped to the directory you launch from — running
 /delete               delete the current chat and go back to the picker
 /resume               back to the picker without deleting
 /stop                 interrupt the agent
+/usage                show plan usage limits and remaining credits
+/context              show what fills the agent's context window
 /quit                 exit
 ```
 
@@ -73,7 +75,7 @@ See `apps/vscode/DEVELOPING.md` in the monorepo for the protocol reference.
 
 ## Requirements
 
-- Python 3.12
+- Python 3.14
 - A [Delos](https://delos.so) account
 
 ## Uninstall

{delos_cli-2.0.0 → delos_cli-2.0.2}/delos_cli/agent/__init__.py

@@ -20,6 +20,8 @@ from .tools import (
     ToolRenderer,
     default_handler,
     default_renderer,
+    friendly_tool_name,
+    tool_line,
 )
 from .transport import AgentTransport
 from .turn import AgentTurn
@@ -33,4 +35,6 @@ __all__ = [
     "ToolRenderer",
     "default_handler",
     "default_renderer",
+    "friendly_tool_name",
+    "tool_line",
 ]

{delos_cli-2.0.0 → delos_cli-2.0.2}/delos_cli/agent/session.py

@@ -15,8 +15,6 @@ import asyncio
 from itertools import starmap
 from typing import TYPE_CHECKING, Any
 
-from delos_cli.state import tool_allowed_in
-
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator
 
@@ -102,22 +100,9 @@ class AgentSession:
             # into a unique-constraint 500.  Execution is the slow part;
             # the posts are cheap.
             async def _execute(
-                tcid: str, meta: dict[str, Any],
+                tcid: str,
+                meta: dict[str, Any],
             ) -> tuple[str, dict[str, Any], str]:
-                # Plan mode is enforced here, not only in ``ctx.confirm``. On
-                # this engine the backend builds the tool list and pins
-                # ``mode="build"`` (BACKEND_COORDINATION.md item 6), so the
-                # mutating tools are still advertised and the model still calls
-                # them — but nothing may actually run. Refusing at the dispatch
-                # point is what makes plan mode hold for callers whose confirm
-                # auto-accepts (``delos serve``, the benchmark harness).
-                mode = getattr(ctx.state, "permission_mode", "default")
-                if not tool_allowed_in(mode, meta["name"]):
-                    return tcid, meta, (
-                        f"Error: '{meta['name']}' is not available in plan mode — it would modify "
-                        "the user's files. Present your plan instead; nothing is changed until the "
-                        "user approves it."
-                    )
                 handler = self._registry.handler_for(meta["name"])
                 result = await handler(meta["input"], ctx)
                 return tcid, meta, result
@@ -131,7 +116,10 @@ class AgentSession:
                     raise outcome
                 tcid, meta, result = outcome
                 await self._transport.submit_tool_result(
-                    self._chat_id, tcid, meta["name"], result,
+                    self._chat_id,
+                    tcid,
+                    meta["name"],
+                    result,
                 )
                 if emit_tool_output:
                     yield {

{delos_cli-2.0.0 → delos_cli-2.0.2}/delos_cli/agent/tools.py

@@ -16,7 +16,9 @@ Defaults:
 
 - :func:`default_renderer` — a one-line ``→ tool_name`` indicator on
   ``tool-input-available``; nothing on output / delta events.  Custom
-  renderers can opt into args, output, or streaming deltas.
+  renderers keep the same ``→`` prefix and the category colours
+  (cyan = read-only, magenta = write/agent, green = shell, yellow = user
+  prompt); they can opt into args, output, or streaming deltas.
 - :func:`default_handler` — prints the input dict, asks for a free-form
   text answer via a one-shot prompt_toolkit prompt.
 """
@@ -63,14 +65,59 @@ class ToolHandler(Protocol):
     """
 
     async def __call__(
-        self, tool_input: dict[str, Any], ctx: Ctx,
+        self,
+        tool_input: dict[str, Any],
+        ctx: Ctx,
     ) -> str:
         """Collect input from the user and return the result string."""
         ...
 
 
+def friendly_tool_name(name: str) -> str:
+    """Humanize a raw tool name the way the VSCode webview does.
+
+    Same rule as the webview's ``friendlyToolName`` fallback
+    (``tool_name.replace(/_/g, ' ')``), capitalised: ``todo_write`` →
+    ``Todo write``.  Tools with a dedicated renderer have their own
+    friendly labels (``Read file``, ``Run shell command``, …) matching the
+    webview's ``TOOL_FRIENDLY_NAMES``.
+    """
+    return name.replace("_", " ").capitalize()
+
+
+def tool_line(
+    marker: str,
+    label: str,
+    value: str = "",
+    *,
+    color: str,
+    suffix: str = "",
+) -> Text:
+    """Build a one-line tool indicator with a clear visual hierarchy.
+
+    Layout: ``<marker> <label> <value>  <suffix>`` where
+
+    - ``marker`` (``→`` running / ``✓`` done) is bold + ``color`` — the
+      category colour is carried only by this two-char glyph.
+    - ``label`` (``Read file``, ``Run shell command``…) is **dim** so it
+      reads as a quiet caption and no longer competes with the payload.
+    - ``value`` (path, command, pattern…) is bold + ``color`` — this is
+      the information the user actually scans for.
+    - ``suffix`` (line ranges, elapsed time, question counts…) stays dim.
+    """
+    line = Text()
+    line.append(f"{marker} ", style=f"bold {color}")
+    line.append(label, style="dim")
+    if value:
+        line.append(" ", style="dim")
+        line.append(value, style=f"bold {color}")
+    if suffix:
+        line.append(f"  {suffix}", style="dim")
+    return line
+
+
 def default_renderer(event: dict[str, Any]) -> RenderableType | None:
-    """Show a single ``→ tool_name`` line on ``tool-input-available``; ignore the rest.
+    """Show a single ``→ Tool name`` line on ``tool-input-available``; ignore the rest.
 
     Args are intentionally hidden — most tool calls are noisy enough as JSON
     that they hurt readability for the default case.  Custom renderers can
@@ -79,11 +126,8 @@ def default_renderer(event: dict[str, Any]) -> RenderableType | None:
     """
     if event.get("type") != "tool-input-available":
         return None
-    name = event.get("toolName", "?")
-    line = Text()
-    line.append("→ ", style="bold cyan")
-    line.append(name, style="cyan")
-    return line
+    name = friendly_tool_name(event.get("toolName", "?"))
+    return tool_line("→", name, color="cyan")
 
 
 async def default_handler(tool_input: dict[str, Any], ctx: Ctx) -> str:
@@ -95,7 +139,7 @@ async def default_handler(tool_input: dict[str, Any], ctx: Ctx) -> str:
     """
     try:
         pretty = json.dumps(tool_input, indent=2, ensure_ascii=False)
-    except (TypeError, ValueError):
+    except TypeError, ValueError:
         pretty = str(tool_input)
     ctx.console.print(
         Panel(

{delos_cli-2.0.0 → delos_cli-2.0.2}/delos_cli/agent/transport.py

@@ -39,7 +39,8 @@ class AgentTransport:
         return f"{base}/{chat_id}" if chat_id is not None else base
 
     async def stream_completions(
-        self, body: dict[str, Any],
+        self,
+        body: dict[str, Any],
     ) -> AsyncIterator[dict[str, Any]]:
         """``POST /{app}/agent/completions/{org}`` → parsed SSE events."""
         async for event in self._http.sse_post(self._path("completions"), body):
@@ -90,7 +91,10 @@ class AgentTransport:
         return list(queue)
 
     async def edit_queued(
-        self, chat_id: str, message_id: str, content: str,
+        self,
+        chat_id: str,
+        message_id: str,
+        content: str,
     ) -> None:
         """``PUT /queue/{org}/{chat_id}/{msg_id}``."""
         path = f"{self._path('queue', chat_id)}/{message_id}"

{delos_cli-2.0.0 → delos_cli-2.0.2}/delos_cli/agent/turn.py

@@ -1,7 +1,7 @@
 """AgentTurn — a container for one agentic REPL turn that can be interrupted.
 
 Modeled on the voice pipeline's ``SpeechHandle``
-(``backend/cosmos/api/functions/voice/speech_handle.py``): a job/turn
+(``backend/cosmos/api/functions/realtime/speech_handle.py``): a job/turn
 container that owns its running task and races it against an interruption
 future, rather than a standalone interrupt flag that the work has to poll.
 

{delos_cli-2.0.0 → delos_cli-2.0.2}/delos_cli/apps/base.py

@@ -29,7 +29,10 @@ class Renderer(Protocol):
     live updates on the buffer.
     """
 
-    assistant_text: str
+    @property
+    def assistant_text(self) -> str:
+        """The assistant text accumulated since the last block commit."""
+        ...
 
     def apply(self, event: dict[str, Any]) -> None:
         """Handle one streamed event."""

{delos_cli-2.0.0 → delos_cli-2.0.2}/delos_cli/apps/chat/app.py

@@ -1,17 +1,9 @@
 """ChatApp — the delos-cli agent.
 
-Two engines behind one :class:`~delos_cli.apps.base.App`:
-
-* ``backend`` (default today) — wraps an :class:`AgentSession` against the
-  ``/cli/agent/*`` routes + ``app_cli`` / ``app_cli_messages`` Supabase
-  tables. The chat row is INSERT'd at picker time (cf.
-  :func:`main._run_repl`), so the agent always has a row to append to.
-* ``local`` — drives :class:`~delos_cli.engine.LocalEngine` in this process,
-  reaching the model through ``/openai-proxy/{org}/chat/completions`` and
-  persisting to a JSONL transcript instead of Supabase.
-
-Both produce the same v6 event stream, so :meth:`send` is the only place the
-choice shows up and the REPL is engine-agnostic.
+Wraps an :class:`AgentSession` against the ``/cli/agent/*`` backend
+endpoints + ``app_cli`` / ``app_cli_messages`` Supabase tables.  The
+chat row is INSERT'd at picker time (cf. :func:`main._run_repl`), so by
+the time we get here the agent always has a row to append messages to.
 
 Owns the per-app :class:`ToolRegistry` (so users can plug in custom
 renderers / handlers per tool).  The :class:`V6Renderer` returned from
@@ -23,14 +15,13 @@ from __future__ import annotations
 import contextlib
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, override
 
 from rich.text import Text
 
 from delos_cli.agent import AgentSession, AgentTransport, ToolRegistry
 from delos_cli.apps.base import App
 from delos_cli.apps.replay import replay_messages
-from delos_cli.engine import LocalEngine, Transcript
 from delos_cli.git_context import collect_git_context
 from delos_cli.state import TodoStore
 from delos_cli.tools import (
@@ -128,40 +119,9 @@ class ChatApp(App):
     #: Set by ``main._run_repl`` after the picker resolves a chat_id, so
     #: history is rendered the moment the REPL takes over the screen.
     pending_replay: list[dict[str, Any]] = field(default_factory=list)
-    #: ``"backend"`` (loop on the server, tools here) or ``"local"`` (loop
-    #: here, LLM through the OpenAI-compatible proxy). Set by ``--engine``.
-    engine: str = "backend"
     _current_session: AgentSession | None = field(default=None, init=False, repr=False)
-    #: The in-process loop, created lazily per ``conv_id`` (``/clear`` and
-    #: ``/resume`` both change it, and each conversation owns a transcript).
-    _local: LocalEngine | None = field(default=None, init=False, repr=False)
-    #: Set while a local turn is streaming, so ``/stop`` and mid-turn queueing
-    #: have something to reach. Mirrors ``_current_session`` for the backend.
-    _active_local: LocalEngine | None = field(default=None, init=False, repr=False)
-
-    @property
-    def is_local(self) -> bool:
-        """True when turns run in this process."""
-        return self.engine == "local"
-
-    @property
-    def local_engine(self) -> LocalEngine | None:
-        """The bound in-process engine, or ``None`` before the first local turn.
-
-        Read-only accessor for introspection commands (``/context``).
-        """
-        return self._local
-
-    def _local_engine(self, ctx: Ctx) -> LocalEngine:
-        """The :class:`LocalEngine` bound to the active conversation."""
-        conv_id = ctx.state.conv_id
-        model = ctx.state.model
-        if self._local is None or self._local.conv_id != conv_id:
-            self._local = LocalEngine(conv_id=conv_id, model=model)
-        elif model and model != self._local.model:
-            self._local.set_model(model)
-        return self._local
 
+    @override
     async def on_enter(self, ctx: Ctx) -> None:
         """Prefetch model list, then replay any staged conversation history."""
         try:
@@ -170,34 +130,23 @@ class ChatApp(App):
             sink = ctx.output if ctx.output is not None else ctx.console
             sink.print(Text(f"(could not fetch models: {e})", style="yellow"))
 
-        # Local sessions persist to a JSONL transcript, not to
-        # ``app_cli_messages`` — so whatever the picker staged from Supabase is
-        # irrelevant and the transcript is the history to show.
-        if self.is_local:
-            self.pending_replay = Transcript.open(ctx.state.conv_id).replay()
-
         if self.pending_replay and ctx.output is not None:
             replay_messages(self.pending_replay, self, ctx.output)
         # Always drain — even a failed replay shouldn't replay again next time.
         self.pending_replay = []
 
+    @override
     async def send(
         self,
         ctx: Ctx,
         messages: list[dict[str, str]],
     ) -> AsyncIterator[dict[str, Any]]:
-        """Stream one turn's v6 events, from whichever engine is active.
+        """Stream one turn through :class:`AgentSession` against ``/cli/agent/...``.
 
-        ``local`` drives the in-process loop; ``backend`` streams
-        :class:`AgentSession` against ``/cli/agent/...`` (the ``app_cli`` row is
-        created at picker time, or by ``/clear``, so the backend always finds
-        the chat — no ``ensure_chat_row`` dance).
+        The ``app_cli`` row is created at picker time (or by ``/clear``),
+        so the backend always finds the chat when this runs — no
+        ``ensure_chat_row`` dance.
         """
-        if self.is_local:
-            async for event in self._send_local(ctx, messages):
-                yield event
-            return
-
         transport = AgentTransport(ctx.http, "cli", ctx.cfg.org_uuid)
         session = AgentSession(transport, ctx.state.conv_id, self.tools)
 
@@ -228,63 +177,29 @@ class ChatApp(App):
         finally:
             self._current_session = None
 
-    async def _send_local(
-        self,
-        ctx: Ctx,
-        messages: list[dict[str, str]],
-    ) -> AsyncIterator[dict[str, Any]]:
-        """Drive the in-process loop for one user turn.
-
-        The REPL sends exactly one new user message per turn; anything typed
-        while the turn runs goes through :meth:`queue_message` and is injected
-        at the next batch boundary, so only the last user message matters here.
-        """
-        engine = self._local_engine(ctx)
-        user_content = next(
-            (m.get("content", "") for m in reversed(messages) if m.get("role") == "user"),
-            "",
-        )
-        # Fresh git snapshot per turn — it rides in the turn's user message (not
-        # the system prompt) so the cacheable prefix stays byte-stable.
-        git_ctx = await collect_git_context(Path.cwd())
-        self._active_local = engine
-        try:
-            async for event in engine.run_turn(ctx, user_content, git_context=git_ctx):
-                yield event
-        finally:
-            self._active_local = None
-
+    @override
     def make_renderer(self, output: OutputBuffer) -> V6Renderer:
         """Build a fresh :class:`V6Renderer` wired to this app's tool registry."""
         return V6Renderer(output, self.tools)
 
+    @override
     async def cancel(self, ctx: Ctx) -> None:
-        """Stop the in-flight turn, if any.
+        """Send the backend stop signal for the in-flight turn, if any.
 
-        Local: flag the loop so it stops at its next checkpoint (the REPL also
-        cancels the driving task, which is what makes it feel instant).
-        Backend: send the Redis stop signal. No-op when no turn is active —
-        :meth:`send` clears its reference as soon as the iterator finishes.
+        No-op when no turn is active — :meth:`send` clears the session ref
+        as soon as the iterator finishes.
         """
         _ = ctx
-        if self.is_local:
-            if self._active_local is not None:
-                self._active_local.request_stop()
-            return
         if self._current_session is None:
             return
         # Best-effort — the loop has already shown an interrupt message.
         with contextlib.suppress(TransportError):
             await self._current_session.stop()
 
+    @override
     async def queue_message(self, ctx: Ctx, content: str) -> bool:
-        """Queue a message to be injected into the turn already in flight."""
+        """Append a message to the backend's FIFO queue while a turn is running."""
         _ = ctx
-        if self.is_local:
-            if self._active_local is None:
-                return False
-            self._active_local.queue_message(content)
-            return True
         if self._current_session is None:
             return False
         try:
@@ -293,10 +208,9 @@ class ChatApp(App):
             return False
         return True
 
+    @override
     def toolbar_fragment(self, ctx: Ctx) -> str:
-        """Show the active model, and the engine when it isn't the default."""
+        """Show the active model so the user can see what ``/model`` would change."""
+        _ = self
         model = ctx.state.model
-        parts = [f"  model: {model}"] if model else []
-        if self.is_local:
-            parts.append("engine: local")
-        return "  ".join(parts)
+        return f"  model: {model}" if model else ""