delos-cli 2.1.0__tar.gz → 5.9.16__tar.gz

{delos_cli-2.1.0 → delos_cli-5.9.16}/.gitignore

@@ -2,6 +2,8 @@ knip.txt
 pentest-*
 backend/.vscode
 backend/cosmos_env
+# convert_scribes_to_docx.py run log (projects/1015_scribe_decoupling)
+backend/scribe_conversion.jsonl
 # Allow backend/.env (has safe localhost defaults), but ignore all other .env files
 apps/**/.env
 collab/.env
@@ -21,26 +23,33 @@ infrastructure/supabase/**/.env
 backend/.python-version
 /scripts/
 */scripts/
+!packages/cms/shared/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/export_module_catalog.py
+!backend/scripts/export_microsoft_capabilities.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/check_usage_export.py
 !backend/scripts/fly_source_recovery.py
 !backend/scripts/audit_sprite_regions.py
 !backend/scripts/migrate_vibe_sprites.py
+!backend/scripts/requeue_mail_file_processing.py
+!backend/scripts/dedupe_outlook_mail.py
 
 .claude/worktrees
 
 data/documents2
 data/logs
+.data/database-service
 **/**0
 _local
 .env.old
@@ -86,12 +95,9 @@ dist/
 *.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
+# Pinned Node libraries copied into the document authoring Docker images.
+!backend/cosmos/modules/office/pptx/node/package-lock.json
 yarn.lock
 npm-shrinkwrap.json
 
@@ -157,7 +163,8 @@ logs/
 # serena
 .serena/
 
-# Mobile App (Expo/React Native)
+# Mobile app (Expo/React Native) — root-level so prettier/oxlint invoked from
+# the repo root skip the generated native folders (they read only this .gitignore)
 apps/mobile/.expo/
 apps/mobile/dist/
 apps/mobile/web-build/
@@ -170,13 +177,13 @@ apps/mobile/*.mobileprovision
 apps/mobile/*.p12
 apps/mobile/*.key
 apps/mobile/.metro-health-check*
+apps/mobile/.*
 
-# Desktop App (Electron) — build output (node_modules/build already ignored above)
-apps/desktop/dist/
-apps/desktop/release/
 
+# Desktop App (Electron) — build output (node_modules/build already ignored above)
+apps/ping-desktop/dist/
+apps/ping-desktop/release/
 
-.gitnexus
 
 # Python cache
 __pycache__/
@@ -200,3 +207,18 @@ apps/workers-mobile/eas-asc-key.p8
 
 # backfill_fts.py keyset cursor (local run state)
 projects/0904_drivesearch/.fts-cursor.json
+
+# Totem: the Pi's config, pushed by totem/scripts/deploy.sh; the Pi-side lock is local.
+# Its scripts/ are the deploy path itself, not build spill: re-included past `*/scripts/`.
+totem/.env.pi
+totem/uv.lock
+!totem/scripts/
+
+# pnpm addin:check report page
+.addin-check/
+
+# Corporate templates the PowerPoint evals run on — the customers' own files, kept off git
+backend/evals/data/powerpoint/private/
+
+# Delos Code worktrees — full repo copies; tools that walk the tree (ty, ruff, oxlint) must skip them
+.delos/

{delos_cli-2.1.0 → delos_cli-5.9.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: delos-cli
-Version: 2.1.0
+Version: 5.9.16
 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
@@ -24,9 +24,11 @@ Requires-Dist: httpx>=0.27.0
 Requires-Dist: prompt-toolkit>=3.0.47
 Requires-Dist: questionary>=2.0.1
 Requires-Dist: rich>=13.8.0
-Requires-Dist: ripgrep<15,>=14; sys_platform == 'darwin' and platform_machine == 'arm64'
-Requires-Dist: ripgrep<15,>=14; sys_platform == 'linux' and platform_machine == 'x86_64'
+Requires-Dist: ripgrep<15,>=14; sys_platform == 'darwin'
+Requires-Dist: ripgrep<15,>=14; sys_platform == 'linux' and (platform_machine == 'x86_64' or platform_machine == 'aarch64')
+Requires-Dist: ripgrep<15,>=14; sys_platform == 'win32' and (platform_machine == 'AMD64' or platform_machine == 'x86_64')
 Requires-Dist: sentry-sdk<3,>=2.44.0
+Requires-Dist: truststore>=0.10.0
 Requires-Dist: typer>=0.12.5
 Description-Content-Type: text/markdown
 
@@ -85,6 +87,7 @@ Conversations are scoped to the directory you launch from — running
 /help                 list commands
 /clear                wipe the screen and start a fresh conversation
 /rename <new name>    rename the current chat
+/mode [name]          show or set the mode: ask, plan, auto, build (default: build; shift-tab cycles)
 /delete               delete the current chat and go back to the picker
 /resume               back to the picker without deleting
 /stop                 interrupt the agent
@@ -93,6 +96,33 @@ Conversations are scoped to the directory you launch from — running
 /quit                 exit
 ```
 
