@pi-unipi/unipi 2.20.4 → 2.20.5

package/CHANGELOG.md

@@ -6,6 +6,17 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [2.20.5] — 2026-09-19
+
+### Fixed
+
+- `memory`: **MemPalace init no longer blocks startup by ~8–9s, and its migration finally converges.** `MemoryStorage.init()` ran the palace `ping` and the full `migrate` synchronously inside the memory `session_start` handler; whenever the source fingerprint had changed (i.e. after almost any memory write) the migrate re-embedded every changed record and, when a MemPalace daemon held the per-palace mine lock, every contended upsert raised `MineAlreadyRunning`, was counted as a hard `failed`, and the completion marker (`failed===0`) never advanced — so the whole ~8s sweep re-ran on every boot. Time-to-first-input dropped from ~9.5s to ~1s. The fix spans several layers:
+  - **Non-blocking init.** `init()` now does only the cheap install check and marks the backend active optimistically; `ping` + migration/catch-up run in a single-flight background task via `runBridgeAsync` (the spawned child is `unref()`d so a fire-and-forget migrate never keeps the process alive). `session_start` no longer awaits the bridge.
+  - **Contention-aware convergence.** The Python bridge now classifies `MineAlreadyRunning` as `deferred` (with `deferred_keys`), distinct from a genuine `failed`, and accepts an `only:[keys]` targeted pass. `markMigrated` advances when `failed===0 && verified+deferred===discovered`, persisting the deferred keys with an exponential backoff (15m → 1h → 6h → 24h) so later sessions retry just those keys instead of re-sweeping. `deferred` (lock) is kept strictly separate from `failed` (malformed) so the marker never advances over lost data.
+  - **Record-level ledger.** A new `~/.unipi/memory/.mempalace-ledger.json` maps `project/id` → sha256 of the exact markdown bytes last confirmed in the palace, replacing the size+mtime fingerprint that a normal `store()` invalidated on every write. Catch-up now migrates only records whose bytes differ from the ledger (plus due-for-retry deferred keys), `store()` records the ledger only on a confirmed upsert, and an existing `.mempalace-migrated` marker is used once to seed the ledger. The bridge stops discovering legacy `memory.db` (the SQLite tier is gone), so the corpus matches the ledger scanner exactly.
+  - **Daemon-aware catch-up.** `probeDaemon()` reads the palace daemon's `endpoint.json` + token and checks `/health`; when a daemon is reachable and actively mining, the background catch-up stands down for the session and lets the backoff ride out the lock instead of contending. When no daemon is running, behaviour is unchanged. (Writes are deliberately not routed through the daemon `/jobs` queue: it exposes no idempotent record-upsert job, and its generic write path uses a content-addressed drawer id incompatible with the bridge's source-URI id.)
+  - **Ping-cache hygiene.** Bridge calls now distinguish a successful `null` result and transient lock contention from real backend errors (`runBridgeOutcome`/`isTransientBridgeError`), so `.mempalace-ping-verified` is only invalidated on a genuine failure instead of on nearly every session.
+
 ## [2.20.4] — 2026-09-19
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/unipi",
-  "version": "2.20.4",
+  "version": "2.20.5",
   "description": "All-in-one extension suite for Pi coding agent",
   "type": "module",
   "license": "MIT",
