shariq-pi-extensions 0.2.23 → 0.2.25

package/docs/EXTENSIONS.md

@@ -36,7 +36,7 @@ The goal extension adds persistent, branch-safe objectives, progress evidence, b
 
 ### [Task List](../extensions/task-list/README.md)
 
-`task_list` gives the active model a branch-safe ordered checklist for ordinary multi-step work; it is separate from persistent Goals and may be used alongside them. Writes replace the full list, retain stable IDs, support pending/in-progress/completed/blocked/cancelled states and priorities, and require an active item while pending work remains. The prompt contract requires same-message list/action calls and immediate verified status updates. Runtime reminders catch missing or stale bookkeeping, with at most one same-model follow-up if an active list is still stale when Pi settles.
+`task_list` gives the active model a branch-safe ordered checklist for ordinary multi-step work; it is separate from persistent Goals and may be used alongside them. Writes replace the full list, retain stable IDs, support pending/in-progress/completed/blocked/cancelled states and priorities, and require an active item while pending work remains. The prompt contract requires same-message list/action calls and verified updates only at task-level transitions—not after routine file reads, edits, commands, or other tool calls. A runtime reminder catches multi-action work that starts without a list; final reconciliation catches unfinished bookkeeping.
 
 State is stored in Pi session entries and reconstructed on resume, reload, and tree navigation. Active work is re-injected when compaction removes the latest snapshot from model context. `/tasks` opens the interactive dashboard and direct editor; the compact live widget auto-hides after all work finishes. Subagents receive the same tool under every capability policy, but each child maintains its own session-local list rather than changing the parent's list.
 

package/extensions/antigravity-provider/README.md

@@ -10,7 +10,7 @@ Local persistent Pi provider for Google Antigravity-compatible models.
 
 The provider includes an IPv4 OAuth token-exchange fallback for Node environments where the default request fails. Its curated catalog follows current Antigravity model identifiers and runtime behavior.
 
-Successful logins are added to `<agent-dir>/antigravity/accounts.json`, written with owner-only permissions. Existing Pi OAuth credentials are migrated into that pool without exposing token values. Requests select the least recently used eligible account, skip disabled/cooling/exhausted accounts, refresh expiring OAuth tokens, and rotate to another account when an auth, rate, quota, or capacity failure occurs before response streaming begins. Cached per-model remaining quota and reset times guide selection; `/antigravity` refreshes the authoritative catalog and can reversibly enable or disable accounts.
+Successful logins are added to `<agent-dir>/antigravity/accounts.json`, written with owner-only permissions. A missing account file triggers one-time migration of an existing Pi OAuth credential; after that, the valid account file is authoritative, so removing an account cannot be undone by a stale credential in `auth.json`. Requests select the least recently used eligible account, skip disabled/cooling/exhausted accounts, refresh expiring OAuth tokens, and rotate to another account when an auth, rate, quota, or capacity failure occurs before response streaming begins. Cached per-model remaining quota and reset times guide selection; `/antigravity` refreshes the authoritative catalog, uses `d` to reversibly enable or disable an account, and uses `x` plus confirmation to remove one permanently.
 
 Current public model IDs:
 - `antigravity/gemini-3.7-flash`

package/extensions/antigravity-provider/antigravity/accounts.ts

@@ -48,6 +48,22 @@ interface AntigravityAccountFile {
   accounts: AntigravityAccount[];
 }
 
+export type AntigravityAccountStore = {
+  status: "missing" | "invalid" | "valid";
+  accounts: AntigravityAccount[];
+};
+
+export type AntigravityStoredCredential = Pick<OAuthCredentials, "refresh" | "access" | "expires"> & {
+  projectId?: string;
+  email?: string;
+};
+
+export type AntigravityCredentialReconciliation =
+  | { action: "none" }
+  | { action: "migrate"; credentials: AntigravityStoredCredential }
+  | { action: "replace"; account: AntigravityAccount }
+  | { action: "delete" };
+
 export interface AntigravityAccountStatus extends AntigravityAccount {
   active: boolean;
 }
@@ -105,17 +121,40 @@ function normalizeAccount(value: unknown): AntigravityAccount | undefined {
   };
 }
 