+### Local MCP servers
+
+The CLI runs the stdio MCP servers declared in a `.mcp.json` (the Claude Code
+format) and gives their tools to the agent as `mcp__<server>__<tool>`. They
+execute on your machine, after the same permission prompt as shell commands,
+so keys stay local.
+
+- global: `~/.config/delos/mcp.json`
+- project: the nearest `.mcp.json` up to the repo root (wins on a name clash)
+
+```json
+{
+  "mcpServers": {
+    "my-server": {
+      "command": "uvx",
+      "args": ["my-mcp"],
+      "env": { "TOKEN": "${MY_TOKEN}" },
+      "timeout": 600
+    }
+  }
+}
+```
+
+`timeout` is per call, in seconds. `http`/`sse` entries are skipped for now. A
+project server only starts once you approve it in `/mcp`, and again whenever
+its command, args or env change. Server logs: `~/.config/delos/logs/mcp-<name>.log`.
+
 ## Headless mode (VSCode extension engine)
 
 ```bash

{delos_cli-2.1.0 → delos_cli-5.9.16}/README.md

@@ -53,6 +53,7 @@ Conversations are scoped to the directory you launch from — running
 /help                 list commands
 /clear                wipe the screen and start a fresh conversation
 /rename <new name>    rename the current chat
+/mode [name]          show or set the mode: ask, plan, auto, build (default: build; shift-tab cycles)
 /delete               delete the current chat and go back to the picker
 /resume               back to the picker without deleting
 /stop                 interrupt the agent
@@ -61,6 +62,33 @@ Conversations are scoped to the directory you launch from — running
 /quit                 exit
 ```
 
+### Local MCP servers
+
+The CLI runs the stdio MCP servers declared in a `.mcp.json` (the Claude Code
+format) and gives their tools to the agent as `mcp__<server>__<tool>`. They
+execute on your machine, after the same permission prompt as shell commands,
+so keys stay local.
+
+- global: `~/.config/delos/mcp.json`
+- project: the nearest `.mcp.json` up to the repo root (wins on a name clash)
+
+```json
+{
+  "mcpServers": {
+    "my-server": {
+      "command": "uvx",
+      "args": ["my-mcp"],
+      "env": { "TOKEN": "${MY_TOKEN}" },
+      "timeout": 600
+    }
+  }
+}
+```
+
+`timeout` is per call, in seconds. `http`/`sse` entries are skipped for now. A
+project server only starts once you approve it in `/mcp`, and again whenever
+its command, args or env change. Server logs: `~/.config/delos/logs/mcp-<name>.log`.
+
 ## Headless mode (VSCode extension engine)
 
 ```bash

delos_cli-5.9.16/delos_cli/__main__.py

@@ -0,0 +1,10 @@
+"""``python -m delos_cli`` — how the VS Code extension runs its bundled copy.
+
+The extension ships its own interpreter with the CLI installed into it and
+launches it through this module rather than the ``delos`` console script,
+whose launcher is tied to the machine that built it.
+"""
+
+from delos_cli.telemetry import main
+
+main()

delos_cli-5.9.16/delos_cli/_build.json

@@ -0,0 +1,5 @@
+{
+  "release": "v5.9.16",
+  "sha": "6d8943056ab27d475e82f4f8ce09feba751745fb",
+  "version": "5.9.16"
+}

{delos_cli-2.1.0 → delos_cli-5.9.16}/delos_cli/apps/__init__.py

@@ -2,6 +2,5 @@
 
 from .base import App, Renderer
 from .chat import ChatApp
-from .scribe import ScribeApp
 
-__all__ = ["App", "ChatApp", "Renderer", "ScribeApp"]
+__all__ = ["App", "ChatApp", "Renderer"]

{delos_cli-2.1.0 → delos_cli-5.9.16}/delos_cli/apps/base.py

@@ -1,6 +1,6 @@
 """App + Renderer protocols.
 
-Each app (chat, scribe, code, …) implements ``App``. The loop is
+Each app (chat, code, …) implements ``App``. The loop is
 app-agnostic: it only knows how to send a turn, get a renderer, and
 ask for a toolbar fragment.
 """
@@ -49,7 +49,7 @@ class App(ABC):
     Subclasses own their own state (model choice, selected tools, …).
     """
 
-    #: Short user-facing name (``"chat"``, ``"scribe"``, …).
+    #: Short user-facing name (``"chat"``, …).
     name: str
 
     #: Slash commands specific to this app — merged with the global registry.

{delos_cli-2.1.0 → delos_cli-5.9.16}/delos_cli/apps/chat/app.py

@@ -23,6 +23,7 @@ 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.git_context import collect_git_context
+from delos_cli.mcp import McpManager, register_tools
 from delos_cli.state import TodoStore
 from delos_cli.tools import (
     handle_ask_user_input,
@@ -50,7 +51,7 @@ from delos_cli.tools import (
     render_write_content,
 )
 from delos_cli.transport.client import TransportError
-from delos_cli.transport.models import fetch_models
+from delos_cli.transport.models import fetch_picker_models
 
 from .commands import CHAT_COMMANDS
 from .render import V6Renderer
@@ -60,6 +61,7 @@ if TYPE_CHECKING:
 
     from delos_cli.commands.base import CommandSpec
     from delos_cli.ctx import Ctx
+    from delos_cli.transport.client import AuthedClient
     from delos_cli.ui.output import OutputBuffer
 
 
@@ -104,6 +106,10 @@ class ChatApp(App):
 
     name: str = "chat"
     available_models: list[str] = field(default_factory=list)
+    #: Model id → Gate's display name (``Claude Sonnet 5.5``); ids missing here fall back to the slug.
+    model_titles: dict[str, str] = field(default_factory=dict)
+    #: Model new chats start on: the first model of the picker's top section, else its first model.
+    default_model: str | None = None
     commands: dict[str, CommandSpec] = field(default_factory=lambda: dict(CHAT_COMMANDS))
     #: Per-tool renderers + handlers.  Built-in entries cover the
     #: client-side tools the backend exposes (``run_shell`` for now).
@@ -119,13 +125,28 @@ 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)
+    #: Local stdio MCP servers (``.mcp.json``); set by ``main._run_repl``.
+    mcp: McpManager | None = None
     _current_session: AgentSession | None = field(default=None, init=False, repr=False)
 
+    async def refresh_models(self, http: AuthedClient) -> None:
+        """Load the ``cli`` picker: available ids, Gate titles and the default model for new chats."""
+        models = await fetch_picker_models(http)
+        self.available_models = [m["id"] for m in models]
+        self.model_titles = {m["id"]: m["title"] for m in models if m["title"]}
+        top = next((m for m in models if m["top"]), None)
+        first = top or (models[0] if models else None)
+        self.default_model = first["id"] if first else None
+
+    def model_label(self, model: str) -> str:
+        """Gate's display name for ``model``, or the slug itself when unknown."""
+        return self.model_titles.get(model, model)
+
     @override
     async def on_enter(self, ctx: Ctx) -> None:
         """Prefetch model list, then replay any staged conversation history."""
         try:
-            self.available_models = await fetch_models(ctx.http)
+            await self.refresh_models(ctx.http)
         except TransportError as e:
             sink = ctx.output if ctx.output is not None else ctx.console
             sink.print(Text(f"(could not fetch models: {e})", style="yellow"))
@@ -163,6 +184,15 @@ class ChatApp(App):
         # the agent doesn't burn its first tool call on `git status`.
         if (git_ctx := await collect_git_context(Path.cwd())) is not None:
             body["git_context"] = git_ctx
+        # Local MCP tools ride in every request of the turn (continuations
+        # re-send the body), never in plan mode — they may write anywhere.
+        if self.mcp is not None and ctx.state.permission_mode != "plan":
+            specs = await self.mcp.client_tool_specs()
+            if specs:
+                register_tools(self.tools, self.mcp, specs)
+                body["client_tools"] = specs
+            if (warning := self.mcp.tool_count_warning()) is not None and ctx.output is not None:
+                ctx.output.print(Text(warning, style="yellow"))
 
         self._current_session = session
         try:

{delos_cli-2.1.0 → delos_cli-5.9.16}/delos_cli/apps/chat/commands.py

@@ -5,28 +5,26 @@ Currently exposes ``/model`` so the user can change the active model
 
 Two modes:
 
-- ``/model``         → defer to the outer loop: set
-                       ``state.model_pick_requested`` and exit the REPL
-                       Application.  ``main._run_repl`` then runs
-                       :func:`pick_model` (a standalone Application) and
-                       re-enters the REPL on the same ``conv_id``.
+- ``/model``         → arrow-key picker shown over the input (``ctx.pick``),
+                       then PATCH the row and update ``ctx.state.model``.
+                       The REPL Application never exits, so nothing is
+                       reprinted and the input comes straight back.
 - ``/model <id>``    → validate against the cached
                        ``app.available_models`` list, PATCH the row,
-                       update ``ctx.state.model``.  Stays inside the REPL.
+                       update ``ctx.state.model``.
 """
 
 from __future__ import annotations
 
-import contextlib
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-from prompt_toolkit.application import get_app
 from rich.text import Text
 
 from delos_cli.commands.base import CommandSpec, registry_from
 from delos_cli.commands.prompts import EXECUTE_PROMPT, INIT_PROMPT_NEW, INIT_PROMPT_UPDATE
 from delos_cli.context_report import fetch_context_report, render_report
+from delos_cli.ctx import PickOption
 from delos_cli.git_context import collect_git_context
 from delos_cli.transport.chats import patch_chat_model
 from delos_cli.transport.client import TransportError
@@ -48,17 +46,47 @@ def _available_models(ctx: Ctx) -> list[str]:
     return list(getattr(ctx.app, "available_models", []) or [])
 
 
+async def _pick_model(ctx: Ctx) -> None:
+    """Show the model picker over the input, then apply the choice."""
+    sink = _sink(ctx)
+    if ctx.pick is None:
+        sink.print(Text("no interactive picker here — use /model <id>", style="yellow"))
+        return
+
+    # ``on_enter`` normally fills the cache; if that fetch failed (or came back
+    # empty) the picker would be empty — fetch lazily so /model stays reliable.
+    refresh = getattr(ctx.app, "refresh_models", None)
+    if not _available_models(ctx) and refresh is not None:
+        try:
+            await refresh(ctx.http)
+        except TransportError as e:
+            sink.print(Text(f"(could not fetch models: {e})", style="yellow"))
+    models = _available_models(ctx)
+    if not models:
+        sink.print(Text("no models available", style="yellow"))
+        return
+
+    titles: dict[str, str] = getattr(ctx.app, "model_titles", {})
+    options = [PickOption(m, titles.get(m, m), m if m in titles else "") for m in models]
+    chosen = await ctx.pick("Select a model", options, ctx.state.model)
+    if chosen is None or chosen == ctx.state.model:
+        return
+    try:
+        await patch_chat_model(ctx.http, chat_id=ctx.state.conv_id, model=chosen)
+    except TransportError as e:
+        sink.print(Text(f"failed to set model: {e}", style="red"))
+        return
+    ctx.state.model = chosen
+    sink.print(Text(f"model → {titles.get(chosen, chosen)}", style="dim"))
+
+
 async def _handle_model(ctx: Ctx, args: str) -> None:
     """Open the picker (no arg) or set directly (``/model <id>``)."""
     sink = _sink(ctx)
     arg = args.strip()
 
     if not arg:
-        # Defer to the outer loop: it owns the picker (no nested Application
-        # inside the live REPL).  /resume uses the same exit pattern.
-        ctx.state.model_pick_requested = True
-        with contextlib.suppress(Exception):
-            get_app().exit()
+        await _pick_model(ctx)
         return
 
     models = _available_models(ctx)
@@ -74,7 +102,9 @@ async def _handle_model(ctx: Ctx, args: str) -> None:
         return
 
     ctx.state.model = arg
-    sink.print(Text(f"model → {arg}", style="dim"))
+    titles: dict[str, str] = getattr(ctx.app, "model_titles", {})
+    label = titles.get(arg, arg)
+    sink.print(Text(f"model → {label}", style="dim"))
 
 
 def _complete_model(ctx: Ctx, prefix: str) -> Iterable[str]:
@@ -115,11 +145,11 @@ INIT = CommandSpec(
 
 
 async def _handle_execute(ctx: Ctx, args: str) -> None:  # noqa: RUF029 — CommandSpec handlers are async
-    """Leave plan permission-mode and stage the execute prompt."""
+    """Leave Plan mode (back to Build) and stage the execute prompt."""
     _ = args
     if ctx.state.permission_mode == "plan":
-        ctx.state.permission_mode = "default"
-        _sink(ctx).print(Text("permission mode → default", style="dim"))
+        ctx.state.permission_mode = "build"
+        _sink(ctx).print(Text("mode → Build", style="dim"))
     ctx.state.staged_message = EXECUTE_PROMPT
 
 

{delos_cli-2.1.0 → delos_cli-5.9.16}/delos_cli/apps/chat/render.py

@@ -201,7 +201,7 @@ class V6Renderer:
             )
 
         elif etype == "data-usage":
-            # Accumulated, not drawn: ``close()`` renders the turn total.
+            # Accumulated, not drawn: exposed as ``usage_label`` once the turn ends.
             payload = event.get("data") or {}
             self._input_tokens += int(payload.get("inputTokens") or 0)
             self._cached_tokens += int(payload.get("cachedTokens") or 0)
@@ -247,16 +247,18 @@ class V6Renderer:
             self._output.commit_live()
         else:
             self._output.discard_live()
-        self._render_usage()
 
-    def _render_usage(self) -> None:
-        """One dim line with the turn's prompt tokens and how many were cached."""
+    @property
+    def usage_label(self) -> str:
+        """The turn's prompt tokens and cache hit rate (``⚡ cache 80% · 48k in``), or ``""``.
+
+        Not printed into the scrollback: the REPL reads it after ``close()``
+        and shows it in the bottom toolbar.
+        """
         if self._input_tokens <= 0:
-            return
+            return ""
         hit = round(100 * self._cached_tokens / self._input_tokens)
-        self._output.append_block(
-            Text(f"⚡ cache {hit}% · {_fmt_tokens(self._input_tokens)} in", style="dim"),
-        )
+        return f"⚡ cache {hit}% · {_fmt_tokens(self._input_tokens)} in"
 
     @property
     def assistant_text(self) -> str:

{delos_cli-2.1.0 → delos_cli-5.9.16}/delos_cli/apps/replay.py

@@ -6,8 +6,7 @@ on REPL entry, routing tool calls through the active app's
 turns as for live ones.
 
 Each app supplies the message list itself (chat fetches a normalized
-``app_cli_messages`` table; scribe reads the ``messages`` jsonb column
-of ``app_scribe_chats``) — once a list is in hand the rendering is
+``app_cli_messages`` table) — once a list is in hand the rendering is
 identical, so it lives here instead of duplicated per app.
 """
 

{delos_cli-2.1.0 → delos_cli-5.9.16}/delos_cli/auth/config.py

@@ -15,9 +15,9 @@ monorepo so each developer's local ngrok tunnel is picked up automatically.
 from __future__ import annotations
 
 import contextlib
-import fcntl  # POSIX only; Windows support skipped for v1
 import json
 import os
+import sys
 import tempfile
 from contextlib import contextmanager
 from dataclasses import asdict, dataclass, field
@@ -49,10 +49,10 @@ class RegionUrls(TypedDict):
 
 # Supabase anon keys are public; same values live in apps/web/.env.production.*
 # and are embedded in the web/extension bundles. Safe to ship here.
-_EU_ANON = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.ewogICJyb2xlIjogImFub24iLAogICJpc3MiOiAic3VwYWJhc2UiLAogICJpYXQiOiAxNzEyNTI3MjAwLAogICJleHAiOiAxODcwMjkzNjAwCn0.gO1qyjuG2g4yAZ3u820P9q5CUTQmDiDrHSurZjIePbA"
+_EU_ANON = "sb_publishable_k0h1VrcR5Wlo7uHypgzp6EPXBM6AmCJYaty1HdlwHkc"
 _US_ANON = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoiYW5vbiIsImlzcyI6InN1cGFiYXNlIiwiaWF0IjoxNzU5MjY5NjAwLCJleHAiOjE5MTcwMzYwMDB9.VYuiRrB3q9GaR3qsZauOm1oIH_bZ3iuOzmNQfDcqo40"
 _AE_ANON = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoiYW5vbiIsImlzcyI6InN1cGFiYXNlIiwiaWF0IjoxNzY1MTQ4NDAwLCJleHAiOjE5MjI5MTQ4MDB9.TlD6gF-Q5K1drdnh-XPQgXGs410h5NcHJBRgV6aNXrY"
-_STAGING_ANON = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.ewogICJyb2xlIjogImFub24iLAogICJpc3MiOiAic3VwYWJhc2UiLAogICJpYXQiOiAxNzEyNTI3MjAwLAogICJleHAiOiAxODcwMjkzNjAwCn0.GDHgmBuu4XivLHq18P3A-sHblw99If9uqW-HChepSb8"
+_STAGING_ANON = "sb_publishable_FXOYjigrAP8eOtVoJsxJs-X6X6oEL0UfEIi3n-3r_4o"
 _DEV_ANON = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZS1kZW1vIiwicm9sZSI6ImFub24iLCJleHAiOjE5ODM4MTI5OTZ9.CRXP1A7WOeoJeXxjNni43kdQwgnWNReilDMblYTn_I0"
 
 
@@ -343,6 +343,33 @@ def save_tokens(cfg: Config) -> Path:
     return save(disk)
 
 
+if sys.platform == "win32":
+    import msvcrt
+
+    def _lock(f: IO[str]) -> None:
+        # LK_LOCK gives up after ~10 s of retries; loop for flock's blocking semantics.
+        f.seek(0)
+        while True:
+            try:
+                msvcrt.locking(f.fileno(), msvcrt.LK_LOCK, 1)
+            except OSError:
+                continue
+            return
+
+    def _unlock(f: IO[str]) -> None:
+        f.seek(0)
+        msvcrt.locking(f.fileno(), msvcrt.LK_UNLCK, 1)
+
+else:
+    import fcntl
+
+    def _lock(f: IO[str]) -> None:
+        fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+
+    def _unlock(f: IO[str]) -> None:
+        fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+
+
 @contextmanager
 def config_file_lock() -> Iterator[None]:
     """Advisory cross-process exclusive lock on ``~/.config/delos/.config.lock``.
@@ -352,17 +379,18 @@ def config_file_lock() -> Iterator[None]:
     against the same stale refresh_token (whichever loses the race would
     otherwise be kicked out with ``invalid_grant``).
 
-    POSIX only (uses :mod:`fcntl`). The lockfile is created on first use and
-    left in place; only the lock state matters.
+    ``fcntl.flock`` on POSIX, ``msvcrt.locking`` on byte 0 on Windows. The
+    lockfile is created on first use and left in place; only the lock state
+    matters.
     """
     CONFIG_DIR.mkdir(parents=True, exist_ok=True)
     f: IO[str] = LOCK_PATH.open("a+")
     try:
-        fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+        _lock(f)
         yield
     finally:
         with contextlib.suppress(OSError):
-            fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+            _unlock(f)
         f.close()