@@ -84,29 +84,29 @@
     "typebox": "^1.1.38"
   },
   "dependencies": {
-    "@pi-unipi/ask-user": "2.20.4",
-    "@pi-unipi/background-tasks": "2.20.4",
-    "@pi-unipi/btw": "2.20.4",
-    "@pi-unipi/command-enchantment": "2.20.4",
-    "@pi-unipi/compactor": "2.20.4",
-    "@pi-unipi/core": "2.20.4",
-    "@pi-unipi/footer": "2.20.4",
-    "@pi-unipi/image": "2.20.4",
-    "@pi-unipi/fusion": "2.20.4",
-    "@pi-unipi/info-screen": "2.20.4",
-    "@pi-unipi/input-shortcuts": "2.20.4",
-    "@pi-unipi/kanboard": "2.20.4",
-    "@pi-unipi/mcp": "2.20.4",
-    "@pi-unipi/memory": "2.20.4",
-    "@pi-unipi/milestone": "2.20.4",
-    "@pi-unipi/notify": "2.20.4",
-    "@pi-unipi/ralph": "2.20.4",
-    "@pi-unipi/subagents": "2.20.4",
-    "@pi-unipi/trajectory": "2.20.4",
-    "@pi-unipi/updater": "2.20.4",
-    "@pi-unipi/utility": "2.20.4",
-    "@pi-unipi/web-api": "2.20.4",
-    "@pi-unipi/workflow": "2.20.4"
+    "@pi-unipi/ask-user": "2.20.5",
+    "@pi-unipi/background-tasks": "2.20.5",
+    "@pi-unipi/btw": "2.20.5",
+    "@pi-unipi/command-enchantment": "2.20.5",
+    "@pi-unipi/compactor": "2.20.5",
+    "@pi-unipi/core": "2.20.5",
+    "@pi-unipi/footer": "2.20.5",
+    "@pi-unipi/image": "2.20.5",
+    "@pi-unipi/fusion": "2.20.5",
+    "@pi-unipi/info-screen": "2.20.5",
+    "@pi-unipi/input-shortcuts": "2.20.5",
+    "@pi-unipi/kanboard": "2.20.5",
+    "@pi-unipi/mcp": "2.20.5",
+    "@pi-unipi/memory": "2.20.5",
+    "@pi-unipi/milestone": "2.20.5",
+    "@pi-unipi/notify": "2.20.5",
+    "@pi-unipi/ralph": "2.20.5",
+    "@pi-unipi/subagents": "2.20.5",
+    "@pi-unipi/trajectory": "2.20.5",
+    "@pi-unipi/updater": "2.20.5",
+    "@pi-unipi/utility": "2.20.5",
+    "@pi-unipi/web-api": "2.20.5",
+    "@pi-unipi/workflow": "2.20.5"
   },
   "devDependencies": {
     "@earendil-works/pi-agent-core": "^0.84.0",

package/packages/ask-user/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/ask-user",
-  "version": "2.20.4",
+  "version": "2.20.5",
   "description": "Structured user input tool for Pi coding agent — single-select, multi-select, freeform",
   "type": "module",
   "main": "index.ts",
@@ -40,7 +40,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.20.4"
+    "@pi-unipi/core": "2.20.5"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/autocomplete/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/command-enchantment",
-  "version": "2.20.4",
+  "version": "2.20.5",
   "description": "Enhanced TUI autocomplete for /unipi:* commands — colored, sorted, and grouped by package",
   "type": "module",
   "main": "src/index.ts",

package/packages/background-tasks/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/background-tasks",
-  "version": "2.20.4",
+  "version": "2.20.5",
   "description": "Background tasks for UniPi — durable shell jobs and delegated background agents with a footer dock",
   "type": "module",
   "main": "src/index.ts",
@@ -10,7 +10,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-ai": "^0.84.0",
-    "@pi-unipi/core": "2.20.4",
+    "@pi-unipi/core": "2.20.5",
     "turndown": "^7.2.4"
   },
   "devDependencies": {

package/packages/btw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/btw",
-  "version": "2.20.4",
+  "version": "2.20.5",
   "description": "A pi extension for parallel side conversations with /unipi:btw — part of the Unipi suite",
   "type": "module",
   "main": "extensions/btw.ts",
@@ -37,7 +37,7 @@
     "@earendil-works/pi-tui": "^0.84.0"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.20.4"
+    "@pi-unipi/core": "2.20.5"
   },
   "pi": {
     "extensions": [

package/packages/compactor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/compactor",
-  "version": "2.20.4",
+  "version": "2.20.5",
   "description": "Context engine for Pi — zero-LLM compaction, session continuity, sandbox execution, and tool display optimization",
   "type": "module",
   "main": "src/index.ts",
@@ -34,8 +34,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.20.4",
-    "@pi-unipi/info-screen": "2.20.4",
+    "@pi-unipi/core": "2.20.5",
+    "@pi-unipi/info-screen": "2.20.5",
     "@earendil-works/pi-agent-core": "^0.84.0"
   },
   "peerDependencies": {

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/core",
-  "version": "2.20.4",
+  "version": "2.20.5",
   "description": "Shared utilities, event types, and constants for Unipi extension suite",
   "type": "module",
   "license": "MIT",

package/packages/footer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/footer",
-  "version": "2.20.4",
+  "version": "2.20.5",
   "description": "Persistent status bar for Unipi — subscribes to UNIPI_EVENTS and renders key stats from all unipi packages",
   "type": "module",
   "main": "index.ts",
@@ -32,8 +32,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.20.4",
-    "@pi-unipi/background-tasks": "2.20.4"
+    "@pi-unipi/core": "2.20.5",
+    "@pi-unipi/background-tasks": "2.20.5"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/fusion/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/fusion",
-  "version": "2.20.4",
+  "version": "2.20.5",
   "description": "Devin-style model picker, fusion presets (lead + sidekick), and Local Fusion runtime for UniPi",
   "type": "module",
   "main": "src/index.ts",
@@ -32,8 +32,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.20.4",
-    "@pi-unipi/subagents": "2.20.4"
+    "@pi-unipi/core": "2.20.5",
+    "@pi-unipi/subagents": "2.20.5"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.84.0",

package/packages/image/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/image",
-  "version": "2.20.4",
+  "version": "2.20.5",
   "description": "Image generation and image recognition tools for the Pi coding agent",
   "type": "module",
   "main": "src/index.ts",
@@ -34,7 +34,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.20.4"
+    "@pi-unipi/core": "2.20.5"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.84.0",

package/packages/info-screen/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/info-screen",
-  "version": "2.20.4",
+  "version": "2.20.5",
   "description": "Dashboard and module registry for Unipi — configurable info overlay with tabbed groups",
   "type": "module",
   "main": "index.ts",
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.20.4"
+    "@pi-unipi/core": "2.20.5"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/input-shortcuts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/input-shortcuts",
-  "version": "2.20.4",
+  "version": "2.20.5",
   "description": "Keyboard shortcuts for stash/restore, undo/redo, clipboard, and thinking toggle — chord-based overlay system",
   "type": "module",
   "main": "src/index.ts",
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.20.4"
+    "@pi-unipi/core": "2.20.5"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/kanboard/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/kanboard",
-  "version": "2.20.4",
+  "version": "2.20.5",
   "description": "Visualization layer for unipi workflow — HTTP server with htmx/Alpine.js UI, modular parsers, TUI overlay, and kanban board",
   "type": "module",
   "main": "index.ts",
@@ -39,7 +39,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.20.4"
+    "@pi-unipi/core": "2.20.5"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/mcp",
-  "version": "2.20.4",
+  "version": "2.20.5",
   "description": "MCP server management extension for Pi coding agent — browse, add, configure, and use MCP servers",
   "type": "module",
   "main": "src/index.ts",
@@ -30,7 +30,7 @@
     "test": "npx tsx --test tests/**/*.test.ts"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.20.4"
+    "@pi-unipi/core": "2.20.5"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/memory/README.md

@@ -2,7 +2,7 @@
 
 Persistent memory that survives across sessions. Stores facts, preferences, and decisions with semantic vector search, so the agent remembers what you told it last week.
 
-**Primary backend: [MemPalace](https://github.com/mempalace/mempalace)** — auto-installed via `uv` on first load, with verified, resumable migration of existing legacy memories. If MemPalace or `uv` is unavailable, the package transparently falls back to the bundled SQLite + sqlite-vec store, so memory never hard-fails.
+**Backend: [MemPalace](https://github.com/mempalace/mempalace)** — auto-installed via `uv` on first load, with verified, resumable, incremental migration of existing markdown memories. Detection, ping, and migration run off the startup path, so loading the package never blocks the first prompt.
 
 Two storage tiers: MemPalace (or SQLite) for vector similarity search, markdown files for a durable human-readable copy you can edit by hand. Project-scoped memories stay separate per codebase, global memories are accessible everywhere.
 
@@ -74,46 +74,56 @@ Examples:
 Memory has no configuration file. Storage paths are fixed:
 
 ```
-~/.unipi/memory/                 # UniPi memory root (legacy + markdown tier)
+~/.unipi/memory/                 # UniPi memory root (markdown tier)
 ├── .mempalace-install           # Cached MemPalace venv detection
-├── .mempalace-migrated          # Versioned migration verification state
+├── .mempalace-migrated          # Legacy migration marker (seeds the ledger once)
+├── .mempalace-ledger.json       # Record-level sync ledger (project/id -> content hash)
+├── .mempalace-ping-verified     # Recent-ping cache (skips the cold-start ping)
 ├── global/
-│   ├── memory.db              # Global vector DB (SQLite fallback)
-│   └── *.md                   # Global memory files
+│   └── *.md                   # Global memory files (durable, human-readable)
 └── <project_name>/
-    ├── memory.db              # Project vector DB (SQLite fallback)
-    └── *.md                   # Project memory files
+    └── *.md                   # Project memory files (durable, human-readable)
 
-~/.mempalace/palace/             # MemPalace palace (primary backend)
+~/.mempalace/palace/             # MemPalace palace (vector backend)
 ```
 
 ## MemPalace backend
 
-On first load, the memory package:
+MemPalace is the sole vector backend; the markdown files are the durable,
+human-readable tier and the migration source. On load, the memory package:
 1. Detects MemPalace; if missing and `uv` is available, runs
    `uv tool install mempalace` once (caches the venv python path in
    `~/.unipi/memory/.mempalace-install`).
-2. Pings the bridge to confirm the palace is usable.
-3. Fingerprints the durable SQLite and markdown sources. If they differ from
-   the verified state in `~/.unipi/memory/.mempalace-migrated`, performs an
-   idempotent read-only migration into MemPalace drawers. Unchanged drawers are
-   skipped, new or changed memories are upserted, and the versioned state is
-   written only after every discovered record is verified in MemPalace.
-   Failed or partial migrations remain unmarked and retry on a later session.
+2. Marks the backend active immediately, then does everything else
+   **off the startup path** so time-to-first-input is never blocked: a
+   background task pings the bridge (skipped when recently ping-verified) and
+   runs an incremental catch-up.
+3. Catch-up is driven by a record-level ledger
+   (`~/.unipi/memory/.mempalace-ledger.json`) mapping `project/id` to the
+   sha256 of the markdown bytes last confirmed in the palace. Only records whose
+   bytes differ from the ledger are upserted, so an ordinary write never
+   triggers a full re-scan. `store()` updates the ledger only after a confirmed
+   upsert; a pre-existing `.mempalace-migrated` marker seeds the ledger once.
    Legacy files are never deleted or mutated.
 
-Each memory operation invokes the packaged Python bridge
-(`bridge/mempalace_bridge.py`) once via `spawnSync` (~0.5s per call). Both the
-standalone memory package and the all-in-one umbrella tarball ship and resolve
-this bridge. The
-first MemPalace use on a machine also downloads the default ONNX embedding
-model (~80MB, cached at `~/.cache/chroma/onnx_models/`).
+Records contended by a running MemPalace daemon's mine lock are recorded as
+**deferred** (never as failures) and retried with exponential backoff, so the
+catch-up always converges instead of re-running every boot. When a daemon is
+reachable and actively mining, the background catch-up stands down for the
+session rather than fighting the lock.
+
+Memory operations invoke the packaged Python bridge
+(`bridge/mempalace_bridge.py`); startup-path work uses the async, non-blocking
+variant. Both the standalone memory package and the all-in-one umbrella tarball
+ship and resolve this bridge. The first MemPalace use on a machine also
+downloads the default ONNX embedding model (~80MB, cached at
+`~/.cache/chroma/onnx_models/`).
 
 ### Forcing re-detection / re-migration
 
 ```bash
 rm ~/.unipi/memory/.mempalace-install    # re-detect MemPalace next session
-rm ~/.unipi/memory/.mempalace-migrated   # force a full verified migration pass next session
+rm ~/.unipi/memory/.mempalace-ledger.json  # force a full verified catch-up pass next session
 ```
 
 ### Backend override

package/packages/memory/bridge/mempalace_bridge.py

@@ -46,6 +46,15 @@ except Exception:  # pragma: no cover
 MEMORY_TYPES = {"preference", "decision", "pattern", "summary"}
 MIGRATION_AGENT = "unipi-memory-bridge"
 
+# MemPalace's per-palace mine lock is non-blocking: when a daemon or another
+# writer holds it, upserts raise MineAlreadyRunning (message "... is held by
+# PID ..."). That is transient contention, not a data error.
+_TRANSIENT_LOCK_RE = re.compile(r"MineAlreadyRunning|is held by", re.IGNORECASE)
+
+
+def _is_transient_lock_error(exc: Exception) -> bool:
+    return bool(_TRANSIENT_LOCK_RE.search(f"{type(exc).__name__}: {exc}"))
+
 
 # ---------------------------------------------------------------------------
 # ID + URI helpers (mirror mempalace.ids when available, else deterministic fallback)
@@ -311,8 +320,12 @@ def discover_legacy_memories(source_dir: Path, project_filter: list[str] | None
             rec = parse_markdown_memory(project, md_path)
             if rec:
                 by_key[(rec["project"], rec["id"])] = rec
-        for rec in load_sqlite_memories(project, project_dir / "memory.db"):
-            by_key.setdefault((rec["project"], rec["id"]), rec)
+        # Markdown is the sole durable source now (the SQLite fallback was
+        # removed). Discovering legacy memory.db here would surface records the
+        # TS ledger scanner cannot see, so `--only` targeted retries could not
+        # name them and the delta would never converge. `load_sqlite_memories`
+        # is retained for any explicit one-off recovery use, but is no longer
+        # part of the automatic catch-up corpus.
     return sorted(by_key.values(), key=lambda r: (r["project"], r["type"], r["title"], r["id"]))
 
 
@@ -492,18 +505,39 @@ class Bridge:
             synced += 1
         return synced
 
-    def migrate(self, source_dir: str, project_filter: list[str] | None = None) -> dict[str, Any]:
+    def migrate(
+        self,
+        source_dir: str,
+        project_filter: list[str] | None = None,
+        only: list[str] | None = None,
+    ) -> dict[str, Any]:
         """Idempotently import and then verify every discovered UniPi record.
 
         Migration callers must not infer success merely from a bridge process
         exiting cleanly. Return explicit discovery/failure/verification counts
         so UniPi only writes its completion marker after full verification.
+
+        Failures are split into two classes:
+        - ``deferred``: transient palace-lock contention (``MineAlreadyRunning``)
+          while a daemon/other writer holds the mine lock. The record is
+          untouched and simply needs retrying later; it is NOT a data error.
+        - ``failed``: a genuine per-record error (malformed record, backend
+          fault). The completion marker must never advance over these.
+
+        ``only`` optionally restricts the pass to a set of ``"project/id"`` keys
+        (targeted retry of previously deferred records) so a catch-up does not
+        re-sweep the entire corpus.
         """
         records = discover_legacy_memories(Path(source_dir), project_filter)
+        if only:
+            wanted = set(only)
+            records = [r for r in records if f"{r['project']}/{r['id']}" in wanted]
         imported = 0
         skipped = 0
         failed = 0
+        deferred = 0
         errors: list[str] = []
+        deferred_keys: list[str] = []
         by_project: dict[str, int] = {}
         expected = {(rec["project"], rec["id"]) for rec in records}
 
@@ -534,11 +568,19 @@ class Bridge:
                 existing_docs[key] = expected_doc
                 by_project[rec["project"]] = by_project.get(rec["project"], 0) + 1
             except Exception as exc:
-                failed += 1
-                if len(errors) < 20:
-                    errors.append(
-                        f"{rec['project']}/{rec['id']}: {type(exc).__name__}: {exc}"
-                    )
+                if _is_transient_lock_error(exc):
+                    # Palace held by a mine/daemon: the record is untouched and
+                    # just needs a later retry. Record the key, do not count it
+                    # as a data failure (which would block the completion marker
+                    # forever whenever a daemon is running).
+                    deferred += 1
+                    deferred_keys.append(f"{rec['project']}/{rec['id']}")
+                else:
+                    failed += 1
+                    if len(errors) < 20:
+                        errors.append(
+                            f"{rec['project']}/{rec['id']}: {type(exc).__name__}: {exc}"
+                        )
 
         # Re-read after writes and verify exact durable documents, not just
         # optimistic in-memory bookkeeping or collection counts. A palace may
@@ -560,6 +602,7 @@ class Bridge:
             if persisted_rec:
                 persisted[(persisted_rec["project"], persisted_rec["id"])] = doc
         verified = 0
+        verified_keys: list[str] = []
         for rec in records:
             expected_doc = build_document(
                 rec["title"], rec["content"], rec["tags"], rec["project"],
@@ -567,6 +610,7 @@ class Bridge:
             )
             if persisted.get((rec["project"], rec["id"])) == expected_doc:
                 verified += 1
+                verified_keys.append(f"{rec['project']}/{rec['id']}")
 
         return {
             "discovered": len(records),
@@ -574,9 +618,12 @@ class Bridge:
             "updated": imported,
             "skipped": skipped,
             "failed": failed,
+            "deferred": deferred,
             "verified": verified,
             "projects": by_project,
             "errors": errors,
+            "deferred_keys": deferred_keys[:200],
+            "verified_keys": verified_keys,
         }
 
 
@@ -617,7 +664,7 @@ def main(argv: list[str]) -> int:
         "has_title": lambda: bridge.has_title(args["wing"], args["title"]),
         "find_similar": lambda: bridge.find_similar(args["wing"], args["title"], float(args.get("threshold", 0.6))),
         "sync_orphaned": lambda: bridge.sync_orphaned(args["project_dir"], args["wing"]),
-        "migrate": lambda: bridge.migrate(args["source_dir"], args.get("projects")),
+        "migrate": lambda: bridge.migrate(args["source_dir"], args.get("projects"), args.get("only")),
     }
     handler = handlers.get(cmd)
     if handler is None: