@phnx-labs/agents-cli 1.22.30 → 1.22.31

package/dist/lib/picker.d.ts

@@ -96,7 +96,7 @@ export declare function itemPicker<T>(config: PickerConfig<T>): Promise<PickedIt
  */
 export declare function multiItemPicker<T>(config: MultiPickerConfig<T>): Promise<T[] | null>;
 /** Configuration for the dynamic (async-refetch) picker prompt. */
-export interface DynamicPickerConfig<T, F> {
+export interface DynamicPickerConfig<T, F, A = never> {
     message: string;
     /** The initial filter state. Changing it (via a keybinding) re-runs {@link load}. */
     initialFilter: F;
@@ -117,6 +117,8 @@ export interface DynamicPickerConfig<T, F> {
      * SAME reference is a no-op; a new object triggers a reload.
      */
     keyBindings?: Record<string, (filter: F) => F>;
+    /** Keys that submit the highlighted row with an alternate typed action. */
+    submitKeys?: Record<string, A>;
     /**
      * Side-effecting keys that don't change the filter (e.g. `y` copies a command).
      * Receives the live search `query` so the effect can be search-aware. Return a
@@ -160,9 +162,10 @@ export declare function hotkeyToken(key: {
     meta?: boolean;
 }): string;
 /** The result returned when the user selects a row: the item plus the live filter. */
-export interface DynamicPicked<T, F> {
+export interface DynamicPicked<T, F, A = never> {
     item: T;
     filter: F;
+    action?: A;
 }
 /**
  * Async-refetch variant of {@link itemPicker}. Holds a `filter` object in state and
@@ -174,4 +177,4 @@ export interface DynamicPicked<T, F> {
  * Same render/pagination/preview machinery as the static pickers — only the data
  * source and keymap are dynamic.
  */
-export declare function dynamicPicker<T, F>(config: DynamicPickerConfig<T, F>): Promise<DynamicPicked<T, F> | null>;
+export declare function dynamicPicker<T, F, A = never>(config: DynamicPickerConfig<T, F, A>): Promise<DynamicPicked<T, F, A> | null>;

package/dist/lib/picker.js

@@ -490,11 +490,11 @@ export function dynamicPicker(config) {
                 setActive(0);
         }, [results]);
         const selected = results[active];
-        const finish = () => {
+        const finish = (action) => {
             if (!selected)
                 return;
             setStatus('done');
-            done({ item: selected.value, filter });
+            done({ item: selected.value, filter, ...(action === undefined ? {} : { action }) });
         };
         useKeypress((key, rl) => {
             if (isEnterKey(key)) {
@@ -575,6 +575,11 @@ export function dynamicPicker(config) {
             // existing single-letter hotkey: `R`/`C`/`A` used to reach their bindings
             // via `key.name`, and keying on the character alone would silently retire
             // them for anyone with caps lock on.
+            const submitAction = cfg.submitKeys?.[token] ?? cfg.submitKeys?.[key.name ?? ''];
+            if (submitAction !== undefined) {
+                finish(submitAction);
+                return;
+            }
             const binding = cfg.keyBindings?.[token] ?? cfg.keyBindings?.[key.name ?? ''];
             if (binding) {
                 const next = binding(filter);

package/dist/lib/secrets/agent.d.ts

@@ -463,7 +463,6 @@ export declare function agentLoad(name: string, bundle: SecretsBundle, env: Reco
 /** Wipe one bundle (or all if name omitted) from the broker. Returns the count
  * wiped, or 0 when no broker is running. */
 export declare function agentLock(name?: string): Promise<number>;
-export declare function agentRevoke(leaseId: string): Promise<number>;
 /** List currently-unlocked bundles, or [] when no broker is running. The
  * internal `secrets list` metadata-cache entry is filtered out here as well as
  * server-side: during a rollout a NEW client can talk to an OLD broker that

package/dist/lib/secrets/agent.js

@@ -1310,10 +1310,6 @@ export async function agentLock(name) {
     const r = await request({ cmd: 'lock', name });
     return r?.ok === true && r.cmd === 'lock' ? r.wiped : 0;
 }
-export async function agentRevoke(leaseId) {
-    const r = await request({ cmd: 'revoke', leaseId });
-    return r?.ok === true && r.cmd === 'revoke' ? r.wiped : 0;
-}
 /** List currently-unlocked bundles, or [] when no broker is running. The
  * internal `secrets list` metadata-cache entry is filtered out here as well as
  * server-side: during a rollout a NEW client can talk to an OLD broker that

package/dist/lib/secrets/session-store.d.ts

@@ -93,10 +93,6 @@ export declare function deleteBundleSessions(name: string): void;
 /** Delete one bundle's session blob and prune it from the index. */
 export declare function deleteSession(name: string, harness?: string): void;
 export declare function deleteLeaseSession(leaseId: string): number;
-export declare function activeLeaseSessions(now?: number): Array<{
-    name: string;
-    lease: SecretLease;
-}>;
 /** Delete every session blob + the index (for `secrets lock --all`). */
 export declare function deleteAllSessions(): void;
 /** Rehydrate every unexpired session into `[name, entry]` pairs for the broker to

package/dist/lib/secrets/session-store.js

@@ -208,11 +208,6 @@ export function deleteLeaseSession(leaseId) {
     }
     return deleted;
 }
-export function activeLeaseSessions(now = Date.now()) {
-    return rehydrateSessions(now)
-        .filter((item) => Boolean(item.entry.lease))
-        .map(({ name, entry }) => ({ name, lease: entry.lease }));
-}
 /** Delete every session blob + the index (for `secrets lock --all`). */
 export function deleteAllSessions() {
     if (!shouldPersist())

package/dist/lib/session/{favorites.d.ts → bookmarks.d.ts}

@@ -1,39 +1,39 @@
 /**
- * Favorited sessions — the durable "keep this one handy" mark a human puts on a
+ * Bookmarked sessions — the durable "keep this one handy" mark a human puts on a
  * session, deliberately kept OUT of the session index.
  *
  * `sessions.db` is a rebuildable CACHE: a reindex or a schema bump throws its
- * rows away and re-derives them from the transcripts on disk. A favorite is not
+ * rows away and re-derives them from the transcripts on disk. A bookmark is not
  * derivable from a transcript — it is a human's choice — so a column there would
  * be silently lost on the next rebuild. It lives in `~/.agents/.history/` instead,
  * next to the actor sidecars, which is never pruned.
  *
  * One flat set of session ids. The id is the transcript's own uuid, so it is
  * stable and machine-independent — but the file is NOT synced today: session sync
- * carries `.history/backups/` (`lib/session/sync/agents.ts`), not this. Favorites
+ * carries `.history/backups/` (`lib/session/sync/agents.ts`), not this. Bookmarks
  * are therefore per-machine; carrying them across the fleet would mean adding
  * them to the sync manifest, which this does not do.
  *
- * Reads are memoized against the file's mtime — the picker asks `isFavorite` once
+ * Reads are memoized against the file's mtime — the picker asks `isBookmarked` once
  * per rendered row, and re-reading a JSON file per row on every keystroke is the
  * kind of cost that makes a TUI feel broken.
  */
-export declare function favoritesFilePath(): string;
+export declare function bookmarksFilePath(): string;
 /** Drop the memoized read. Tests that write the file directly need this; nothing
  *  in the CLI does, because every mutation here refreshes the cache itself. */
-export declare function clearFavoritesCache(): void;
+export declare function clearBookmarksCache(): void;
 /**
- * Every favorited session id. Empty (never throws) when the file is absent,
- * unreadable, or malformed — a corrupt favorites file must not take down
+ * Every bookmarked session id. Empty (never throws) when the file is absent,
+ * unreadable, or malformed — a corrupt bookmarks file must not take down
  * `agents sessions`.
  */
-export declare function listFavorites(): Set<string>;
-export declare function isFavorite(sessionId: string | undefined): boolean;
+export declare function listBookmarks(): Set<string>;
+export declare function isBookmarked(sessionId: string | undefined): boolean;
 /**
- * Set (or clear) the favorite mark on a session. Returns the resulting state, so
+ * Set (or clear) the bookmark mark on a session. Returns the resulting state, so
  * a caller can report it without a second read. A no-op write is skipped, which
  * keeps the file's mtime — and every other process's memoized read — untouched.
  */
-export declare function setFavorite(sessionId: string, on: boolean): boolean;
-/** Flip the mark; returns the new state (`true` = now favorited). */
-export declare function toggleFavorite(sessionId: string): boolean;
+export declare function setBookmark(sessionId: string, on: boolean): boolean;
+/** Flip the mark; returns the new state (`true` = now bookmarked). */
+export declare function toggleBookmark(sessionId: string): boolean;

package/dist/lib/session/{favorites.js → bookmarks.js}

@@ -1,28 +1,28 @@
 /**
- * Favorited sessions — the durable "keep this one handy" mark a human puts on a
+ * Bookmarked sessions — the durable "keep this one handy" mark a human puts on a
  * session, deliberately kept OUT of the session index.
  *
  * `sessions.db` is a rebuildable CACHE: a reindex or a schema bump throws its
- * rows away and re-derives them from the transcripts on disk. A favorite is not
+ * rows away and re-derives them from the transcripts on disk. A bookmark is not
  * derivable from a transcript — it is a human's choice — so a column there would
  * be silently lost on the next rebuild. It lives in `~/.agents/.history/` instead,
  * next to the actor sidecars, which is never pruned.
  *
  * One flat set of session ids. The id is the transcript's own uuid, so it is
  * stable and machine-independent — but the file is NOT synced today: session sync
- * carries `.history/backups/` (`lib/session/sync/agents.ts`), not this. Favorites
+ * carries `.history/backups/` (`lib/session/sync/agents.ts`), not this. Bookmarks
  * are therefore per-machine; carrying them across the fleet would mean adding
  * them to the sync manifest, which this does not do.
  *
- * Reads are memoized against the file's mtime — the picker asks `isFavorite` once
+ * Reads are memoized against the file's mtime — the picker asks `isBookmarked` once
  * per rendered row, and re-reading a JSON file per row on every keystroke is the
  * kind of cost that makes a TUI feel broken.
  */
 import fs from 'node:fs';
 import path from 'node:path';
 import { getHistoryDir } from '../state.js';
-export function favoritesFilePath() {
-    return path.join(getHistoryDir(), 'favorites.json');
+export function bookmarksFilePath() {
+    return path.join(getHistoryDir(), 'bookmarks.json');
 }
 /** Memoized parse, invalidated by the file's mtime+size (another process — or
  *  another machine's sync — can rewrite it under us). */
@@ -38,16 +38,16 @@ function statKey(file) {
 }
 /** Drop the memoized read. Tests that write the file directly need this; nothing
  *  in the CLI does, because every mutation here refreshes the cache itself. */
-export function clearFavoritesCache() {
+export function clearBookmarksCache() {
     cache = null;
 }
 /**
- * Every favorited session id. Empty (never throws) when the file is absent,
- * unreadable, or malformed — a corrupt favorites file must not take down
+ * Every bookmarked session id. Empty (never throws) when the file is absent,
+ * unreadable, or malformed — a corrupt bookmarks file must not take down
  * `agents sessions`.
  */
-export function listFavorites() {
-    const file = favoritesFilePath();
+export function listBookmarks() {
+    const file = bookmarksFilePath();
     const key = statKey(file);
     if (cache && cache.key === key)
         return cache.ids;
@@ -64,14 +64,14 @@ export function listFavorites() {
     cache = { key, ids };
     return ids;
 }
-export function isFavorite(sessionId) {
+export function isBookmarked(sessionId) {
     if (!sessionId)
         return false;
-    return listFavorites().has(sessionId);
+    return listBookmarks().has(sessionId);
 }
 /** Atomic write (tmp + rename) so a concurrent reader never sees a half file. */
-function writeFavorites(ids) {
-    const file = favoritesFilePath();
+function writeBookmarks(ids) {
+    const file = bookmarksFilePath();
     fs.mkdirSync(path.dirname(file), { recursive: true });
     const body = { version: 1, sessionIds: [...ids].sort() };
     const tmp = `${file}.${process.pid}.tmp`;
@@ -80,22 +80,22 @@ function writeFavorites(ids) {
     cache = { key: statKey(file), ids };
 }
 /**
- * Set (or clear) the favorite mark on a session. Returns the resulting state, so
+ * Set (or clear) the bookmark mark on a session. Returns the resulting state, so
  * a caller can report it without a second read. A no-op write is skipped, which
  * keeps the file's mtime — and every other process's memoized read — untouched.
  */
-export function setFavorite(sessionId, on) {
-    const ids = new Set(listFavorites());
+export function setBookmark(sessionId, on) {
+    const ids = new Set(listBookmarks());
     if (ids.has(sessionId) === on)
         return on;
     if (on)
         ids.add(sessionId);
     else
         ids.delete(sessionId);
-    writeFavorites(ids);
+    writeBookmarks(ids);
     return on;
 }
-/** Flip the mark; returns the new state (`true` = now favorited). */
-export function toggleFavorite(sessionId) {
-    return setFavorite(sessionId, !isFavorite(sessionId));
+/** Flip the mark; returns the new state (`true` = now bookmarked). */
+export function toggleBookmark(sessionId) {
+    return setBookmark(sessionId, !isBookmarked(sessionId));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.30",
+  "version": "1.22.31",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",