pi-git-auth 1.1.0 → 1.2.2

package/README.md

@@ -2,8 +2,8 @@
 
 A [pi](https://github.com/badlogic/pi-mono) (coding-agent) extension that 
 gives the agent **git forges authentication** for **GitHub and GitLab**: login tokens are stored in the
-OS keyring, the active account is selected in the TUI, and every `git`
-command the agent runs is transparently authenticated with that account's
+OS keyring (kwallet), switch account, and every `git`command 
+the agent runs is transparently authenticated with that account's
 token for its host. It also manages accounts and repositories through each
 service's REST API.
 
@@ -138,9 +138,11 @@ available; the extension picks one at load time.
 ### OS keyring (preferred)
 The token lives in the session keyring, addressed by the
 [freedesktop Secret Service API](https://specifications.freedesktop.org/secret-service/)
-(`org.freedesktop.secrets` over D-Bus). This covers KWallet (via
-`ksecretd`), GNOME Keyring, KeePassXC, and any other Secret Service
-provider.
+(`org.freedesktop.secrets` over D-Bus). Any provider that implements
+that API over D-Bus is targeted: KWallet (via `ksecretd`) is the one
+verified end-to-end (including the interactive unlock dialog); GNOME
+Keyring and KeePassXC are covered by the same generic code path but
+have not been tested.
 
 - The embedded python3 client (a small script that `keyring.ts` keeps
   in sync in the state dir) opens a D-Bus session and talks
@@ -154,6 +156,41 @@ provider.
 - `credentials.json` keeps only a `wallet:v1:<accountKey>` marker per
   account; the token itself is in the keyring.
 
+#### KDE Plasma (KWallet / ksecretd)
+
+`ksecretd` fires a KWallet unlock dialog for **every** D-Bus operation on
+a locked collection, so the client is built to keep wallet access to the
+absolute minimum:
+
+- **Lookup never prompts.** A read on a locked collection returns
+  `locked` without touching the collection — no stacked prompts, no kded
+  "Repeated attempts to access a wallet have occurred" warning.
+- **Interactive unlock uses the Secret Service Prompt protocol.**
+  `Service.Unlock()` on a locked `ksecretd` collection returns a Prompt
+  object; the "KDE Wallet Service" password dialog is only shown once the
+  client calls `Prompt.Prompt()` on that object. The client does both:
+  trigger the dialog, then poll the collection's `Locked` property until it
+  actually opens (or the wait expires).
+- **Store is a single roundtrip** (create the new item + delete any older
+  matches, at most one unlock attempt) and only runs when a token actually
+  changed. `/auth switch`, `status`, and plain git use perform **zero**
+  keyring writes. On an interactive save (login) the client **waits up to
+  20 s for the unlock prompt to be answered** — without the wait the token
+  would silently fall back to the file every time the wallet happens to be
+  locked.
+- **When the wallet is still locked (or the keyring is otherwise
+  unreachable) after the wait**, the token is transparently kept in the
+  encrypted file instead of leaving a dead `wallet:v1:` marker — the token
+  stays available. Once the wallet unlocks, the token moves back into the
+  keyring on the next load.
+- If the wallet is locked when pi starts, the in-memory token is empty
+  (git auth is disabled meanwhile) and `/auth status` says so explicitly
+  instead of showing a bare `(none)`. The lookup is retried automatically
+  (throttled, prompt-safe) on the next `/auth status` or git-gate hit, so
+  the token recovers as soon as the wallet unlocks — no re-login needed.
+- `/auth status` reports where the active token **actually** lives
+  (keyring vs. encrypted file), not just which backend was selected.
+
 ### Encrypted file (fallback)
 When python3 / D-Bus / a keyring are unavailable (headless server, no
 session bus), the extension transparently falls back to an on-disk
@@ -178,8 +215,9 @@ reachable, else file), `wallet`, or `file`.
 
 - The git gate adds one regex pass per `git` command (same as any string
   rewrite) and no network calls; login adds one TUI prompt.
-- The keyring round-trip is one D-Bus exchange per account, only at load
-  and write time.
+- The keyring round-trip is one D-Bus exchange per account at load, and a
+  single upsert roundtrip **only for accounts whose token changed** at
+  write time (a `/auth switch` writes no keyring at all).
 - GitHub's details view uses a single bounded set of REST calls
   (repo meta + 5 commits + 1 recursive tree). GitLab's tree is top-level
   only (its API does not recurse), bounded to 100 entries.

package/auth.ts

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { loadStore, saveStore, maskToken, activeAccount, accountKey, purgeAccountStorage, storeBackend, type StoreData } from "./store";
+import { loadStore, saveStore, maskToken, activeAccount, accountKey, purgeAccountStorage, storeBackend, activeTokenStorage, keyringUnavailableAtLoadFlag, type StoreData } from "./store";
 import { SERVICES, type Platform, type Service } from "./forge";
 
 /** The subset of ctx.ui the auth flows need. */
@@ -132,13 +132,40 @@ export function statusDetail(data: StoreData): string {
   }
   const activeKey = data.activeLogin;
   if (activeKey) lines.push("");
-  lines.push(`Store: ${storeBackend() === "keyring" ? "OS keyring (Secret Service)" : "encrypted file"}`);
-  if (activeKey) lines.push("");
+  const backendIsKeyring = storeBackend() === "keyring";
+  const kwLocked = backendIsKeyring && keyringUnavailableAtLoadFlag();
   const active = activeKey ? data.accounts[activeKey] : undefined;
+  let storeLine = backendIsKeyring
+    ? "Store: OS keyring (Secret Service)"
+    : "Store: encrypted file (fallback)";
+  if (!backendIsKeyring) {
+    storeLine +=
+      process.env.PI_GIT_AUTH_STORE?.toLowerCase() === "file"
+        ? " — forced by PI_GIT_AUTH_STORE=file"
+        : " — keyring unavailable";
+  } else if (!active?.accessToken && kwLocked) {
+    storeLine += " (wallet locked on load — token unavailable)";
+  }
+  lines.push(storeLine);
   if (active && activeKey) {
     lines.push("");
     lines.push(`Active: @${active.user ?? activeKey.slice(activeKey.indexOf(":") + 1)}  (${active.platform})`);
-    lines.push(`Token: ${maskToken(active.accessToken)}`);
+    if (!active.accessToken && kwLocked) {
+      lines.push(
+        "Token: (none) — keyring locked: the token is stored in the keyring and is available again once the wallet unlocks (git auth is disabled meanwhile)"
+      );
+    } else if (active.accessToken) {
+      const inKeyring = backendIsKeyring && activeTokenStorage() === "keyring";
+      lines.push(
+        inKeyring
+          ? `Token: ${maskToken(active.accessToken)}  (stored in OS keyring)`
+          : `Token: ${maskToken(active.accessToken)}  (stored in encrypted file${
+              backendIsKeyring ? " — wallet was locked at save" : ""
+            })`,
+      );
+    } else {
+      lines.push(`Token: ${maskToken(active.accessToken)}`);
+    }
     if (active.scopes) lines.push(`Scopes: ${active.scopes}`);
     lines.push(`Saved: ${active.savedAt}`);
   }

package/commands.ts

@@ -1,5 +1,5 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { loadStore, activeAccount, type StoreData } from "./store";
+import { loadStore, activeAccount, retryKeyringLoad, type StoreData } from "./store";
 import { SERVICES, type Service, type TreeEntry } from "./forge";
 import { buildDetailsText, RepoDetailsPanel } from "./details";
 import { activeService, accountName, loginWithPastedToken, removeAccount, setActiveAccount, statusDetail } from "./auth";
@@ -7,6 +7,7 @@ import { activeService, accountName, loginWithPastedToken, removeAccount, setAct
 type Ctx = ExtensionCommandContext;
 
 async function showStatus(ctx: Ctx): Promise<void> {
+  retryKeyringLoad(); // prompt-safe: recovers the token once the wallet unlocks
   const data = loadStore();
   if (Object.keys(data.accounts).length === 0) {
     ctx.ui.notify("git auth: not connected — run /auth login", "info");

package/index.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { isToolCallEventType } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { loadStore, activeAccount } from "./store";
+import { loadStore, activeAccount, retryKeyringLoad } from "./store";
 import { SERVICES } from "./forge";
 import { findAccounts, setActiveAccount, statusDetail } from "./auth";
 import { instrumentGit } from "./git-gate";
@@ -15,6 +15,7 @@ export default function (pi: ExtensionAPI) {
   // ------------------------------------------------------------------
   pi.on("tool_call", async (event, ctx) => {
     if (!isToolCallEventType("bash", event)) return;
+    retryKeyringLoad(); // prompt-safe: recovers the token once the wallet unlocks
     const acc = activeAccount(loadStore());
     if (!acc?.accessToken) return;
     const host = SERVICES[acc.platform].host;
@@ -86,6 +87,7 @@ export default function (pi: ExtensionAPI) {
 
       switch (params.action) {
         case "status": {
+          retryKeyringLoad(); // prompt-safe: recovers the token once the wallet unlocks
           const data = loadStore();
           if (Object.keys(data.accounts).length === 0) return { ...text(notConnected), isError: true };
           return text(statusDetail(data));

package/keyring.ts

@@ -8,11 +8,32 @@
  * It talks JSON over stdin/stdout, which means the secret NEVER appears in
  * a process argument list — only in the parent process's memory.
  *
+ * KWallet/ksecretd (KDE Plasma) notes:
+ *   ksecretd implements the Secret Service "Prompt" protocol: calling
+ *   Service.Unlock() on a locked collection returns a Prompt object, and
+ *   the unlock dialog (the real "KDE Wallet Service" password dialog,
+ *   shown by ksecretd itself) only appears when the client then calls
+ *   Prompt.Prompt(window_id) on it. We do exactly that (with an empty
+ *   window id — headless) and then wait `wait` seconds (default 20) for
+ *   the collection to actually unlock:
+ *       * "lookup" on a locked collection returns {"locked": true} and
+ *         never touches the collection (no prompt — reads happen in the
+ *         background during git operations);
+ *       * "upsert" creates the new item (with its secret) FIRST and only
+ *         then deletes the previously matched ones — kill-safe: an
+ *         interrupted upsert never destroys the keyring copy; when the
+ *         collection is locked and a non-empty secret is being written it
+ *         triggers ONE interactive unlock (Service.Unlock + Prompt) and
+ *         waits for it to complete;
+ *       * delete-only ("clear" / empty secret) never unlocks.
+ * Non-interactive callers (bulk migration/repair at load) pass wait=0 and
+ * get the old instant-fallback behavior.
+ *
  * Two API generations are auto-detected at runtime by introspection:
  *   - modern 0.0.1 (gnome-keyring, kwallet --secretservice):
  *       Service.Store / SearchItems / item.GetSecret
  *   - legacy 0.0.0 (KDE ksecretd, default with KWallet 6):
- *       Collection.CreateItem / Service.SearchItems / Service.GetSecrets
+ *       Collection.CreateItem / SearchItems / Service.GetSecrets
  *
  * Fallback: when python3/dbus/keyring are unavailable (headless, no D-Bus),
  * store.ts silently keeps the on-disk AES-encrypted file format.
@@ -25,11 +46,19 @@ import { join } from "node:path";
 export const STATE_DIR = join(homedir(), ".pi", "agent", "pi-git-auth");
 const PY_PATH = join(STATE_DIR, "wallet-tool.py");
 const TIMEOUT_MS = 8000;
+/** Default seconds to wait for an interactive wallet unlock on write. */
+export const UNLOCK_WAIT_S = 20;
+/** Upserts may block on an interactive unlock: give the wait room. */
+const UPSERT_TIMEOUT_MS = (UNLOCK_WAIT_S + 15) * 1000;
+
+/** Outcome of a keyring write: ok, keyring locked, or unreachable. */
+export type WalletResult = "ok" | "locked" | "unreachable";
 
 interface WalletRes {
   ok: boolean;
   secret?: string;
   api?: string;
+  locked?: boolean;
   error?: string;
 }
 
@@ -38,16 +67,38 @@ const PY = `#!/usr/bin/env python3
 
 Protocol: one JSON request on stdin, one JSON response line on stdout.
   {"cmd": "available"}
-  {"cmd": "store",  "attrs": {...}, "secret": "..."}
+  {"cmd": "upsert", "attrs": {...}, "secret": "...", "wait": 20}
+      # empty secret = delete only; wait = seconds to wait for an
+      # interactive unlock while writing (0 = never wait)
   {"cmd": "lookup", "attrs": {...}}
   {"cmd": "clear",  "attrs": {...}}
 
 Auto-detects the Secret Service API generation (modern 0.0.1 vs legacy
 0.0.0/ksecretd) by introspecting the service.
+
+KWallet/ksecretd (KDE) note: ksecretd implements the Secret Service Prompt
+protocol. Service.Unlock() on a locked collection returns a Prompt object;
+the "KDE Wallet Service" password dialog (shown by ksecretd itself) only
+appears once the client calls Prompt.Prompt() on it. We do that (empty
+window id — we are headless) and then wait "wait" seconds for the
+collection to actually unlock.
+  - "lookup" on a locked collection returns {"locked": true} and never
+    touches the collection (no prompt);
+  - "upsert" creates the new item (with its secret) FIRST and only then
+    deletes the previously matched ones — kill-safe: an interrupted
+    upsert never destroys the keyring copy; when locked and a non-empty
+    secret is written it triggers ONE interactive unlock (Service.Unlock
+    + Prompt.Prompt) and waits for it;
+  - delete-only never unlocks.
+This keeps the client from stacking unlock prompts, which is what makes
+kded warn "Repeated attempts to access a wallet have occurred".
 """
 import sys
 import json
 import re
+import time
+
+UNLOCK_WAIT_S = 20.0
 
 
 def out(obj):
@@ -114,12 +165,12 @@ def main():
             if str(coll) == "/":
                 out({"ok": False, "error": "no default collection in keyring"})
                 return
-            try:
-                dbusi.Unlock([coll])
-            except Exception:
-                pass
 
         def find_items():
+            """Return (item paths in unlocked collections, locked flag).
+            legacy ksecretd reports items in LOCKED collections separately;
+            touching them would fire KWallet unlock dialogs, so callers
+            get the flag instead."""
             if MODERN:
                 res = dbusi.SearchItems(
                     dbus.UInt32(0),
@@ -128,11 +179,51 @@ def main():
                     ),
                     dbus.ObjectPath("/"),
                 )
-                return [str(k) for k in res]
-            (u, _l) = dbusi.SearchItems(dbus.Dictionary(
+                return [str(k) for k in res], False
+            (u, locked) = dbusi.SearchItems(dbus.Dictionary(
                 {k: v for k, v in attrs.items()}, "ss"
             ))
-            return [str(k) for k in list(u) + list(_l)]
+            return [str(k) for k in list(u)], bool(locked)
+
+        def is_locked_now():
+            """Authoritative collection lock state, via the Locked
+            property. (SearchItems only reports locking through items that
+            match the query — a locked collection with NO matching items
+            would otherwise look unlocked!)"""
+            if MODERN:
+                return False
+            try:
+                return bool(dbus.Interface(
+                    bus.get_object(owner, str(coll)),
+                    "org.freedesktop.DBus.Properties",
+                ).Get("org.freedesktop.Secret.Collection", "Locked"))
+            except Exception:
+                return bool(find_items()[1])
+
+        def unlock_with_prompt():
+            """Trigger ksecretd's interactive unlock flow. Service.Unlock()
+            returns (unlocked collections, prompt object path); the dialog
+            is only shown once Prompt.Prompt(window_id) is called on that
+            object — and it is shown by ksecretd itself, so it survives
+            this process exiting."""
+            if MODERN:
+                return  # modern (0.0.1) API has no locking
+            try:
+                res = dbusi.Unlock([dbus.ObjectPath(str(coll))])
+                prompt = str(res[1]) if res and len(res) > 1 else "/"
+            except Exception:
+                return
+            if prompt and prompt != "/":
+                try:
+                    piface = dbus.Interface(
+                        bus.get_object(owner, prompt),
+                        "org.freedesktop.Secret.Prompt",
+                    )
+                    # Empty window id: ksecretd still shows the dialog,
+                    # unparented, kept above all windows.
+                    piface.Prompt("")
+                except Exception:
+                    pass
 
         def get_content(path):
             """Return the secret bytes for an item path, or None."""
@@ -171,7 +262,50 @@ def main():
             except Exception:
                 pass
 
-        if cmd == "store":
+        if cmd in ("upsert", "store", "clear"):
+            wait = max(0.0, float(req.get("wait", UNLOCK_WAIT_S)))
+            paths, is_locked = find_items()
+            is_locked = is_locked_now() or is_locked
+            writing = cmd != "clear" and bool(secret)
+            if is_locked:
+                if not writing:
+                    # delete-only on a locked keyring: skip it rather than
+                    # prompt (best-effort purge; the file is already clean).
+                    out({"ok": False, "locked": True,
+                         "error": "keyring is locked"})
+                    return
+                if wait <= 0:
+                    # Non-interactive caller: NEVER prompt. Fall through to
+                    # the write attempt below — it may still succeed if the
+                    # wallet is being unlocked in parallel; otherwise the
+                    # IsLocked D-Bus error is caught below and reported as
+                    # "locked".
+                    pass
+                else:
+                    # Writing while locked: trigger the interactive unlock
+                    # (Service.Unlock + Prompt — ksecretd shows the "KDE
+                    # Wallet Service" password dialog) and wait for the
+                    # collection to actually unlock.
+                    unlock_with_prompt()
+                    deadline = time.time() + wait
+                    while is_locked_now() and time.time() < deadline:
+                        time.sleep(1)
+                    if is_locked_now():
+                        out({"ok": False, "locked": True,
+                             "error": "keyring is locked"})
+                        return
+                    paths, is_locked = find_items()
+            if cmd == "clear" or not secret:
+                for path in paths:
+                    item_delete(path)
+                out({"ok": True})
+                return
+            # Kill-safe order: create the new item (with its secret) first,
+            # then delete the previously matched items. Even if this process
+            # is killed mid-upsert the keyring copy is never destroyed
+            # (worst case: orphan items remain; the next upsert cleans them
+            # up, and lookups take the first non-empty secret).
+            new_path = ""
             if MODERN:
                 item = "/org/freedesktop/secrets/0/item/" + re.sub(
                     r"[^A-Za-z0-9_]", "_", "%s_%s" % (
@@ -211,9 +345,10 @@ def main():
                         "sv",
                     ),
                 )
+                new_path = item
             else:
                 coll_obj = dbus.Interface(
-                    bus.get_object(owner, str(dbusi.ReadAlias("default"))),
+                    bus.get_object(owner, str(coll)),
                     "org.freedesktop.Secret.Collection",
                 )
                 secret_arg = dbus.Struct((
@@ -231,12 +366,35 @@ def main():
                             {k: v for k, v in attrs.items()}, "ss"
                         ),
                 }, "sv")
-                coll_obj.CreateItem(props, secret_arg, True)
+                create_res = coll_obj.CreateItem(props, secret_arg, True)
+                # ksecretd returns (item_path, prompt) — the item comes
+                # FIRST (the 0.0.1 spec says (session, item)); scan the
+                # whole reply for a path under this collection instead of
+                # trusting a fixed index.
+                for cand in (
+                    create_res if isinstance(create_res, tuple) else ()
+                ):
+                    s = str(cand)
+                    if s.startswith(str(coll) + "/"):
+                        new_path = s
+                        break
+            if new_path:
+                for path in paths:
+                    if path != new_path:
+                        item_delete(path)
+            # else: can't tell which pre-matched item was updated in place —
+            # keep them all (orphans are harmless); deleting blindly would
+            # destroy the copy we just wrote.
             out({"ok": True})
             return
 
         if cmd == "lookup":
-            for path in find_items():
+            if is_locked_now():
+                out({"ok": False, "locked": True,
+                     "error": "keyring is locked"})
+                return
+            paths, is_locked = find_items()
+            for path in paths:
                 content = get_content(path)
                 if content:
                     out({
@@ -244,21 +402,29 @@ def main():
                         "secret": content.decode("utf-8", "replace"),
                     })
                     return
+            if is_locked:
+                # Item exists but its collection is locked (KWallet):
+                # report it, don't touch the collection (no unlock prompt).
+                out({"ok": False, "locked": True,
+                     "error": "keyring is locked"})
+                return
             out({"ok": False, "error": "item not found"})
             return
 
-        if cmd == "clear":
-            for path in find_items():
-                item_delete(path)
-            out({"ok": True})
-            return
-
         out({"ok": False, "error": "unknown command"})
     except Exception as e:
+        name = ""
+        try:
+            name = e.get_dbus_name() or ""  # D-Bus error name (python-dbus)
+        except Exception:
+            pass
         msg = str(e)
         if secret:
             msg = msg.replace(secret, "***")
-        out({"ok": False, "error": msg or e.__class__.__name__})
+        if "IsLocked" in name or "IsLocked" in msg:
+            out({"ok": False, "locked": True, "error": "keyring is locked"})
+        else:
+            out({"ok": False, "error": msg or e.__class__.__name__})
 
 
 main()
@@ -319,20 +485,40 @@ export function walletAvailable(): boolean {
   return availCache;
 }
 
-/** Store (upsert) a secret. */
-export function walletStore(attrs: Record<string, string>, secret: string): boolean {
-  const r = call({ cmd: "store", attrs, secret });
-  return !!(r && r.ok);
+let lastLookupLocked = false;
+
+/**
+ * Upsert a secret for the given attrs in ONE D-Bus roundtrip: the new item
+ * is created (with its secret) first, then the previously matched items are
+ * deleted — an interrupted upsert never destroys the keyring copy. An empty
+ * secret deletes only (best-effort, never prompts).
+ * `waitSec` is how long to wait for an interactive unlock when the
+ * keyring is locked while writing (default UNLOCK_WAIT_S for interactive
+ * callers such as login; pass 0 for non-interactive paths so they fall
+ * back to the file instantly). "locked" = the keyring exists but is
+ * locked (KWallet): the token must be kept in the file fallback;
+ * "unreachable" = no keyring/D-Bus at all.
+ */
+export function walletUpsert(attrs: Record<string, string>, secret: string, waitSec = UNLOCK_WAIT_S): WalletResult {
+  const r = call({ cmd: "upsert", attrs, secret, wait: waitSec }, Math.max(UPSERT_TIMEOUT_MS, (waitSec + 15) * 1000));
+  if (!r) return "unreachable";
+  if (r.ok) return "ok";
+  if (r.locked) return "locked";
+  return "unreachable";
 }
 
-/** Read a secret; null when not found or the keyring is unreachable. */
+/**
+ * Read a secret; null when not found, the keyring is locked, or the
+ * keyring is unreachable. See walletWasLocked() to distinguish a locked
+ * keyring from a missing item.
+ */
 export function walletLookup(attrs: Record<string, string>): string | null {
   const r = call({ cmd: "lookup", attrs });
+  lastLookupLocked = !!(r && r.locked);
   return r && r.ok ? (r.secret ?? null) : null;
 }
 
-/** Remove every item matching attrs. No-op when none exist. */
-export function walletClear(attrs: Record<string, string>): boolean {
-  const r = call({ cmd: "clear", attrs });
-  return !!(r && r.ok);
+/** True when the last lookup failed because the keyring is locked. */
+export function walletWasLocked(): boolean {
+  return lastLookupLocked;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-git-auth",
-  "version": "1.1.0",
+  "version": "1.2.2",
   "description": "pi coding-agent extension: git auth for GitHub and GitLab: keyring-stored login tokens, account switching, transparent git auth, repo list/create with details overlay",
   "license": "MIT",
   "author": "Carlo Onofrio",

package/store.ts

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
 import type { Platform } from "./forge";
-import { STATE_DIR, walletAvailable, walletStore, walletLookup, walletClear, walletAttrs } from "./keyring";
+import { STATE_DIR, walletAvailable, walletUpsert, walletLookup, walletAttrs, UNLOCK_WAIT_S } from "./keyring";
 
 /**
  * Credential persistence for pi-git-auth (multi-account, multi-service).
@@ -20,6 +20,15 @@ import { STATE_DIR, walletAvailable, walletStore, walletLookup, walletClear, wal
  *
  * Migration is transparent: legacy plaintext or `enc:v1:` tokens are moved
  * into the keyring on first load (a `.bak` copy of the file is kept).
+ * This is also the self-heal: a token kept in the file after a locked
+ * wallet goes back to the keyring on the next load while it is reachable
+ * (load-time writes use wait=0, so a still-locked wallet never delays
+ * startup).
+ *
+ * If the keyring is locked on load, the token for `wallet:v1:` accounts
+ * is "" for this process but is retried (throttled, prompt-safe) via
+ * retryKeyringLoad() on the next status/git-gate hit, so it recovers
+ * automatically once the wallet unlocks.
  *
  * Env override: PI_GIT_AUTH_STORE = auto (default) | wallet | file
  *
@@ -67,6 +76,16 @@ export interface StoreData {
 
 let cache: StoreData | null = null;
 let keyCache: Buffer | null = null;
+/** Stored strings (markers/envelopes) from the last file read/write. */
+let diskData: StoreData | null = null;
+/** Plaintext tokens as last persisted, per account key ("" = unreadable). */
+let storedPlaintext: Record<string, string> = {};
+/** A `wallet:v1:` token could not be read on load (keyring locked/absent). */
+let keyringUnavailableAtLoad = false;
+/** Accounts with a `wallet:v1:` marker that failed to read on load. */
+let loadFailedKeys: string[] = [];
+let lastRetryAt = 0;
+const RETRY_THROTTLE_MS = 10_000;
 
 const ENC_PREFIX = "enc:v1:";
 const WALLET_PREFIX = "wallet:v1:";
@@ -163,22 +182,40 @@ function decryptToken(enc: string): string {
 // Store API
 // ---------------------------------------------------------------------------
 
-function persist(data: StoreData): void {
-  // The in-memory copy holds plaintext; for each account the token is
-  // stored in the backend and the file keeps only a marker/envelope.
+/**
+ * Persist the in-memory (plaintext) state. Only accounts whose token
+ * changed since the last persist are (re)written to the backend; the
+ * others keep their on-disk marker/envelope untouched. This matters on
+ * KDE/ksecretd: a keyring write is the only operation that may trigger
+ * the KWallet unlock dialog, so e.g. `/auth switch` performs zero
+ * keyring writes (no prompts, no "repeated wallet access" warnings).
+ * When the keyring is locked/unreachable the token is kept in the
+ * encrypted file instead of leaving a dead `wallet:v1:` marker behind.
+ *
+ * `waitSec` = how long a keyring write may wait for an interactive
+ * wallet unlock. Interactive callers (login) pass UNLOCK_WAIT_S so the
+ * user can answer the KWallet prompt; load-time migration/repair passes
+ * 0 so a locked wallet never delays startup.
+ */
+function persist(data: StoreData, forceStore = false, waitSec = 0): void {
   const mode = storeMode();
   const accounts: Record<string, AccountRecord> = {};
+  const nowPlaintext: Record<string, string> = {};
   for (const [k, a] of Object.entries(data.accounts)) {
+    const changed = forceStore || storedPlaintext[k] !== a.accessToken;
+    const diskStored = diskData?.accounts[k]?.accessToken;
     let stored: string;
-    if (mode === "wallet") {
-      // Clear-then-store keeps the keyring free of duplicate items.
-      const attrs = recAttrs(a, k);
-      walletClear(attrs);
-      stored = walletStore(attrs, a.accessToken) ? WALLET_PREFIX + k : encryptToken(a.accessToken);
+    if (changed && a.accessToken) {
+      // Single keyring roundtrip (delete matching items + create).
+      const r = mode === "wallet" ? walletUpsert(recAttrs(a, k), a.accessToken, waitSec) : null;
+      stored = r === "ok" ? WALLET_PREFIX + k : encryptToken(a.accessToken);
+    } else if (diskStored) {
+      stored = diskStored; // unchanged: keep the existing marker/envelope
     } else {
-      stored = encryptToken(a.accessToken);
+      stored = a.accessToken ? encryptToken(a.accessToken) : "";
     }
     accounts[k] = { ...a, accessToken: stored };
+    nowPlaintext[k] = a.accessToken;
   }
   const out: StoreData = {
     accounts,
@@ -189,6 +226,9 @@ function persist(data: StoreData): void {
   writeFileSync(tmp, JSON.stringify(out, null, 2) + "\n", { mode: 0o600 });
   renameSync(tmp, CREDENTIALS_FILE);
   chmodSync(CREDENTIALS_FILE, 0o600);
+  diskData = out;
+  storedPlaintext = nowPlaintext;
+  cache = data;
 }
 
 export function loadStore(): StoreData {
@@ -201,6 +241,12 @@ export function loadStore(): StoreData {
   } catch {
     raw = {};
   }
+  // Deep snapshot BEFORE absorb() mutates records in place — diskData must
+  // keep the on-disk stored strings (markers/envelopes), never the
+  // plaintext tokens that absorb decrypts into the same objects.
+  diskData = raw.accounts && typeof raw.accounts === "object" ? JSON.parse(JSON.stringify(raw)) : null;
+  keyringUnavailableAtLoad = false;
+  loadFailedKeys = [];
   const data: StoreData = { accounts: {} };
   let migrated = false;
 
@@ -209,7 +255,12 @@ export function loadStore(): StoreData {
     if (rec.accessToken.startsWith(WALLET_PREFIX)) {
       const got = walletLookup(recAttrs(rec, key));
       if (got === null) {
-        rec.accessToken = ""; // keyring unreachable/cleared: don't crash, don't leak
+        // keyring locked/cleared: keep the marker on disk, run this
+        // process without the token, and flag it for the status output
+        // and for retryKeyringLoad().
+        rec.accessToken = "";
+        keyringUnavailableAtLoad = true;
+        loadFailedKeys.push(key);
       } else {
         rec.accessToken = got;
       }
@@ -229,6 +280,7 @@ export function loadStore(): StoreData {
       migrated = true;
     }
     data.accounts[key] = rec as AccountRecord;
+    storedPlaintext[key] = (rec as AccountRecord).accessToken;
   };
 
   if (raw.accounts && typeof raw.accounts === "object") {
@@ -253,7 +305,7 @@ export function loadStore(): StoreData {
       // Keep a rollback copy of the pre-migration file (still 0600, no
       // new secrets — it only contains ciphertexts/markers).
       if (hadFile && existsSync(CREDENTIALS_FILE)) copyFileSync(CREDENTIALS_FILE, CREDENTIALS_FILE + ".bak");
-      persist(cache);
+      persist(cache, true); // force re-store under the current backend
     } catch {
       /* best-effort migration */
     }
@@ -261,15 +313,62 @@ export function loadStore(): StoreData {
   return cache;
 }
 
+/**
+ * Persist after an interactive change (login): keyring writes may wait
+ * up to UNLOCK_WAIT_S for the user to answer the wallet unlock prompt.
+ */
 export function saveStore(data: StoreData): void {
-  cache = data;
-  persist(data);
+  persist(data, false, UNLOCK_WAIT_S);
+}
+
+/**
+ * Lazy recovery for tokens that could not be read on load (keyring
+ * locked): retry the lookup, throttled. Prompt-safe — a lookup never
+ * touches a locked collection, so this cannot stack unlock prompts.
+ * No-op once nothing is pending. Call it from hot paths (git gate,
+ * /auth status) so the token recovers as soon as the wallet unlocks.
+ */
+export function retryKeyringLoad(): void {
+  if (loadFailedKeys.length === 0) return;
+  const now = Date.now();
+  if (now - lastRetryAt < RETRY_THROTTLE_MS) return;
+  lastRetryAt = now;
+  const data = cache;
+  if (!data) return;
+  for (const k of [...loadFailedKeys]) {
+    const rec = data.accounts[k];
+    if (!rec || rec.accessToken) {
+      loadFailedKeys = loadFailedKeys.filter((x) => x !== k);
+      continue;
+    }
+    const got = walletLookup(recAttrs(rec, k));
+    if (got !== null) {
+      rec.accessToken = got;
+      storedPlaintext[k] = got;
+      loadFailedKeys = loadFailedKeys.filter((x) => x !== k);
+    }
+  }
+  if (loadFailedKeys.length === 0) keyringUnavailableAtLoad = false;
+}
+
+/** Where the active account's token actually lives on disk right now. */
+export function activeTokenStorage(): "keyring" | "file" {
+  const key = cache?.activeLogin;
+  const stored = key ? diskData?.accounts[key]?.accessToken : undefined;
+  return stored?.startsWith(WALLET_PREFIX) ? "keyring" : "file";
+}
+
+/** True when a `wallet:v1:` token could not be read on load (keyring
+ *  locked or unreachable) — the in-memory token for that account is "". */
+export function keyringUnavailableAtLoadFlag(): boolean {
+  return keyringUnavailableAtLoad;
 }
 
 /** Remove one account's keyring item (idempotent, best-effort). */
 export function purgeAccountStorage(key: string, rec?: AccountRecord | null): void {
   try {
-    if (rec) walletClear(recAttrs(rec, key));
+    // Empty secret = delete-only: best-effort, never triggers a prompt.
+    if (rec) walletUpsert(recAttrs(rec, key), "");
   } catch {
     /* best-effort */
   }
@@ -280,13 +379,15 @@ export function clearStore(): void {
   try {
     if (cache) {
       for (const [k, rec] of Object.entries(cache.accounts)) {
-        walletClear(recAttrs(rec, k));
+        walletUpsert(recAttrs(rec, k), "");
       }
     }
   } catch {
     /* best-effort */
   }
   cache = { accounts: {} };
+  diskData = null;
+  storedPlaintext = {};
   try {
     rmSync(CREDENTIALS_FILE);
   } catch {