-export function loadAntigravityAccounts(): AntigravityAccount[] {
+export function inspectAntigravityAccountStore(): AntigravityAccountStore {
   try {
     const parsed = JSON.parse(fs.readFileSync(ANTIGRAVITY_ACCOUNTS_PATH, "utf8")) as Partial<AntigravityAccountFile>;
-    return Array.isArray(parsed.accounts)
-      ? parsed.accounts.map(normalizeAccount).filter((account): account is AntigravityAccount => Boolean(account))
-      : [];
-  } catch {
-    return [];
+    if (!Array.isArray(parsed.accounts)) return { status: "invalid", accounts: [] };
+    return {
+      status: "valid",
+      accounts: parsed.accounts.map(normalizeAccount).filter((account): account is AntigravityAccount => Boolean(account)),
+    };
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? (error as { code?: unknown }).code : undefined;
+    return { status: code === "ENOENT" ? "missing" : "invalid", accounts: [] };
   }
 }
 
+export function loadAntigravityAccounts(): AntigravityAccount[] {
+  return inspectAntigravityAccountStore().accounts;
+}
+
+function matchesStoredCredential(account: AntigravityAccount, credentials: AntigravityStoredCredential) {
+  return account.refresh === credentials.refresh || Boolean(account.email && credentials.email && account.email === credentials.email);
+}
+
+export function reconcileAntigravityStoredCredential(
+  store: AntigravityAccountStore,
+  credentials: AntigravityStoredCredential | undefined,
+): AntigravityCredentialReconciliation {
+  if (store.status === "invalid") return { action: "none" };
+  if (store.status === "missing") return credentials ? { action: "migrate", credentials } : { action: "none" };
+  if (credentials && store.accounts.some((account) => matchesStoredCredential(account, credentials))) return { action: "none" };
+  const replacement = store.accounts.find((account) => !account.disabled) ?? store.accounts[0];
+  if (replacement) return { action: "replace", account: replacement };
+  return credentials ? { action: "delete" } : { action: "none" };
+}
+
 function saveAntigravityAccounts(accounts: AntigravityAccount[]) {
   fs.mkdirSync(ANTIGRAVITY_STATE_DIR, { recursive: true, mode: 0o700 });
   fs.chmodSync(ANTIGRAVITY_STATE_DIR, 0o700);

package/extensions/antigravity-provider/antigravity/dashboard.ts

@@ -78,6 +78,7 @@ export class AntigravityDashboard implements Component {
   private snapshot: AntigravityDashboardSnapshot;
   private readonly refreshData: (force: boolean) => Promise<AntigravityDashboardSnapshot>;
   private readonly toggleAccount: (id: string, enabled: boolean) => Promise<AntigravityDashboardSnapshot>;
+  private readonly removeAccount: (id: string, label: string) => Promise<AntigravityDashboardSnapshot>;
   private readonly done: () => void;
 
   constructor(
@@ -87,6 +88,7 @@ export class AntigravityDashboard implements Component {
     snapshot: AntigravityDashboardSnapshot,
     refreshData: (force: boolean) => Promise<AntigravityDashboardSnapshot>,
     toggleAccount: (id: string, enabled: boolean) => Promise<AntigravityDashboardSnapshot>,
+    removeAccount: (id: string, label: string) => Promise<AntigravityDashboardSnapshot>,
     done: () => void,
   ) {
     this.tui = tui;
@@ -95,6 +97,7 @@ export class AntigravityDashboard implements Component {
     this.snapshot = snapshot;
     this.refreshData = refreshData;
     this.toggleAccount = toggleAccount;
+    this.removeAccount = removeAccount;
     this.done = done;
   }
 
@@ -139,10 +142,13 @@ export class AntigravityDashboard implements Component {
       if (accounts.length) this.selected = (this.selected + 1) % accounts.length;
     } else if (data === "r") {
       this.startRefresh(true);
-    } else if (data === "d" && accounts[this.selected] && !this.refreshing) {
+    } else if ((data === "d" || data === "x") && accounts[this.selected] && !this.refreshing) {
       const account = accounts[this.selected]!;
       this.refreshing = true;
-      void this.toggleAccount(account.id, account.disabled === true)
+      const action = data === "x"
+        ? this.removeAccount(account.id, account.email || `account-${account.id.slice(0, 6)}`)
+        : this.toggleAccount(account.id, account.disabled === true);
+      void action
         .then((snapshot) => this.replaceSnapshot(snapshot))
         .catch((error) => {
           if (!this.closed) this.snapshot = { ...this.snapshot, warning: error instanceof Error ? error.message : String(error) };
@@ -188,7 +194,7 @@ export class AntigravityDashboard implements Component {
       for (let row = 0; row < bodyHeight; row++) lines.push(this.theme.fg("border", "│") + padLine(list[row] ?? "", inner) + this.theme.fg("border", "│"));
     }
     lines.push(frameBottom(this.theme, width));
-    lines.push(truncateToWidth(`${this.theme.fg("accent", "  ↑↓ / j k")} ${this.theme.fg("dim", "select")}  ${this.theme.fg("accent", "r")} ${this.theme.fg("dim", "refresh")}  ${this.theme.fg("accent", "d")} ${this.theme.fg("dim", "enable/disable")}  ${this.theme.fg("accent", "esc")} ${this.theme.fg("dim", "close")}`, width, ""));
+    lines.push(truncateToWidth(`${this.theme.fg("accent", "  ↑↓ / j k")} ${this.theme.fg("dim", "select")}  ${this.theme.fg("accent", "r")} ${this.theme.fg("dim", "refresh")}  ${this.theme.fg("accent", "d")} ${this.theme.fg("dim", "enable/disable")}  ${this.theme.fg("accent", "x")} ${this.theme.fg("dim", "remove")}  ${this.theme.fg("accent", "esc")} ${this.theme.fg("dim", "close")}`, width, ""));
     return lines.map((line) => truncateToWidth(line, width, ""));
   }
 
@@ -250,10 +256,11 @@ export async function openAntigravityDashboard(
   initial: AntigravityDashboardSnapshot,
   refresh: (force: boolean) => Promise<AntigravityDashboardSnapshot>,
   toggle: (id: string, enabled: boolean) => Promise<AntigravityDashboardSnapshot>,
+  remove: (id: string, label: string) => Promise<AntigravityDashboardSnapshot>,
 ) {
   await ctx.ui.custom<void>(
     (tui, theme, keys, done) => {
-      const dashboard = new AntigravityDashboard(tui, theme, keys, initial, refresh, toggle, () => done(undefined));
+      const dashboard = new AntigravityDashboard(tui, theme, keys, initial, refresh, toggle, remove, () => done(undefined));
       queueMicrotask(() => dashboard.startRefresh(false));
       return dashboard;
     },

package/extensions/antigravity-provider/antigravity/index.ts

@@ -24,8 +24,12 @@ import {
 import { streamAntigravity } from "./cloud-code-assist.ts";
 import {
 	antigravityAccountStatuses,
+	inspectAntigravityAccountStore,
+	reconcileAntigravityStoredCredential,
+	removeAntigravityAccount,
 	setAntigravityAccountEnabled,
 	upsertAntigravityAccount,
+	type AntigravityStoredCredential,
 } from "./accounts.ts";
 import { refreshAntigravityQuotas } from "./quotas.ts";
 import {
@@ -43,19 +47,43 @@ export default function antigravityProviderExtension(pi: ExtensionAPI) {
 		};
 	};
 
-	const migrateStoredCredential = () => {
+	const readOAuthCredential = (): AntigravityStoredCredential | undefined => {
+		const credential = readStoredCredential(PROVIDER_ID) as any;
+		if (credential?.type !== "oauth" || typeof credential.refresh !== "string" || typeof credential.access !== "string") return undefined;
+		return {
+			refresh: credential.refresh,
+			access: credential.access,
+			expires: typeof credential.expires === "number" ? credential.expires : 0,
+			projectId: typeof credential.projectId === "string" ? credential.projectId : undefined,
+			email: typeof credential.email === "string" ? credential.email : undefined,
+		};
+	};
+
+	const reconcileStoredCredential = async (ctx?: ExtensionContext) => {
 		try {
-			const credential = readStoredCredential(PROVIDER_ID) as any;
-			if (credential?.type !== "oauth" || typeof credential.refresh !== "string" || typeof credential.access !== "string") return;
-			upsertAntigravityAccount({
-				refresh: credential.refresh,
-				access: credential.access,
-				expires: typeof credential.expires === "number" ? credential.expires : 0,
-				projectId: typeof credential.projectId === "string" ? credential.projectId : undefined,
-				email: typeof credential.email === "string" ? credential.email : undefined,
-			});
+			const credentials = readOAuthCredential();
+			const reconciliation = reconcileAntigravityStoredCredential(inspectAntigravityAccountStore(), credentials);
+			if (reconciliation.action === "migrate") {
+				upsertAntigravityAccount(reconciliation.credentials);
+				return;
+			}
+			const authStorage = (ctx?.modelRegistry as any)?.authStorage;
+			if (!authStorage) return;
+			if (reconciliation.action === "replace") {
+				const account = reconciliation.account;
+				await authStorage.modify(PROVIDER_ID, async () => ({
+					type: "oauth",
+					refresh: account.refresh,
+					access: account.access,
+					expires: account.expires,
+					projectId: account.projectId,
+					email: account.email,
+				}));
+			} else if (reconciliation.action === "delete") {
+				await authStorage.delete(PROVIDER_ID);
+			}
 		} catch {
-			// A malformed or unavailable Pi credential must not block extension startup.
+			// Malformed or unavailable credential state must not block extension startup.
 		}
 	};
 
@@ -67,9 +95,9 @@ export default function antigravityProviderExtension(pi: ExtensionAPI) {
 		oauth: {
 			name: PROVIDER_NAME,
 			login: ((callbacks: Parameters<typeof loginAntigravity>[0]) => {
-				// Pi replaces its single stored provider credential after login. Archive
-				// the current account first so signing into another account cannot lose it.
-				migrateStoredCredential();
+				// A missing account store is a legacy installation, so archive Pi's single
+				// credential before login. A valid store remains authoritative after edits.
+				void reconcileStoredCredential();
 				return loginAntigravity(callbacks);
 			}) as any,
 			refreshToken: refreshAntigravityToken as any,
@@ -78,9 +106,9 @@ export default function antigravityProviderExtension(pi: ExtensionAPI) {
 		streamSimple: streamAntigravity,
 	} as any);
 
-	pi.on("session_start", (_event, ctx) => {
+	pi.on("session_start", async (_event, ctx) => {
 		(ctx.modelRegistry as any).authStorage?.reload?.();
-		migrateStoredCredential();
+		await reconcileStoredCredential(ctx);
 		void refreshAntigravityQuotas({ signal: ctx.signal }).catch(() => {
 			// Cached quota state remains available; /antigravity reports refresh failures.
 		});
@@ -94,7 +122,7 @@ export default function antigravityProviderExtension(pi: ExtensionAPI) {
 	pi.registerCommand("antigravity", {
 		description: "Open Antigravity accounts, rotation, and quota dashboard",
 		handler: async (_args, ctx) => {
-			migrateStoredCredential();
+			await reconcileStoredCredential(ctx);
 			await openAntigravityDashboard(
 				ctx,
 				dashboardSnapshot(ctx),
@@ -107,6 +135,13 @@ export default function antigravityProviderExtension(pi: ExtensionAPI) {
 					if (enabled) await refreshAntigravityQuotas({ force: true, signal: ctx.signal });
 					return dashboardSnapshot(ctx);
 				},
+				async (id, label) => {
+					const confirmed = await ctx.ui.confirm("Remove Antigravity account?", `Permanently remove ${label} from this Pi installation?`);
+					if (!confirmed) return dashboardSnapshot(ctx);
+					removeAntigravityAccount(id);
+					await reconcileStoredCredential(ctx);
+					return dashboardSnapshot(ctx);
+				},
 			);
 		},
 	});

package/extensions/factory-provider/API_KEYS.md

@@ -14,4 +14,4 @@ Alternatively choose Pi's top-level **Use an API key** authentication method to
 
 Use `/logout` to remove the active Factory authentication selection. The configured key file is intentionally not deleted by logout.
 
-Open `/factory` to inspect every account, its Standard/Core usage, and rotation status. For a smoke test, use the current `factory/kimi-k3` model.
+Open `/factory` to inspect every account, its Standard/Core usage, and rotation status. File-backed keys remain visible when disabled: select one and press `d` to enable/disable it, or press `x` and confirm to remove it permanently from `api-keys.json`. Environment-provided keys are read-only. For a smoke test, use the current `factory/kimi-k3` model.

package/extensions/factory-provider/README.md

@@ -59,7 +59,7 @@ There are no `-oauth` or `-api-key` model duplicates. The user-curated catalog e
 /factory
 ```
 
-`/factory` opens a full-width account dashboard combining provider status, authentication, Droid/model metadata, rotation cooldowns, and separate Standard and Droid Core usage for every credential. Percentages are explicitly labeled as **used**. Navigate with the arrow keys or `j`/`k`, press `r` to force-refresh every account, and press Escape to close.
+`/factory` opens a full-width account dashboard combining provider status, authentication, Droid/model metadata, rotation cooldowns, and separate Standard and Droid Core usage for every credential. Percentages are explicitly labeled as **used**. Navigate with the arrow keys or `j`/`k`, press `r` to force-refresh every account, use `d` to reversibly enable or disable a rotating file-backed key, use `x` plus confirmation to remove one permanently, and press Escape to close. Environment variables and single credentials managed by Pi auth remain read-only in this dashboard.
 
 Usage is never estimated from Pi token counts: Factory's API already applies model multipliers and cache-hit discounts. Cached records refresh at most every 15 minutes during normal sessions and after Factory runs; the manual command is the explicit force-refresh path.
 

package/extensions/factory-provider/factory/api-keys.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { existsSync, readFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { createAssistantMessageEventStream } from "@earendil-works/pi-ai";
 import { FACTORY_API_BASE_URL, FACTORY_STATE_DIR } from "./constants.ts";
@@ -25,6 +25,10 @@ export type FactoryApiKeyEntry = {
   disabled?: boolean;
 };
 
+type FactoryApiKeySourceEntry = FactoryApiKeyEntry & {
+  source: "environment" | "file";
+};
+
 type FactoryApiKeyConfig = {
   keys?: Array<string | Partial<FactoryApiKeyEntry>>;
 };
@@ -69,19 +73,19 @@ export function parseFactoryApiKeyFile(raw: string): { entries: FactoryApiKeyEnt
   }
 }
 
-export function loadFactoryApiKeys(): FactoryApiKeyEntry[] {
-  const entries: FactoryApiKeyEntry[] = [];
+function configuredFactoryApiKeys(): FactoryApiKeySourceEntry[] {
+  const entries: FactoryApiKeySourceEntry[] = [];
   const envKeys = (process.env.FACTORY_API_KEYS || process.env.FACTORY_API_KEY || "")
     .split(/[\n,]+/)
     .map((key) => key.trim())
     .filter(Boolean);
-  envKeys.forEach((key, index) => entries.push({ label: `env-${index + 1}`, key }));
+  envKeys.forEach((key, index) => entries.push({ label: `env-${index + 1}`, key, source: "environment" }));
 
   lastConfigurationWarning = undefined;
   if (existsSync(FACTORY_API_KEYS_PATH)) {
     try {
       const parsed = parseFactoryApiKeyFile(readFileSync(FACTORY_API_KEYS_PATH, "utf8"));
-      entries.push(...parsed.entries);
+      entries.push(...parsed.entries.map((entry) => ({ ...entry, source: "file" as const })));
       lastConfigurationWarning = parsed.warning;
     } catch {
       lastConfigurationWarning = "Factory rotating-key configuration could not be read.";
@@ -90,13 +94,63 @@ export function loadFactoryApiKeys(): FactoryApiKeyEntry[] {
 
   const seen = new Set<string>();
   return entries.filter((entry) => {
-    if (entry.disabled) return false;
     if (seen.has(entry.key)) return false;
     seen.add(entry.key);
     return true;
   });
 }
 
+export function loadFactoryApiKeys(): FactoryApiKeyEntry[] {
+  return configuredFactoryApiKeys().filter((entry) => !entry.disabled);
+}
+
+function editableFactoryApiKeyEntries(): FactoryApiKeyEntry[] {
+  if (!existsSync(FACTORY_API_KEYS_PATH)) return [];
+  const parsed = parseFactoryApiKeyFile(readFileSync(FACTORY_API_KEYS_PATH, "utf8"));
+  if (parsed.warning) throw new Error(parsed.warning);
+  return parsed.entries;
+}
+
+function saveFactoryApiKeyEntries(entries: FactoryApiKeyEntry[]) {
+  mkdirSync(FACTORY_STATE_DIR, { recursive: true, mode: 0o700 });
+  chmodSync(FACTORY_STATE_DIR, 0o700);
+  const temporary = `${FACTORY_API_KEYS_PATH}.${process.pid}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify({ keys: entries }, null, 2)}\n`, { mode: 0o600 });
+  renameSync(temporary, FACTORY_API_KEYS_PATH);
+  chmodSync(FACTORY_API_KEYS_PATH, 0o600);
+}
+
+export function updateFactoryApiKeyEntries(
+  entries: FactoryApiKeyEntry[],
+  id: string,
+  action: { kind: "enabled"; enabled: boolean } | { kind: "remove" },
+) {
+  let changed = false;
+  const next = entries.flatMap((entry): FactoryApiKeyEntry[] => {
+    if (keyId(entry) !== id) return [entry];
+    changed = true;
+    if (action.kind === "remove") return [];
+    return [{ ...entry, disabled: !action.enabled }];
+  });
+  return { entries: next, changed };
+}
+
+export function setFactoryApiKeyEnabled(id: string, enabled: boolean) {
+  const result = updateFactoryApiKeyEntries(editableFactoryApiKeyEntries(), id, { kind: "enabled", enabled });
+  if (!result.changed) return false;
+  saveFactoryApiKeyEntries(result.entries);
+  return true;
+}
+
+export function removeFactoryApiKey(id: string) {
+  const result = updateFactoryApiKeyEntries(editableFactoryApiKeyEntries(), id, { kind: "remove" });
+  if (!result.changed) return false;
+  saveFactoryApiKeyEntries(result.entries);
+  state.delete(id);
+  organizationIdCache.delete(id);
+  return true;
+}
+
 export function sortFactoryApiKeysByLastUsed(
   entries: FactoryApiKeyEntry[],
   lastUsed = (entry: FactoryApiKeyEntry) => state.get(keyId(entry))?.lastUsedAt,
@@ -395,7 +449,7 @@ export function streamSimpleUnifiedFactoryResponses(model: any, context: any, op
 }
 
 export function factoryApiKeyStatus() {
-  const keys = loadFactoryApiKeys();
+  const keys = configuredFactoryApiKeys();
   const now = Date.now();
   return {
     configured: keys.length,
@@ -408,6 +462,8 @@ export function factoryApiKeyStatus() {
         id: keyId(entry),
         label: entry.label,
         key: maskKey(entry.key),
+        disabled: Boolean(entry.disabled),
+        editable: entry.source === "file",
         cooldownSeconds: runtime?.cooldownUntil && runtime.cooldownUntil > now ? Math.ceil((runtime.cooldownUntil - now) / 1000) : 0,
         lastError: runtime?.lastError ? runtime.lastError.slice(0, 200) : undefined,
         lastUsedAt: runtime?.lastUsedAt ? new Date(runtime.lastUsedAt).toISOString() : undefined,

package/extensions/factory-provider/factory/dashboard.ts

@@ -26,6 +26,8 @@ import { factoryWarmTheme } from "./warm-theme.ts";
 export interface FactoryDashboardAccount {
   id: string;
   label: string;
+  disabled?: boolean;
+  editable?: boolean;
   record?: FactoryLimitRecord;
   cooldownSeconds?: number;
   lastUsedAt?: string;
@@ -96,6 +98,7 @@ function compactPool(
 }
 
 function accountState(account: FactoryDashboardAccount) {
+  if (account.disabled) return "disabled";
   if (account.cooldownSeconds && account.cooldownSeconds > 0) return "cooldown";
   if (account.record?.error) return "refresh error";
   const observedAt = account.record?.fetchedAt ?? Date.now();
@@ -122,6 +125,8 @@ export class FactoryDashboard implements Component {
   private readonly keys: KeybindingsManager;
   private snapshot: FactoryDashboardSnapshot;
   private readonly refreshData: (force: boolean) => Promise<FactoryDashboardSnapshot>;
+  private readonly toggleAccount: (id: string, enabled: boolean) => Promise<FactoryDashboardSnapshot>;
+  private readonly removeAccount: (id: string, label: string) => Promise<FactoryDashboardSnapshot>;
   private readonly done: () => void;
 
   constructor(
@@ -130,6 +135,8 @@ export class FactoryDashboard implements Component {
     keys: KeybindingsManager,
     snapshot: FactoryDashboardSnapshot,
     refreshData: (force: boolean) => Promise<FactoryDashboardSnapshot>,
+    toggleAccount: (id: string, enabled: boolean) => Promise<FactoryDashboardSnapshot>,
+    removeAccount: (id: string, label: string) => Promise<FactoryDashboardSnapshot>,
     done: () => void,
   ) {
     this.tui = tui;
@@ -137,6 +144,8 @@ export class FactoryDashboard implements Component {
     this.keys = keys;
     this.snapshot = snapshot;
     this.refreshData = refreshData;
+    this.toggleAccount = toggleAccount;
+    this.removeAccount = removeAccount;
     this.done = done;
   }
 
@@ -145,17 +154,7 @@ export class FactoryDashboard implements Component {
     this.refreshing = true;
     this.tui.requestRender();
     void this.refreshData(force)
-      .then((snapshot) => {
-        if (this.closed) return;
-        const selectedId = this.snapshot.accounts[this.selected]?.id;
-        this.snapshot = snapshot;
-        const nextIndex = selectedId
-          ? snapshot.accounts.findIndex((account) => account.id === selectedId)
-          : -1;
-        this.selected = nextIndex >= 0
-          ? nextIndex
-          : Math.min(this.selected, Math.max(0, snapshot.accounts.length - 1));
-      })
+      .then((snapshot) => this.replaceSnapshot(snapshot))
       .catch((error) => {
         if (this.closed) return;
         this.snapshot = {
@@ -170,6 +169,18 @@ export class FactoryDashboard implements Component {
       });
   }
 
+  private replaceSnapshot(snapshot: FactoryDashboardSnapshot) {
+    if (this.closed) return;
+    const selectedId = this.snapshot.accounts[this.selected]?.id;
+    this.snapshot = snapshot;
+    const nextIndex = selectedId
+      ? snapshot.accounts.findIndex((account) => account.id === selectedId)
+      : -1;
+    this.selected = nextIndex >= 0
+      ? nextIndex
+      : Math.min(this.selected, Math.max(0, snapshot.accounts.length - 1));
+  }
+
   dispose() {
     this.closed = true;
   }
@@ -191,6 +202,23 @@ export class FactoryDashboard implements Component {
       if (accounts.length) this.selected = (this.selected + 1) % accounts.length;
     } else if (data === "r") {
       this.startRefresh(true);
+    } else if ((data === "d" || data === "x") && accounts[this.selected]?.editable && !this.refreshing) {
+      const account = accounts[this.selected]!;
+      this.refreshing = true;
+      const action = data === "x"
+        ? this.removeAccount(account.id, account.label)
+        : this.toggleAccount(account.id, account.disabled === true);
+      void action
+        .then((snapshot) => this.replaceSnapshot(snapshot))
+        .catch((error) => {
+          if (!this.closed) this.snapshot = { ...this.snapshot, warning: error instanceof Error ? error.message : String(error) };
+        })
+        .finally(() => {
+          if (!this.closed) {
+            this.refreshing = false;
+            this.tui.requestRender();
+          }
+        });
     }
     this.tui.requestRender();
   }
@@ -242,7 +270,7 @@ export class FactoryDashboard implements Component {
     lines.push(frameBottom(this.theme, width));
     lines.push(
       truncateToWidth(
-        `${this.theme.fg("accent", "  ↑↓ / j k")} ${this.theme.fg("dim", "select")}  ${this.theme.fg("accent", "r")} ${this.theme.fg("dim", "refresh all")}  ${this.theme.fg("accent", "esc")} ${this.theme.fg("dim", "close")}`,
+        `${this.theme.fg("accent", "  ↑↓ / j k")} ${this.theme.fg("dim", "select")}  ${this.theme.fg("accent", "r")} ${this.theme.fg("dim", "refresh all")}  ${this.theme.fg("accent", "d")} ${this.theme.fg("dim", "enable/disable")}  ${this.theme.fg("accent", "x")} ${this.theme.fg("dim", "remove")}  ${this.theme.fg("accent", "esc")} ${this.theme.fg("dim", "close")}`,
         width,
         "",
       ),
@@ -341,6 +369,8 @@ export async function openFactoryDashboard(
   ctx: ExtensionContext,
   initial: FactoryDashboardSnapshot,
   refresh: (force: boolean) => Promise<FactoryDashboardSnapshot>,
+  toggle: (id: string, enabled: boolean) => Promise<FactoryDashboardSnapshot>,
+  remove: (id: string, label: string) => Promise<FactoryDashboardSnapshot>,
 ) {
   await ctx.ui.custom<void>(
     (tui, theme, keys, done) => {
@@ -350,6 +380,8 @@ export async function openFactoryDashboard(
         keys,
         initial,
         refresh,
+        toggle,
+        remove,
         () => done(undefined),
       );
       queueMicrotask(() => dashboard.startRefresh(false));

package/extensions/factory-provider/index.ts

@@ -11,6 +11,8 @@ import {
   FACTORY_API_KEY_FILE_SENTINEL,
   factoryApiKeyStatus,
   loadFactoryApiKeys,
+  removeFactoryApiKey,
+  setFactoryApiKeyEnabled,
   streamSimpleUnifiedFactoryResponses,
 } from "./factory/api-keys.ts";
 import {
@@ -88,21 +90,35 @@ export default async function factoryExtension(pi: ExtensionAPI) {
     ctx: ExtensionContext,
   ): Promise<FactoryDashboardSnapshot> => {
     const credentials = await limitCredentials(ctx);
+    const resolved = await ctx.modelRegistry.getProviderAuth(PROVIDER_ID);
+    const fileBacked = resolved?.auth.apiKey?.trim() === FACTORY_API_KEY_FILE_SENTINEL;
     const auth = ctx.modelRegistry.getProviderAuthStatus(PROVIDER_ID);
     const apiKeys = factoryApiKeyStatus();
     const cache = loadFactoryLimitCache();
     const runtimeById = new Map(apiKeys.keys.map((key) => [key.id, key]));
-    const accounts = credentials.map((credential) => {
-      const id = factoryCredentialId(credential.secret);
-      const runtime = runtimeById.get(id);
-      return {
-        id,
-        label: credential.label,
-        record: cache.records.find((record) => record.id === id),
-        cooldownSeconds: runtime?.cooldownSeconds,
-        lastUsedAt: runtime?.lastUsedAt,
-      };
-    });
+    const accounts = fileBacked
+      ? apiKeys.keys.map((key) => ({
+          id: key.id,
+          label: key.label,
+          disabled: key.disabled,
+          editable: key.editable,
+          record: cache.records.find((record) => record.id === key.id),
+          cooldownSeconds: key.cooldownSeconds,
+          lastUsedAt: key.lastUsedAt,
+        }))
+      : credentials.map((credential) => {
+          const id = factoryCredentialId(credential.secret);
+          const runtime = runtimeById.get(id);
+          return {
+            id,
+            label: credential.label,
+            disabled: false,
+            editable: false,
+            record: cache.records.find((record) => record.id === id),
+            cooldownSeconds: runtime?.cooldownSeconds,
+            lastUsedAt: runtime?.lastUsedAt,
+          };
+        });
     return {
       version: clientVersion,
       modelCount: models.length,
@@ -110,7 +126,7 @@ export default async function factoryExtension(pi: ExtensionAPI) {
         ? auth.label || auth.source || "configured"
         : "not configured",
       configured: accounts.length,
-      active: accounts.filter((account) => !account.cooldownSeconds).length,
+      active: accounts.filter((account) => !account.disabled && !account.cooldownSeconds).length,
       warning: apiKeys.warning,
       accounts,
     };
@@ -195,10 +211,25 @@ export default async function factoryExtension(pi: ExtensionAPI) {
     description: "Open Factory account, rotation, and usage dashboard",
     handler: async (_args, ctx) => {
       const initial = await dashboardSnapshot(ctx);
-      await openFactoryDashboard(ctx, initial, async (force) => {
-        await refreshLimits(ctx, force);
-        return dashboardSnapshot(ctx);
-      });
+      await openFactoryDashboard(
+        ctx,
+        initial,
+        async (force) => {
+          await refreshLimits(ctx, force);
+          return dashboardSnapshot(ctx);
+        },
+        async (id, enabled) => {
+          if (!setFactoryApiKeyEnabled(id, enabled)) throw new Error("This Factory credential is not editable from the rotating-key file.");
+          if (enabled) await refreshLimits(ctx, true);
+          return dashboardSnapshot(ctx);
+        },
+        async (id, label) => {
+          const confirmed = await ctx.ui.confirm("Remove Factory account?", `Permanently remove ${label} from the rotating-key file?`);
+          if (!confirmed) return dashboardSnapshot(ctx);
+          if (!removeFactoryApiKey(id)) throw new Error("This Factory credential is not editable from the rotating-key file.");
+          return dashboardSnapshot(ctx);
+        },
+      );
     },
   });
 }

package/extensions/task-list/README.md

@@ -38,8 +38,8 @@ The tool definition and Pi prompt guidance explicitly require the model to:
 The runtime reinforces these instructions without assigning the list to another worker:
 
 - after two substantive tool calls with no list, the next model context receives a conditional reminder;
-- after substantive work makes an active list stale, the next model context asks for an immediate update paired with the next action;
-- if the model still stops with a stale active list, Pi starts at most one follow-up model turn so the same model can update it and continue or finish;
+- routine file reads, edits, commands, and tool calls do not trigger bookkeeping updates while the current task remains active;
+- the model updates only for task-level transitions: verified completion and handoff to the next task, genuine blockers or cancellations, user-requested scope changes, and final reconciliation;
 - status-only inspection tools do not count as substantive progress.
 
 The list remains a coordination aid, not evidence that implementation or verification succeeded.

package/extensions/task-list/index.ts

@@ -97,13 +97,8 @@ export default function taskListExtension(pi: ExtensionAPI) {
   let state = emptyTaskListState();
   let lastCtx: ExtensionContext | null = null;
   let finishedTimer: ReturnType<typeof setTimeout> | undefined;
-  let sequence = 0;
-  let lastTaskSequence = 0;
-  let lastWorkSequence = 0;
   let workCallsSinceUser = 0;
   let taskCallsSinceUser = 0;
-  let nudgeCount = 0;
-  let staleAtAgentEnd = false;
 
   function cancelFinishedTimer(): void {
     if (!finishedTimer) return;
@@ -207,9 +202,6 @@ export default function taskListExtension(pi: ExtensionAPI) {
   }
 
   function reminderText(): string | null {
-    if (hasActiveTasks(state) && lastWorkSequence > lastTaskSequence) {
-      return "The task list is stale after substantive work. Before more narration, call task_list with the complete updated list: mark finished work completed only if verified, keep current work in_progress, and pair the update with the next action tool when work remains.";
-    }
     if (state.tasks.length === 0 && taskCallsSinceUser === 0 && workCallsSinceUser >= 2) {
       return "You have started multi-action work without task_list. If this request requires at least three distinct actions or contains multiple user tasks, create the complete list now and call task_list in the same assistant message as the next action. Do not create a retroactive list if the work is already complete or was genuinely trivial.";
     }
@@ -220,21 +212,13 @@ export default function taskListExtension(pi: ExtensionAPI) {
     if (event.source === "extension") return;
     workCallsSinceUser = 0;
     taskCallsSinceUser = 0;
-    lastTaskSequence = 0;
-    lastWorkSequence = 0;
-    staleAtAgentEnd = false;
-    nudgeCount = 0;
   });
 
   pi.on("session_start", async (_event, ctx) => {
     lastCtx = ctx;
     state = restoreTaskList(ctx);
-    sequence = 0;
-    lastTaskSequence = 0;
-    lastWorkSequence = 0;
     workCallsSinceUser = 0;
     taskCallsSinceUser = 0;
-    nudgeCount = 0;
     updatePresentation(ctx);
   });
 
@@ -245,14 +229,8 @@ export default function taskListExtension(pi: ExtensionAPI) {
 
   pi.on("tool_execution_start", async (event, ctx) => {
     lastCtx = ctx;
-    sequence++;
-    if (event.toolName === TASK_LIST_TOOL) {
-      lastTaskSequence = sequence;
-      taskCallsSinceUser++;
-    } else if (!WORK_TOOL_EXCLUSIONS.has(event.toolName)) {
-      lastWorkSequence = sequence;
-      workCallsSinceUser++;
-    }
+    if (event.toolName === TASK_LIST_TOOL) taskCallsSinceUser++;
+    else if (!WORK_TOOL_EXCLUSIONS.has(event.toolName)) workCallsSinceUser++;
   });
 
   pi.on("context", async (event) => {
@@ -281,23 +259,6 @@ export default function taskListExtension(pi: ExtensionAPI) {
     return additions.length > 0 ? { messages: [...event.messages, ...additions] } : undefined;
   });
 
-  pi.on("agent_end", async () => {
-    staleAtAgentEnd = hasActiveTasks(state) && lastWorkSequence > lastTaskSequence;
-  });
-
-  pi.on("agent_settled", async (_event, ctx) => {
-    lastCtx = ctx;
-    if (!staleAtAgentEnd || nudgeCount >= 1 || ctx.hasPendingMessages()) return;
-    staleAtAgentEnd = false;
-    nudgeCount++;
-    pi.sendMessage({
-      customType: "task-list-reminder",
-      content: "You stopped with a stale active task list. Update task_list now. If work remains, pair that update with the next concrete action; if work is finished, mark verified items completed and cancelled items with a reason before the final response.",
-      display: false,
-      details: { revision: state.revision, kind: "settled-stale-list" },
-    }, { deliverAs: "followUp", triggerTurn: true });
-  });
-
   pi.on("session_shutdown", async () => {
     cancelFinishedTimer();
   });
@@ -398,7 +359,7 @@ Use task_list for work with at least three distinct actions, multiple user-reque
 
 Start the list before substantive work and call task_list in the SAME assistant message as the first action tool. Never spend a turn only announcing or updating the list when another action can run. Keep stable ids and preserve every user-requested item, exact command, flag, path, and success condition.
 
-Update the list as work happens, not after several steps: mark a finished item completed only after its outcome is verified, move the next sequential item to in_progress, and issue that next action in the same assistant message. Keep one in_progress task for sequential work; use several only when work is genuinely running in parallel. Use blocked only for a concrete unresolved dependency and cancelled only when an item is no longer required, with the reason in note.
+Update the list only when task-level state changes—not after every file read, edit, command, or tool call. When a task is fully verified, mark it completed, move the next sequential item to in_progress, and issue that next action in the same assistant message. Also update for genuine blockers, cancellations, or user-requested scope changes. Keep one in_progress task for sequential work; use several only when work is genuinely running in parallel.
 
 Before the final response, reconcile the whole list with actual results. No item may remain pending or in_progress if the requested work is finished. Do not claim completion from the list itself.`,
     promptSnippet: "Read or replace the current session's complete task list and progress state.",
@@ -406,7 +367,7 @@ Before the final response, reconcile the whole list with actual results. No item
       "Use task_list for requests with at least three distinct actions, multiple requested tasks, or meaningful phases; skip it for direct answers and one- or two-action work.",
       "Create task_list before substantive multi-step work and send the update in the same assistant message as the first real action; never spend a turn on task bookkeeping alone when another action exists.",
       "Every task_list write replaces the entire ordered list. Preserve stable ids, all unfinished and user-requested work, and exact commands, flags, paths, and success conditions.",
-      "Update task_list immediately as each step changes: complete only verified work, set the next sequential item in_progress, and pair the update with the next action. Multiple in_progress items require genuinely parallel work.",
+      "Update task_list only for task-level transitions: verified completion, starting the next task, a genuine blocker or cancellation, or a user-requested scope change. Do not update it after every file read, edit, command, or tool call. Pair transitions with the next action when work remains.",
       "Before a final response, reconcile task_list with observed results and leave no stale pending or in_progress items when the requested work is finished. The list is not proof of completion.",
     ],
     parameters: TaskListParams,
@@ -414,7 +375,6 @@ Before the final response, reconcile the whole list with actual results. No item
       lastCtx = ctx;
       if (params.tasks !== undefined) {
         replaceState(buildUpdatedTaskList(state, params), ctx);
-        lastTaskSequence = Math.max(lastTaskSequence, sequence);
       }
       const action = params.tasks === undefined ? "read" : "update";
       const details: TaskListDetails = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shariq-pi-extensions",
-  "version": "0.2.23",
+  "version": "0.2.25",
   "description": "Cross-platform extension suite for the Pi coding agent.",
   "license": "MIT",
   "author": "Shariq Riaz",