@event4u/agent-switch 2.1.0 → 2.2.0

package/dist/mappings.js

@@ -12,6 +12,9 @@
  * canonicalized) paths; values are `{ provider, name }`. A path may map a
  * different profile per provider, so the stored value is keyed by provider:
  * `{ "<path>": { claude: "<name>", codex: "<name>", ... } }`.
+ *
+ * A rule can be paused without losing it: `paused` lists `{ "<path>": [provider] }`
+ * next to `mappings`, and resolution skips a paused rule as if it were absent.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -39,14 +42,30 @@ export function normalizePath(p) {
     }
     return canonicalizeWin32(resolved);
 }
-export function loadMappings() {
-    let data;
+function readFile() {
     try {
-        data = JSON.parse(fs.readFileSync(MAPPINGS_FILE, "utf8"));
+        return JSON.parse(fs.readFileSync(MAPPINGS_FILE, "utf8"));
     }
     catch {
+        return null;
+    }
+}
+function loadPaused() {
+    const raw = readFile()?.paused;
+    if (!raw || typeof raw !== "object")
         return {};
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (Array.isArray(value))
+            out[key] = value.filter((v) => typeof v === "string");
     }
+    return out;
+}
+const isPaused = (paused, key, providerId) => !!paused[key]?.includes(providerId);
+export function loadMappings() {
+    const data = readFile();
+    if (!data)
+        return {};
     const raw = data && typeof data.mappings === "object" ? data.mappings : {};
     const out = {};
     for (const [key, value] of Object.entries(raw)) {
@@ -58,11 +77,29 @@ export function loadMappings() {
     }
     return out;
 }
-function save(mappings) {
+/** Write mappings; paused flags of rules that no longer exist are dropped. */
+function save(mappings, paused = loadPaused()) {
     ensureRoot();
-    fs.writeFileSync(MAPPINGS_FILE, JSON.stringify({ schema: 2, mappings }, null, 2) + "\n", {
-        mode: 0o600,
-    });
+    const kept = {};
+    for (const [key, providers] of Object.entries(paused)) {
+        const live = providers.filter((p) => mappings[key]?.[p]);
+        if (live.length > 0)
+            kept[key] = live;
+    }
+    const body = Object.keys(kept).length > 0 ? { schema: 2, mappings, paused: kept } : { schema: 2, mappings };
+    fs.writeFileSync(MAPPINGS_FILE, JSON.stringify(body, null, 2) + "\n", { mode: 0o600 });
+}
+/** Pause or resume one folder rule. False when the folder has no rule for the provider. */
+export function setPaused(dir, providerId, on) {
+    const key = normalizePath(dir);
+    const mappings = loadMappings();
+    if (!mappings[key]?.[providerId])
+        return false;
+    const paused = loadPaused();
+    const rest = (paused[key] ?? []).filter((p) => p !== providerId);
+    paused[key] = on ? [...rest, providerId] : rest;
+    save(mappings, paused);
+    return true;
 }
 export function setMapping(dir, providerId, name) {
     const key = normalizePath(dir);
@@ -93,10 +130,11 @@ export function removeMapping(dir, providerId) {
 /** Nearest mapped ancestor of `dir` (inclusive) for a provider; null if none. */
 export function resolveMapping(dir, providerId) {
     const mappings = loadMappings();
+    const paused = loadPaused();
     let current = normalizePath(dir);
     for (;;) {
         const entry = mappings[current];
-        if (entry && entry[providerId])
+        if (entry && entry[providerId] && !isPaused(paused, current, providerId))
             return { path: current, name: entry[providerId] };
         const parent = path.dirname(current);
         if (parent === current)
@@ -123,9 +161,10 @@ export function pruneMappings(providerId, name) {
 /** All mappings as flat rows for display. */
 export function mappingRows() {
     const rows = [];
+    const paused = loadPaused();
     for (const [key, entry] of Object.entries(loadMappings())) {
         for (const [provider, name] of Object.entries(entry)) {
-            rows.push({ path: key, provider: provider, name: name });
+            rows.push({ path: key, provider: provider, name: name, paused: isPaused(paused, key, provider) });
         }
     }
     return rows.sort((a, b) => a.path.localeCompare(b.path) || a.provider.localeCompare(b.provider));

package/dist/pools.js

@@ -0,0 +1,144 @@
+/**
+ * Pools — explicit, user-created groups of profiles that a folder rule may point
+ * at (`map pool:<id> [dir]`). Additive and opt-in: the store starts empty, an
+ * upgrade creates nothing, and labels (Work/Personal/Other) and
+ * `autoSwitch.tag` are never read or changed here. Membership is many-to-many
+ * and keyed by `provider/name`; a pool may hold profiles of several providers,
+ * and a lookup only ever considers members of the provider being started.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ROOT, ensureRoot, labelFor, listAllProfiles, PROFILE_LABELS } from "./profiles.js";
+import { isProviderId } from "./providers.js";
+export const POOLS_FILE = path.join(ROOT, "pools.json");
+export const POOL_PREFIX = "pool:";
+export function isPoolRef(v) {
+    return v.startsWith(POOL_PREFIX);
+}
+export function poolIdOf(ref) {
+    return ref.slice(POOL_PREFIX.length);
+}
+/** `claude/work` → `{ provider, name }`, or null when it is not a member key. */
+export function parseMember(v) {
+    const m = /^([a-z]+)\/([A-Za-z0-9_-]+)$/.exec(v);
+    if (!m || !isProviderId(m[1]))
+        return null;
+    return { provider: m[1], name: m[2] };
+}
+export function slugify(name) {
+    return name
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 40);
+}
+export function readPools(file = POOLS_FILE) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (!Array.isArray(raw?.pools))
+            return [];
+        return raw.pools
+            .filter((p) => p && typeof p.id === "string" && typeof p.name === "string")
+            .map((p) => ({
+            id: p.id,
+            name: p.name,
+            members: Array.isArray(p.members) ? p.members.filter((m) => typeof m === "string" && parseMember(m)) : [],
+            createdAt: typeof p.createdAt === "string" ? p.createdAt : "",
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function save(pools, file) {
+    if (file === POOLS_FILE)
+        ensureRoot();
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify({ schema: 1, pools }, null, 2) + "\n", { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+export function findPool(id, file = POOLS_FILE) {
+    return readPools(file).find((p) => p.id === id) ?? null;
+}
+function mustFind(pools, id) {
+    const p = pools.find((x) => x.id === id);
+    if (!p)
+        throw new Error(`no pool "${id}" (pools: ${pools.map((x) => x.id).join(", ") || "none"})`);
+    return p;
+}
+export function createPool(name, file = POOLS_FILE, now = new Date()) {
+    const display = name.trim();
+    const id = slugify(display);
+    if (!id)
+        throw new Error("pool name needs at least one letter or digit");
+    const pools = readPools(file);
+    if (pools.some((p) => p.id === id))
+        throw new Error(`a pool "${id}" already exists`);
+    const pool = { id, name: display, members: [], createdAt: now.toISOString() };
+    save([...pools, pool], file);
+    return pool;
+}
+/** Renames the display name only — the id stays, so folder rules keep working. */
+export function renamePool(id, name, file = POOLS_FILE) {
+    const pools = readPools(file);
+    const p = mustFind(pools, id);
+    if (!name.trim())
+        throw new Error("pool name must not be empty");
+    p.name = name.trim();
+    save(pools, file);
+    return p;
+}
+export function deletePool(id, file = POOLS_FILE) {
+    const pools = readPools(file);
+    mustFind(pools, id);
+    save(pools.filter((p) => p.id !== id), file);
+}
+export function addPoolMember(id, member, file = POOLS_FILE) {
+    if (!parseMember(member))
+        throw new Error(`"${member}" is not a profile key (expected provider/name, e.g. claude/work)`);
+    const pools = readPools(file);
+    const p = mustFind(pools, id);
+    if (!p.members.includes(member))
+        p.members.push(member);
+    save(pools, file);
+    return p;
+}
+export function removePoolMember(id, member, file = POOLS_FILE) {
+    const pools = readPools(file);
+    const p = mustFind(pools, id);
+    p.members = p.members.filter((m) => m !== member);
+    save(pools, file);
+    return p;
+}
+/** Keep memberships pointing at a profile across a rename / drop them on remove. */
+export function renamePoolMember(from, to, file = POOLS_FILE) {
+    const pools = readPools(file);
+    let changed = false;
+    for (const p of pools) {
+        if (!p.members.includes(from))
+            continue;
+        p.members = p.members.filter((m) => m !== from);
+        if (to && !p.members.includes(to))
+            p.members.push(to);
+        changed = true;
+    }
+    if (changed)
+        save(pools, file);
+}
+/**
+ * "Suggest from tags": one proposed pool per label in use. A preview only —
+ * nothing is stored until the user confirms (`pool suggest --confirm`), and a
+ * proposal whose id already exists is marked so it is never overwritten.
+ */
+export function suggestPoolsFromLabels(profiles = listAllProfiles(), label = labelFor, existing = readPools()) {
+    const out = [];
+    for (const l of PROFILE_LABELS) {
+        const members = profiles.filter((p) => label(p.provider, p.name) === l).map((p) => `${p.provider}/${p.name}`);
+        if (members.length === 0)
+            continue;
+        const id = slugify(l);
+        out.push({ id, name: l, members, exists: existing.some((p) => p.id === id) });
+    }
+    return out;
+}

package/dist/profiles.js

@@ -4,7 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { PROVIDER_IDS, provider, isProviderId } from "./providers.js";
 import { credentialStore } from "./credentials.js";
-import { DEFAULT_GUARD_POLICY, isGuardPolicy } from "./single-load.js";
+import { DEFAULT_GUARD_POLICY, FRESH_INSTALL_GUARD_POLICY, isGuardPolicy } from "./single-load.js";
 export const HOME = os.homedir();
 export const ROOT = process.env.AGENT_SWITCH_HOME ?? path.join(HOME, ".agent-switch");
 export const STATE_FILE = path.join(ROOT, "state.json");
@@ -13,6 +13,11 @@ export const PROFILE_LABELS = ["Work", "Personal", "Other"];
 export function isProfileLabel(v) {
     return typeof v === "string" && PROFILE_LABELS.includes(v);
 }
+/** The account colours the GUI offers (its swatches use the same names). */
+export const PROFILE_COLORS = ["orange", "red", "yellow", "green", "teal", "blue", "purple", "pink"];
+export function isProfileColor(v) {
+    return typeof v === "string" && PROFILE_COLORS.includes(v);
+}
 export const DEFAULT_AUTOSWITCH = { enabled: false, threshold: 95, tag: "all" };
 /**
  * Providers enabled out of the box. Everything else is available but off by
@@ -33,7 +38,13 @@ export function die(msg) {
     process.exit(1);
 }
 export function ensureRoot() {
+    // A fresh install pins its fresh-install defaults (guard: warn) on the first
+    // write, so the first profile it gets cannot flip it into looking like an
+    // upgraded 2.1.0 install (profiles, no state.json → block).
+    const fresh = !fs.existsSync(STATE_FILE) && listAllProfiles().length === 0;
     fs.mkdirSync(ROOT, { recursive: true, mode: 0o700 });
+    if (fresh)
+        fs.writeFileSync(STATE_FILE, JSON.stringify(readState(), null, 2) + "\n", { mode: 0o600 });
 }
 function validateName(name) {
     if (!/^[A-Za-z0-9_-]+$/.test(name))
@@ -102,6 +113,16 @@ function normalizeLabels(raw) {
     }
     return out;
 }
+function normalizeColors(raw) {
+    const out = {};
+    if (raw && typeof raw === "object") {
+        for (const [k, v] of Object.entries(raw)) {
+            if (isProfileColor(v))
+                out[k] = v;
+        }
+    }
+    return out;
+}
 function normalizeAutoSwitch(raw) {
     const r = (raw ?? {});
     const threshold = typeof r.threshold === "number" && r.threshold >= 1 && r.threshold <= 100 ? Math.round(r.threshold) : DEFAULT_AUTOSWITCH.threshold;
@@ -168,6 +189,8 @@ export function readState() {
     try {
         const raw = JSON.parse(fs.readFileSync(STATE_FILE, "utf8"));
         const labels = normalizeLabels(raw?.labels);
+        const colors = normalizeColors(raw?.colors);
+        const disabled = Array.isArray(raw?.disabled) ? raw.disabled.filter((k) => typeof k === "string") : [];
         const autoSwitch = normalizeAutoSwitchMap(raw?.autoSwitch);
         const providers = normalizeProvidersMap(raw?.providers);
         const binaryPaths = normalizeBinaryPaths(raw?.binaryPaths);
@@ -176,17 +199,21 @@ export function readState() {
         const guard = normalizeGuard(raw?.guard);
         // v1: { active: "<name>" } — a single Claude profile.
         if (typeof raw?.active === "string") {
-            return { active: { ...emptyActive(), claude: raw.active }, labels, autoSwitch, providers, binaryPaths, osNotifications, rebind, guard };
+            return { active: { ...emptyActive(), claude: raw.active }, labels, colors, disabled, autoSwitch, providers, binaryPaths, osNotifications, rebind, guard };
         }
         if (raw?.active && typeof raw.active === "object") {
-            return { active: { ...emptyActive(), ...raw.active }, labels, autoSwitch, providers, binaryPaths, osNotifications, rebind, guard };
+            return { active: { ...emptyActive(), ...raw.active }, labels, colors, disabled, autoSwitch, providers, binaryPaths, osNotifications, rebind, guard };
         }
-        return { active: emptyActive(), labels, autoSwitch, providers, binaryPaths, osNotifications, rebind, guard };
+        return { active: emptyActive(), labels, colors, disabled, autoSwitch, providers, binaryPaths, osNotifications, rebind, guard };
     }
     catch {
         /* absent / unparsable → default */
     }
-    return { active: emptyActive(), labels: {}, autoSwitch: emptyAutoSwitch(), providers: emptyProviders(), binaryPaths: {}, osNotifications: false, rebind: { ...DEFAULT_REBIND_STATE }, guard: DEFAULT_GUARD_POLICY };
+    // Fresh = nothing at all yet. `add` without `use` writes no state.json, so a
+    // 2.1.0 install can have profiles and no state file — that user must keep the
+    // pre-2.2 default (block), not be treated as new.
+    const fresh = !fs.existsSync(STATE_FILE) && listAllProfiles().length === 0;
+    return { active: emptyActive(), labels: {}, colors: {}, disabled: [], autoSwitch: emptyAutoSwitch(), providers: emptyProviders(), binaryPaths: {}, osNotifications: false, rebind: { ...DEFAULT_REBIND_STATE }, guard: fresh ? FRESH_INSTALL_GUARD_POLICY : DEFAULT_GUARD_POLICY };
 }
 export function readOsNotifications() {
     return readState().osNotifications;
@@ -247,9 +274,40 @@ export function setLabel(providerId, name, label) {
         delete state.labels[key];
     writeState(state);
 }
-/** Drop a removed profile's label so it can't linger as an orphan. */
+/** Drop a removed profile's label, colour and disabled flag so they can't
+ *  linger as orphans (a reused name starts clean). */
 export function clearLabel(providerId, name) {
     setLabel(providerId, name, null);
+    setColor(providerId, name, null);
+    setDisabled(providerId, name, false);
+}
+export function isDisabled(providerId, name) {
+    return readState().disabled.includes(labelKey(providerId, name));
+}
+/** Disable (or re-enable) a profile. Disabling the active one clears the slot. */
+export function setDisabled(providerId, name, disabled) {
+    const state = readState();
+    const key = labelKey(providerId, name);
+    state.disabled = state.disabled.filter((k) => k !== key);
+    if (disabled) {
+        state.disabled.push(key);
+        if (state.active[providerId] === name)
+            state.active[providerId] = null;
+    }
+    writeState(state);
+}
+export function colorOf(providerId, name) {
+    return readState().colors[labelKey(providerId, name)] ?? null;
+}
+/** Set (or clear, with null) a profile's colour. */
+export function setColor(providerId, name, color) {
+    const state = readState();
+    const key = labelKey(providerId, name);
+    if (color)
+        state.colors[key] = color;
+    else
+        delete state.colors[key];
+    writeState(state);
 }
 /**
  * Rename a profile: move its config dir, carry its Claude credential across the
@@ -292,6 +350,11 @@ export function renameProfile(providerId, from, to, store = credentialStore()) {
         state.labels[toKey] = state.labels[fromKey];
         delete state.labels[fromKey];
     }
+    if (state.colors[fromKey] !== undefined) {
+        state.colors[toKey] = state.colors[fromKey];
+        delete state.colors[fromKey];
+    }
+    state.disabled = state.disabled.map((k) => (k === fromKey ? toKey : k));
     writeState(state);
 }
 export function readAutoSwitch(providerId) {

package/dist/protection.js

@@ -0,0 +1,93 @@
+/**
+ * Session protection — a per-profile policy, separate from the near-limit
+ * notifications (`autoswitch`, 95 %) and the context alerts. Default ON at 98 %
+ * for every profile, including ones that existed before this file did: a
+ * profile with no stored entry simply reads the default.
+ *
+ * What it does today: the daemon WARNS when a polled profile reaches its
+ * threshold. It does not pause anything. A real pause needs the provider to
+ * hold the session (Claude Code's own auto-continue), which agent-switch cannot
+ * verify from here, so every notice says "warn" — never "paused".
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ROOT, ensureRoot } from "./profiles.js";
+export const PROTECTION_FILE = path.join(ROOT, "protection.json");
+export const DEFAULT_PROTECTION = { enabled: true, thresholdPct: 98 };
+function key(providerId, name) {
+    return `${providerId}/${name}`;
+}
+function validThreshold(v) {
+    return typeof v === "number" && Number.isInteger(v) && v >= 1 && v <= 100;
+}
+function load(file) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+        return raw && typeof raw.profiles === "object" && raw.profiles ? raw.profiles : {};
+    }
+    catch {
+        return {};
+    }
+}
+function save(profiles, file) {
+    if (file === PROTECTION_FILE)
+        ensureRoot();
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify({ schema: 1, profiles }, null, 2) + "\n", { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+function normalize(raw) {
+    return {
+        enabled: typeof raw?.enabled === "boolean" ? raw.enabled : DEFAULT_PROTECTION.enabled,
+        thresholdPct: validThreshold(raw?.thresholdPct) ? raw.thresholdPct : DEFAULT_PROTECTION.thresholdPct,
+    };
+}
+export function readProtection(providerId, name, file = PROTECTION_FILE) {
+    return normalize(load(file)[key(providerId, name)]);
+}
+export function setProtection(providerId, name, patch, file = PROTECTION_FILE) {
+    if (patch.thresholdPct !== undefined && !validThreshold(patch.thresholdPct)) {
+        throw new Error("threshold must be a whole number between 1 and 100");
+    }
+    const all = load(file);
+    const next = normalize({ ...normalize(all[key(providerId, name)]), ...patch });
+    all[key(providerId, name)] = next;
+    save(all, file);
+    return next;
+}
+/** Carry a profile's policy across a rename; drop it on remove. */
+export function renameProtection(providerId, from, to, file = PROTECTION_FILE) {
+    const all = load(file);
+    if (!(key(providerId, from) in all))
+        return;
+    all[key(providerId, to)] = all[key(providerId, from)];
+    delete all[key(providerId, from)];
+    save(all, file);
+}
+export function forgetProtection(providerId, name, file = PROTECTION_FILE) {
+    const all = load(file);
+    if (!(key(providerId, name) in all))
+        return;
+    delete all[key(providerId, name)];
+    save(all, file);
+}
+/**
+ * The threshold warning for one profile, or null. Pure. Fires once per reset
+ * cycle of the window that crossed (`lastCycle` = what was announced before).
+ */
+export function protectionNotice(target, snap, policy, lastCycle) {
+    if (!policy.enabled)
+        return null;
+    const hit = snap.windows.find((w) => typeof w.utilization === "number" && w.utilization >= policy.thresholdPct);
+    if (!hit)
+        return null;
+    const cycle = `${hit.key}@${hit.resetsAt ?? ""}`;
+    if (cycle === lastCycle)
+        return null;
+    return {
+        cycle,
+        title: "Session protection: limit almost reached",
+        message: `${target} reached ${hit.utilization}% of its ${hit.label} limit (protection threshold ${policy.thresholdPct}%). ` +
+            `This is a warning only — agent-switch does not pause running sessions.`,
+    };
+}

package/dist/rebind.js

@@ -13,9 +13,10 @@
  *
  * Move-semantics + safety: the target account's credential is moved INTO the
  * running profile's store and the target's own store is emptied, so the family
- * is live in exactly one store. Both original credentials are stashed in a
- * per-profile binding-marker BEFORE any mutation, so `--restore` fully reverses
- * it and a crash leaves a recoverable marker. Nothing is deleted without a stash.
+ * is live in exactly one store. Both original credentials are stashed in the
+ * Keychain BEFORE any mutation and a per-profile binding-marker names those
+ * entries (never the tokens), so `--restore` fully reverses it and a crash
+ * leaves a recoverable marker. Nothing is deleted without a stash.
  *
  * Deferred to later Phase-2 slices (see road-to-live-rebind.md), not built here:
  * live pid/process auto-detection, a global cross-profile binding registry +
@@ -365,15 +366,30 @@ export function readBinding(cfgDir, d = defaultDeps()) {
         return null;
     try {
         const m = JSON.parse(raw);
-        if (m && typeof m.boundToProfile === "string" && typeof m.runningOwnCredential === "string" && typeof m.targetOrigCredential === "string") {
+        if (!m || typeof m.boundToProfile !== "string")
+            return null;
+        const stashed = typeof m.runningOwnStash === "string" && typeof m.targetOrigStash === "string";
+        const legacy = typeof m.runningOwnCredential === "string" && typeof m.targetOrigCredential === "string";
+        if (stashed || legacy)
             return m;
-        }
     }
     catch {
         /* corrupt marker → treat as none */
     }
     return null;
 }
+/** Keychain services that hold a binding's originals while the rebind is live. */
+function stashServices(pConfig, d) {
+    const base = d.serviceNameFor(pConfig);
+    return { own: `${base}-agent-switch-rebind-own`, target: `${base}-agent-switch-rebind-target` };
+}
+/** The two original credentials a binding needs for restore — from the Keychain
+ *  stash, or inline for a marker written before D16. Null when unreadable. */
+export function bindingCredentials(m, d = defaultDeps()) {
+    const runningOwn = m.runningOwnStash ? d.kcGet(m.runningOwnStash) : (m.runningOwnCredential ?? null);
+    const targetOrig = m.targetOrigStash ? d.kcGet(m.targetOrigStash) : (m.targetOrigCredential ?? null);
+    return runningOwn && targetOrig ? { runningOwn, targetOrig } : null;
+}
 export class RebindError extends Error {
 }
 /**
@@ -615,12 +631,21 @@ async function performRebind(opts, d) {
             // All guards passed — commit the global binding record.
             reg[account] = { runningProfile: profile, boundAt: new Date(d.now()).toISOString() };
             writeRegistry(reg, d);
-            // 1. Recovery point BEFORE any store mutation: stash both originals.
+            // 1. Recovery point BEFORE any store mutation: stash both originals in the
+            //    Keychain (never in the marker file), then point the marker at them.
+            const stash = stashServices(pConfig, d);
+            if (!d.kcAdd(stash.own, pCred) || !d.kcAdd(stash.target, credToMove)) {
+                d.kcDelete(stash.own);
+                d.kcDelete(stash.target);
+                delete reg[account];
+                writeRegistry(reg, d);
+                throw new RebindError(`could not stash the original credentials in the Keychain — no swap performed.`);
+            }
             const marker = {
                 boundToProfile: account,
                 boundAt: new Date(d.now()).toISOString(),
-                runningOwnCredential: pCred,
-                targetOrigCredential: credToMove,
+                runningOwnStash: stash.own,
+                targetOrigStash: stash.target,
                 targetFileMoved: false,
                 // Snapshot the running profile's OWN identity stamp before the swap: from
                 // here on Claude Code will overwrite it with the borrowed account's.
@@ -648,6 +673,57 @@ async function performRebind(opts, d) {
             `Restore with: agent-switch rebind --restore --profile ${profile}`,
     };
 }
+/**
+ * Drop an active rebind on `profile` WITHOUT restoring it — the `remove --force`
+ * path, where the running profile is about to be deleted. Deletes both Keychain
+ * stash entries (they would otherwise outlive the profile), releases the
+ * registry entry and the marker, and hands the borrowed account back to its own
+ * profile: the stashed original goes back into that store only while it is
+ * empty (a store that holds a login again is never overwritten), and a lent
+ * plaintext file is returned. Returns false when there was no rebind.
+ */
+export function discardBinding(profile, d = defaultDeps()) {
+    const pConfig = configDir("claude", profile);
+    const marker = readBinding(pConfig, d);
+    if (!marker)
+        return false;
+    const originals = bindingCredentials(marker, d);
+    const aConfig = configDir("claude", marker.boundToProfile);
+    const aSvc = d.serviceNameFor(aConfig);
+    if (originals && d.kcGet(aSvc) === null)
+        d.kcAdd(aSvc, originals.targetOrig);
+    const aFile = credFile(aConfig);
+    if (marker.targetFileMoved && d.exists(aFile + LENT_SUFFIX) && !d.exists(aFile))
+        d.renameFile(aFile + LENT_SUFFIX, aFile);
+    const stash = stashServices(pConfig, d);
+    d.kcDelete(marker.runningOwnStash ?? stash.own);
+    d.kcDelete(marker.targetOrigStash ?? stash.target);
+    const reg = readRegistry(d);
+    if (reg[marker.boundToProfile]?.runningProfile === profile) {
+        delete reg[marker.boundToProfile];
+        writeRegistry(reg, d);
+    }
+    d.removeFile(markerFile(pConfig));
+    return true;
+}
+/** The profile currently serving `account`'s login through a rebind, or null. */
+export function borrowerOf(account, d = defaultDeps()) {
+    return readRegistry(d)[account]?.runningProfile ?? null;
+}
+/**
+ * Before `account`'s profile is deleted (`remove --force`): put the profile
+ * borrowing it back on its own login through the normal restore path, so both
+ * stores stay consistent and the stash is cleared. Restore's provenance checks
+ * still apply — a refusal propagates and nothing is released. Returns the
+ * borrower that was restored, or null when nothing borrowed the account.
+ */
+export async function releaseBorrowedAccount(account, d = defaultDeps()) {
+    const holder = borrowerOf(account, d);
+    if (!holder)
+        return null;
+    await restoreRebind({ profile: holder }, d);
+    return holder;
+}
 /** Reverse an active rebind on `profile`: restore both profiles' own credentials. */
 export async function restoreRebind(opts, d = defaultDeps()) {
     const { profile } = opts;
@@ -658,6 +734,11 @@ export async function restoreRebind(opts, d = defaultDeps()) {
     const marker = readBinding(pConfig, d);
     if (!marker)
         throw new RebindRefused(`no active rebind on profile "${profile}".`);
+    const originals = bindingCredentials(marker, d);
+    if (!originals) {
+        throw new RebindRefused(`the stashed credentials for profile "${profile}"'s rebind are not readable — refusing restore (no mutation). ` +
+            `The binding marker is left in place for manual recovery.`);
+    }
     const aConfig = configDir("claude", marker.boundToProfile);
     const pSvc = d.serviceNameFor(pConfig);
     const aSvc = d.serviceNameFor(aConfig);
@@ -672,7 +753,7 @@ export async function restoreRebind(opts, d = defaultDeps()) {
             // account we bound INTO it. If someone re-logged the running profile, its
             // store now holds a DIFFERENT account — never clobber that fresh login.
             const liveRunning = readCred(pConfig, d);
-            const branch = await compareAccounts(marker.targetOrigCredential, liveRunning, d);
+            const branch = await compareAccounts(originals.targetOrig, liveRunning, d);
             if (branch === "unparseable") {
                 throw new RebindRefused(`running profile "${profile}"'s live credential is missing or unparseable — refusing restore (no mutation). ` +
                     `The binding marker is left in place for manual recovery.`);
@@ -691,11 +772,23 @@ export async function restoreRebind(opts, d = defaultDeps()) {
             }
             // "same" / "rotated" → the bound account is still there → restore normally.
             // Restore the running profile to its own account.
-            d.kcAdd(pSvc, marker.runningOwnCredential);
+            if (!d.kcAdd(pSvc, originals.runningOwn)) {
+                throw new RebindError(`could not write profile "${profile}"'s own credential back to the Keychain — restore aborted. ` +
+                    `Nothing was changed; the marker and the stashed credentials are kept — retry the restore.`);
+            }
             // Restore the target profile's own store. On "rotated" the live credential
             // is the same account with a FRESHER (rotated) refresh token — hand that
             // back instead of the stale stash, or the target profile logs out.
-            d.kcAdd(aSvc, branch === "rotated" ? liveRunning : marker.targetOrigCredential);
+            if (!d.kcAdd(aSvc, branch === "rotated" ? liveRunning : originals.targetOrig)) {
+                // Put the running store back on the bound account, so the provenance
+                // check of a retry still sees the account it was rebound to (otherwise
+                // the retry would read its own credential as a foreign re-login).
+                const rolledBack = d.kcAdd(pSvc, liveRunning);
+                throw new RebindError(`could not write "${marker.boundToProfile}"'s credential back to the Keychain — restore aborted. ` +
+                    (rolledBack
+                        ? `Profile "${profile}" still serves "${marker.boundToProfile}"; the marker and the stashed credentials are kept — retry the restore.`
+                        : `Profile "${profile}" could not be rolled back either; the marker and the stashed credentials are kept for manual recovery.`));
+            }
             if (marker.targetFileMoved && d.exists(aFile + LENT_SUFFIX)) {
                 d.renameFile(aFile + LENT_SUFFIX, aFile);
             }
@@ -703,6 +796,10 @@ export async function restoreRebind(opts, d = defaultDeps()) {
             // Claude Code stamped into its `.claude.json` while it served the other account.
             await restoreStampedIdentity(pConfig, marker.runningOwnIdentity, d);
             d.removeFile(markerFile(pConfig));
+            if (marker.runningOwnStash)
+                d.kcDelete(marker.runningOwnStash);
+            if (marker.targetOrigStash)
+                d.kcDelete(marker.targetOrigStash);
             // Release the global binding-registry entry for the bound account.
             const reg = readRegistry(d);
             if (reg[marker.boundToProfile]) {