@phnx-labs/agents-cli 1.20.50 → 1.20.52

package/dist/lib/secrets/bundles.js

@@ -25,7 +25,7 @@ import { deleteKeychainToken, getKeychainToken, getKeychainTokens, hasKeychainTo
 import { fileStore } from './filestore.js';
 import { emit } from '../events.js';
 import { readMeta } from '../state.js';
-import { agentGetSync, agentAutoLoadSync, agentGetMetaSync, agentAutoLoadMetaSync, secretsAgentAutoEnabled, DEFAULT_TTL_MS } from './agent.js';
+import { agentGetSync, agentAutoLoadSync, agentGetMetaSync, agentAutoLoadMetaSync, agentEvictSync, secretsAgentAutoEnabled, DEFAULT_TTL_MS } from './agent.js';
 import { createHash } from 'node:crypto';
 const keychainStore = {
     has: hasKeychainToken,
@@ -105,9 +105,9 @@ export const SECRET_TYPES = [
 ];
 /** Minimum gap between last_used updates so the keychain isn't written on every secrets injection. */
 const LAST_USED_THROTTLE_MS = 60_000;
-const BUNDLE_NAME_PATTERN = /^[a-z0-9][a-z0-9\-_.]{0,48}$/i;
-const ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const BUNDLE_META_PREFIX = 'agents-cli.bundles.';
+export const BUNDLE_NAME_PATTERN = /^[a-z0-9][a-z0-9\-_.]{0,48}$/i;
+export const ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+export const BUNDLE_META_PREFIX = 'agents-cli.bundles.';
 const SECRETS_ITEM_PREFIX = 'agents-cli.secrets.';
 export const RESERVED_ENV_NAMES = new Set([
     'PATH', 'HOME', 'USER', 'USERNAME', 'SHELL', 'PWD', 'OLDPWD',
@@ -277,7 +277,24 @@ export function secretsDefaultPolicy() {
 export function bundlePolicy(bundle) {
     return bundle.policy ?? secretsDefaultPolicy();
 }
-export function writeBundle(bundle) {
+/**
+ * Whether a bundle write should evict the broker-held copy. Pure + exported
+ * for regression coverage. Skips when the writer opted out (stampLastUsed),
+ * when the broker integration is disabled (AGENTS_SECRETS_NO_AGENT — the same
+ * kill-switch the read fast-path honors), or when a test keychain backend is
+ * installed (an in-memory backend has no real keychain behind it, and a test
+ * writing bundle 'prod' must never evict the user's real 'prod' unlock).
+ */
+export function shouldEvictAfterBundleWrite(skipRequested, noAgentEnv, backendOverridden) {
+    if (skipRequested)
+        return false;
+    if (noAgentEnv === '1')
+        return false;
+    if (backendOverridden)
+        return false;
+    return true;
+}
+export function writeBundle(bundle, opts = {}) {
     validateBundleName(bundle.name);
     const backend = bundle.backend ?? 'keychain';
     if (backend === 'file')
@@ -337,12 +354,20 @@ export function writeBundle(bundle) {
     // no-ACL command is missing) rather than silently landing an ACL'd item.
     itemStore(backend).set(bundleMetaItem(bundle.name), json, { noAcl: bundle.policy === 'never' });
     emit('secrets.set', { module: 'secrets', bundle: bundle.name });
+    // A broker-held snapshot predates this write; evict it so the next read
+    // re-resolves from the keychain instead of serving stale values.
+    if (shouldEvictAfterBundleWrite(Boolean(opts.skipBrokerEviction), process.env.AGENTS_SECRETS_NO_AGENT, isKeychainBackendOverridden())) {
+        agentEvictSync(bundle.name);
+    }
 }
 export function deleteBundle(name) {
     validateBundleName(name);
     const deleted = itemStore(bundleBackend(name)).delete(bundleMetaItem(name));
     if (deleted) {
         emit('secrets.delete', { module: 'secrets', bundle: name });
+        if (shouldEvictAfterBundleWrite(false, process.env.AGENTS_SECRETS_NO_AGENT, isKeychainBackendOverridden())) {
+            agentEvictSync(name);
+        }
     }
     return deleted;
 }
@@ -513,7 +538,9 @@ function stampLastUsed(bundle) {
     }
     try {
         bundle.last_used = new Date(nowMs).toISOString();
-        writeBundle(bundle);
+        // skipBrokerEviction: this stamp fires on every broker HIT; letting it
+        // evict would make the cache destroy itself on first use.
+        writeBundle(bundle, { skipBrokerEviction: true });
     }
     catch {
         // Swallow — telemetry must never block secret resolution.
@@ -694,7 +721,7 @@ export function readAndResolveBundleEnv(name, opts = {}) {
             emit('secrets.get', {
                 module: 'secrets',
                 bundle: name,
-                caller: opts.caller,
+                operation: opts.caller,
                 status: 'success',
                 source: 'agent',
                 keyCount: Object.keys(filtered.env).length,
@@ -702,6 +729,9 @@ export function readAndResolveBundleEnv(name, opts = {}) {
             return filtered;
         }
     }
+    if (opts.agentOnly) {
+        throw new Error(`Secrets bundle '${name}' is not unlocked in the secrets agent.`);
+    }
     if (backend === 'file')
         assertFileBackendUsable(name);
     const store = itemStore(backend);
@@ -784,7 +814,7 @@ export function readAndResolveBundleEnv(name, opts = {}) {
         emit('secrets.get', {
             module: 'secrets',
             bundle: bundle.name,
-            caller: opts.caller,
+            operation: opts.caller,
             status,
             keyCount: keys.length,
             keys,

package/dist/lib/secrets/icloud-import.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Recovery for LEGACY SYNCHRONIZABLE (iCloud Keychain) bundles.
+ *
+ * The pre-biometry helper era defaulted bundles to iCloud Keychain sync. The
+ * device-local cutover (biometry ACL + kSecAttrSynchronizable false on every
+ * query) orphaned those items: they still sync back via iCloud Keychain, but
+ * neither `secrets list` nor `migrate-acl` can see them. This module powers
+ * `agents secrets import --from icloud` — discover the orphaned bundles,
+ * re-import them as normal device-local bundles, and optionally purge the
+ * iCloud copies.
+ *
+ * The item-name scheme is the same one the modern store uses (see bundles.ts):
+ * metadata under `agents-cli.bundles.<name>`, one value per key under
+ * `agents-cli.secrets.<bundle>.<key>`. Env keys can never contain a dot
+ * (ENV_KEY_PATTERN), so splitting a secret service at its LAST dot recovers
+ * the bundle/key boundary even for dotted bundle names like `hetzner.com`.
+ */
+import { type SecretsBackend } from './bundles.js';
+/** One orphaned iCloud bundle, as discovered from the synced item names. */
+export interface SyncedBundleCandidate {
+    /** Bundle name derived from the iCloud service names. */
+    name: string;
+    /** Env keys that have a per-key secret item in the iCloud keychain. */
+    keys: string[];
+    /** True when an `agents-cli.bundles.<name>` metadata item exists in iCloud. */
+    hasMeta: boolean;
+    /** Every iCloud service name belonging to this candidate (the purge set). */
+    services: string[];
+}
+/**
+ * Group raw synced service names into per-bundle candidates. Pure — separated
+ * from discovery so the parsing rules are unit-testable without a keychain.
+ *
+ * A bundle can surface as metadata only (`agents-cli.bundles.<name>`), as
+ * secret items only (`agents-cli.secrets.<bundle>.<KEY>` — metadata never
+ * synced), or both; all three shapes appear in real iCloud strays, so every
+ * one becomes a candidate.
+ */
+export declare function groupSyncedServices(services: string[]): SyncedBundleCandidate[];
+/** Enumerate the iCloud keychain and return every orphaned bundle candidate. */
+export declare function discoverSyncedBundles(): SyncedBundleCandidate[];
+export interface ImportSyncedOptions {
+    /** Overwrite keys that already exist in the local bundle. */
+    force?: boolean;
+    /** Store imported values as literals in the bundle metadata (no keychain items). */
+    allPlaintext?: boolean;
+    /** Backend for a newly created bundle (existing bundles keep theirs). */
+    backend?: SecretsBackend;
+    /** Delete the iCloud copies of successfully-read items after import. */
+    purge?: boolean;
+}
+export interface ImportSyncedResult {
+    name: string;
+    added: number;
+    skipped: number;
+    /** Keys whose iCloud value could not be read (left in place, never purged). */
+    missing: string[];
+    purged: number;
+}
+/**
+ * Import one discovered iCloud bundle into the local (device-local) store.
+ *
+ * Values come from the synced secret items; the synced metadata item, when
+ * present, contributes the description, literal vars, and non-keychain refs
+ * (env:/file:/exec: refs carry no stored secret, so copying the ref preserves
+ * them exactly). Existing local keys are skipped unless `force`. With `purge`,
+ * only services whose value was successfully read are deleted from iCloud —
+ * an unreadable item is never destroyed.
+ */
+export declare function importSyncedBundle(candidate: SyncedBundleCandidate, opts?: ImportSyncedOptions): ImportSyncedResult;

package/dist/lib/secrets/icloud-import.js

@@ -0,0 +1,173 @@
+/**
+ * Recovery for LEGACY SYNCHRONIZABLE (iCloud Keychain) bundles.
+ *
+ * The pre-biometry helper era defaulted bundles to iCloud Keychain sync. The
+ * device-local cutover (biometry ACL + kSecAttrSynchronizable false on every
+ * query) orphaned those items: they still sync back via iCloud Keychain, but
+ * neither `secrets list` nor `migrate-acl` can see them. This module powers
+ * `agents secrets import --from icloud` — discover the orphaned bundles,
+ * re-import them as normal device-local bundles, and optionally purge the
+ * iCloud copies.
+ *
+ * The item-name scheme is the same one the modern store uses (see bundles.ts):
+ * metadata under `agents-cli.bundles.<name>`, one value per key under
+ * `agents-cli.secrets.<bundle>.<key>`. Env keys can never contain a dot
+ * (ENV_KEY_PATTERN), so splitting a secret service at its LAST dot recovers
+ * the bundle/key boundary even for dotted bundle names like `hetzner.com`.
+ */
+import { deleteSyncedKeychainItem, getSyncedKeychainTokens, listSyncedKeychainItems, parseBundleValue, secretsKeychainItem, serializeRef, SECRETS_ITEM_PREFIX, } from './index.js';
+import { BUNDLE_META_PREFIX, BUNDLE_NAME_PATTERN, ENV_KEY_PATTERN, bundleExists, bundleItemStore, bundlePolicy, keychainRef, readBundle, writeBundle, } from './bundles.js';
+/**
+ * Group raw synced service names into per-bundle candidates. Pure — separated
+ * from discovery so the parsing rules are unit-testable without a keychain.
+ *
+ * A bundle can surface as metadata only (`agents-cli.bundles.<name>`), as
+ * secret items only (`agents-cli.secrets.<bundle>.<KEY>` — metadata never
+ * synced), or both; all three shapes appear in real iCloud strays, so every
+ * one becomes a candidate.
+ */
+export function groupSyncedServices(services) {
+    const byName = new Map();
+    const claim = (name) => {
+        let c = byName.get(name);
+        if (!c) {
+            c = { name, keys: [], hasMeta: false, services: [] };
+            byName.set(name, c);
+        }
+        return c;
+    };
+    for (const svc of services) {
+        if (svc.startsWith(BUNDLE_META_PREFIX)) {
+            const name = svc.slice(BUNDLE_META_PREFIX.length);
+            if (!BUNDLE_NAME_PATTERN.test(name))
+                continue;
+            const c = claim(name);
+            c.hasMeta = true;
+            c.services.push(svc);
+        }
+        else if (svc.startsWith(SECRETS_ITEM_PREFIX)) {
+            const rest = svc.slice(SECRETS_ITEM_PREFIX.length);
+            const cut = rest.lastIndexOf('.');
+            if (cut <= 0)
+                continue;
+            const name = rest.slice(0, cut);
+            const key = rest.slice(cut + 1);
+            if (!BUNDLE_NAME_PATTERN.test(name) || !ENV_KEY_PATTERN.test(key))
+                continue;
+            const c = claim(name);
+            if (!c.keys.includes(key))
+                c.keys.push(key);
+            c.services.push(svc);
+        }
+    }
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Enumerate the iCloud keychain and return every orphaned bundle candidate. */
+export function discoverSyncedBundles() {
+    return groupSyncedServices(listSyncedKeychainItems('agents-cli.'));
+}
+/**
+ * Import one discovered iCloud bundle into the local (device-local) store.
+ *
+ * Values come from the synced secret items; the synced metadata item, when
+ * present, contributes the description, literal vars, and non-keychain refs
+ * (env:/file:/exec: refs carry no stored secret, so copying the ref preserves
+ * them exactly). Existing local keys are skipped unless `force`. With `purge`,
+ * only services whose value was successfully read are deleted from iCloud —
+ * an unreadable item is never destroyed.
+ */
+export function importSyncedBundle(candidate, opts = {}) {
+    const values = getSyncedKeychainTokens(candidate.services);
+    let bundle;
+    if (bundleExists(candidate.name)) {
+        bundle = readBundle(candidate.name);
+    }
+    else {
+        bundle = {
+            name: candidate.name,
+            backend: opts.backend === 'file' ? 'file' : undefined,
+            vars: {},
+        };
+    }
+    const metaService = BUNDLE_META_PREFIX + candidate.name;
+    let metaVars = {};
+    const metaJson = values.get(metaService);
+    if (metaJson !== undefined) {
+        try {
+            const parsed = JSON.parse(metaJson);
+            if (parsed && typeof parsed === 'object') {
+                if (typeof parsed.description === 'string' && !bundle.description) {
+                    bundle.description = parsed.description;
+                }
+                if (parsed.vars && typeof parsed.vars === 'object') {
+                    metaVars = parsed.vars;
+                }
+            }
+        }
+        catch {
+            // Corrupt legacy metadata — the per-key secret items still import.
+        }
+    }
+    const store = bundleItemStore(bundle.backend, { noAcl: bundlePolicy(bundle) === 'never' });
+    let added = 0;
+    let skipped = 0;
+    const missing = [];
+    // Keys with a synced secret item: re-store the value device-locally.
+    for (const key of candidate.keys) {
+        const value = values.get(secretsKeychainItem(candidate.name, key));
+        if (value === undefined) {
+            missing.push(key);
+            continue;
+        }
+        if (!opts.force && key in bundle.vars) {
+            skipped++;
+            continue;
+        }
+        if (opts.allPlaintext) {
+            bundle.vars[key] = { value };
+        }
+        else {
+            store.set(secretsKeychainItem(candidate.name, key), value);
+            bundle.vars[key] = keychainRef(key);
+        }
+        added++;
+    }
+    // Vars declared only in the synced metadata: literals and non-keychain refs
+    // carry everything they need; a keychain ref without its synced item is
+    // unrecoverable.
+    for (const [key, raw] of Object.entries(metaVars)) {
+        if (!ENV_KEY_PATTERN.test(key))
+            continue;
+        if (candidate.keys.includes(key))
+            continue; // the secret item already covered it
+        let parsed;
+        try {
+            parsed = parseBundleValue(raw);
+        }
+        catch {
+            continue; // malformed legacy entry
+        }
+        if ('ref' in parsed && parsed.ref.provider === 'keychain') {
+            if (!missing.includes(key))
+                missing.push(key);
+            continue;
+        }
+        if (!opts.force && key in bundle.vars) {
+            skipped++;
+            continue;
+        }
+        bundle.vars[key] = 'literal' in parsed ? { value: parsed.literal } : serializeRef(parsed.ref);
+        added++;
+    }
+    writeBundle(bundle);
+    let purged = 0;
+    if (opts.purge) {
+        for (const svc of candidate.services) {
+            if (!values.has(svc))
+                continue; // never destroy an item we couldn't read
+            if (deleteSyncedKeychainItem(svc))
+                purged++;
+        }
+    }
+    return { name: candidate.name, added, skipped, missing, purged };
+}

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

@@ -24,6 +24,7 @@
  */
 import type { NativeImportReport } from './fallback.js';
 export type { NativeImportReport, NativeImportResult, NativeImportStatus } from './fallback.js';
+export declare const SECRETS_ITEM_PREFIX = "agents-cli.secrets.";
 /** Supported secret resolution backends. */
 export type SecretProvider = 'keychain' | 'env' | 'file' | 'exec';
 /** A typed reference to a secret, consisting of a provider and a provider-specific value. */
@@ -141,6 +142,41 @@ export declare function listKeychainItems(prefix: string): string[];
  * stragglers instead of every item (which would be a Touch ID storm).
  */
 export declare function listLegacyKeychainItems(prefix: string): string[];
+/**
+ * Test seam for the LEGACY SYNCHRONIZABLE (iCloud Keychain) recovery path.
+ * The main `KeychainBackend` seam models the live device-local store; this one
+ * models the orphaned iCloud items that `secrets import --from icloud` reads.
+ * Kept separate so a test can populate both sides independently.
+ */
+export interface SyncedKeychainBackend {
+    list(prefix: string): string[];
+    getBatch(items: string[]): Map<string, string>;
+    delete(item: string): boolean;
+}
+export declare function setSyncedKeychainBackendForTest(b: SyncedKeychainBackend | null): SyncedKeychainBackend | null;
+/**
+ * Enumerate LEGACY SYNCHRONIZABLE (iCloud Keychain) item names with the given
+ * prefix — bundles written by the pre-biometry helper era, which defaulted
+ * secrets to iCloud Keychain sync. The device-local cutover orphaned them:
+ * every modern query pins synchronizable=false, so only the helper's
+ * `list-synced` verb can see them. Silent (attributes only, never decrypts).
+ * macOS only — Linux/Windows never had iCloud Keychain sync, so this returns [].
+ */
+export declare function listSyncedKeychainItems(prefix: string): string[];
+/**
+ * Batch-read LEGACY SYNCHRONIZABLE (iCloud Keychain) items. Returns a map of
+ * item name → value; missing items are simply absent. Pre-biometry items carry
+ * no biometry ACL, so this does not normally prompt. macOS only — returns an
+ * empty map on Linux/Windows.
+ */
+export declare function getSyncedKeychainTokens(items: string[]): Map<string, string>;
+/**
+ * Delete a LEGACY SYNCHRONIZABLE (iCloud Keychain) item after a successful
+ * import (`--purge`). Matches synchronizable items only — the device-local
+ * copy the import wrote is untouched. iCloud propagates the deletion to the
+ * user's other devices. Returns true if a copy was removed.
+ */
+export declare function deleteSyncedKeychainItem(item: string): boolean;
 /**
  * One-time upgrade for a keychain item that was written by a previous helper
  * generation with a trusted-app ACL. The helper reads the legacy item

package/dist/lib/secrets/index.js

@@ -30,7 +30,7 @@ import { linuxBackend, usesFileFallback as linuxUsesFileFallback, importNativeSe
 import { windowsBackend, usesFileFallback as windowsUsesFileFallback, importNativeCredManItems } from './windows.js';
 import { getKeychainHelperPath } from './install-helper.js';
 const SERVICE_PREFIX = 'agents-cli';
-const SECRETS_ITEM_PREFIX = `${SERVICE_PREFIX}.secrets.`;
+export const SECRETS_ITEM_PREFIX = `${SERVICE_PREFIX}.secrets.`;
 const BUNDLES_ITEM_PREFIX = `${SERVICE_PREFIX}.bundles.`;
 const REF_PATTERN = /^(keychain|env|file|exec):(.+)$/s;
 /** Parse a bundle value into either a literal string or a typed secret ref. */
@@ -234,12 +234,20 @@ export function getKeychainTokens(items) {
         throw new Error(msg || `Failed to batch-read ${items.length} keychain items.`);
     }
     const out = child.stdout?.toString() ?? '';
-    // Output is a sequence of records, one per service in input order:
-    //   "V <service>\n<value>\n"   (present)
-    //   "M <service>\n"            (missing)
-    // Service names are validated newline/'='-free by setKeychainToken below
-    // and values are rejected if they contain newlines — so splitting on '\n'
-    // and walking line-by-line is unambiguous.
+    parseBatchRecords(out, result);
+    return result;
+}
+/**
+ * Parse the helper's batch-read output into `into`. The format is shared by
+ * `get-batch` and `get-batch-synced` — a sequence of records, one per service
+ * in input order:
+ *   "V <service>\n<value>\n"   (present)
+ *   "M <service>\n"            (missing)
+ * Service names are validated newline/'='-free by setKeychainToken below
+ * and values are rejected if they contain newlines — so splitting on '\n'
+ * and walking line-by-line is unambiguous.
+ */
+function parseBatchRecords(out, into) {
     const lines = out.split('\n');
     let i = 0;
     while (i < lines.length) {
@@ -249,7 +257,7 @@ export function getKeychainTokens(items) {
         if (line.startsWith('V ')) {
             const service = line.slice(2);
             const value = lines[i + 1] ?? '';
-            result.set(service, value);
+            into.set(service, value);
             i += 2;
         }
         else if (line.startsWith('M ')) {
@@ -262,7 +270,6 @@ export function getKeychainTokens(items) {
             throw new Error(`Malformed get-batch output line: ${JSON.stringify(line)}`);
         }
     }
-    return result;
 }
 /** Store or update a secret value in the keychain/keyring. Device-local;
  * biometry-gated on macOS. `opts.noAcl` (the `never` prompt-policy) writes our
@@ -408,6 +415,89 @@ export function listLegacyKeychainItems(prefix) {
     const out = result.stdout?.toString() || '';
     return out.split('\n').map((s) => s.trim()).filter(Boolean);
 }
+let syncedBackend = null;
+export function setSyncedKeychainBackendForTest(b) {
+    const prev = syncedBackend;
+    syncedBackend = b;
+    return prev;
+}
+/**
+ * Enumerate LEGACY SYNCHRONIZABLE (iCloud Keychain) item names with the given
+ * prefix — bundles written by the pre-biometry helper era, which defaulted
+ * secrets to iCloud Keychain sync. The device-local cutover orphaned them:
+ * every modern query pins synchronizable=false, so only the helper's
+ * `list-synced` verb can see them. Silent (attributes only, never decrypts).
+ * macOS only — Linux/Windows never had iCloud Keychain sync, so this returns [].
+ */
+export function listSyncedKeychainItems(prefix) {
+    if (syncedBackend)
+        return syncedBackend.list(prefix);
+    if (backend)
+        return [];
+    assertSupportedPlatform();
+    if (isLinux() || isWindows())
+        return [];
+    const bin = getKeychainHelperPath();
+    const result = spawnSync(bin, ['list-synced', prefix], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.status !== 0) {
+        const msg = result.stderr?.toString().trim();
+        throw new Error(msg || `Failed to enumerate iCloud keychain items with prefix '${prefix}'.`);
+    }
+    const out = result.stdout?.toString() || '';
+    return out.split('\n').map((s) => s.trim()).filter(Boolean);
+}
+/**
+ * Batch-read LEGACY SYNCHRONIZABLE (iCloud Keychain) items. Returns a map of
+ * item name → value; missing items are simply absent. Pre-biometry items carry
+ * no biometry ACL, so this does not normally prompt. macOS only — returns an
+ * empty map on Linux/Windows.
+ */
+export function getSyncedKeychainTokens(items) {
+    const result = new Map();
+    if (items.length === 0)
+        return result;
+    if (syncedBackend)
+        return syncedBackend.getBatch(items);
+    if (backend)
+        return result;
+    assertSupportedPlatform();
+    if (isLinux() || isWindows())
+        return result;
+    const bin = getKeychainHelperPath();
+    const child = spawnSync(bin, ['get-batch-synced', os.userInfo().username, ...items], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (child.status === 4) {
+        throw new Error(`Auth cancelled while reading ${items.length} iCloud keychain item(s).`);
+    }
+    if (child.status !== 0) {
+        const msg = child.stderr?.toString().trim();
+        throw new Error(msg || `Failed to batch-read ${items.length} iCloud keychain items.`);
+    }
+    parseBatchRecords(child.stdout?.toString() ?? '', result);
+    return result;
+}
+/**
+ * Delete a LEGACY SYNCHRONIZABLE (iCloud Keychain) item after a successful
+ * import (`--purge`). Matches synchronizable items only — the device-local
+ * copy the import wrote is untouched. iCloud propagates the deletion to the
+ * user's other devices. Returns true if a copy was removed.
+ */
+export function deleteSyncedKeychainItem(item) {
+    if (syncedBackend)
+        return syncedBackend.delete(item);
+    if (backend)
+        return false;
+    assertSupportedPlatform();
+    if (isLinux() || isWindows())
+        return false;
+    const bin = getKeychainHelperPath();
+    return spawnSync(bin, ['delete-synced', item, os.userInfo().username], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+    }).status === 0;
+}
 /**
  * One-time upgrade for a keychain item that was written by a previous helper
  * generation with a trusted-app ACL. The helper reads the legacy item

package/dist/lib/secrets/remote.js

@@ -161,7 +161,7 @@ export async function remoteResolveEnv(target, bundle) {
     emit('secrets.get', {
         module: 'secrets',
         bundle,
-        caller: 'remote resolve',
+        operation: 'remote resolve',
         source: 'remote',
         host: target,
         status: 'success',

package/dist/lib/secrets/sync.js

@@ -193,7 +193,7 @@ export async function pushBundle(name, opts) {
     emit('secrets.get', {
         module: 'secrets',
         bundle: name,
-        caller: 'sync push',
+        operation: 'sync push',
         source: 'sync-push',
         status: 'success',
         keyCount: Object.keys(snap.secrets).length,

package/dist/lib/session/active.d.ts

@@ -1,5 +1,5 @@
 import { type PidSessionEntry } from './pid-registry.js';
-import { type SessionActivity, type AwaitingReason, type DetectedPr, type DetectedWorktree, type DetectedTicket } from './state.js';
+import { type SessionActivity, type AwaitingReason, type StructuredQuestion, type DetectedPr, type DetectedWorktree, type DetectedTicket } from './state.js';
 import { type SessionProvenance } from './provenance.js';
 /**
  * Per-PID `lsof` probes run bounded and staggered rather than as one parallel
@@ -30,6 +30,16 @@ export interface ActiveSession {
     activity?: SessionActivity;
     /** Why the agent is waiting, when activity is waiting_input. */
     awaitingReason?: AwaitingReason;
+    /** The structured decision (question/plan/permission + options) the agent is waiting on. */
+    question?: StructuredQuestion;
+    /**
+     * Plan markdown from the last `ExitPlanMode` tool call. Present when the
+     * transcript ever entered plan-review; `awaitingReason === 'plan_review'`
+     * says whether it is still pending.
+     */
+    plan?: string;
+    /** Last few assistant turns (most-recent last), for at-a-glance context in the UI. */
+    tail?: string[];
     /** PR opened during the session. */
     pr?: DetectedPr;
     /** Worktree the session runs in. */

package/dist/lib/session/active.js

@@ -236,6 +236,9 @@ function applyState(base, state, fallbackFile) {
         status: statusFromActivity(state.activity),
         activity: state.activity,
         awaitingReason: state.awaitingReason,
+        question: state.question,
+        plan: state.plan,
+        tail: state.tail,
         // Prefer the live preview (latest turn); keep the first-prompt topic as a fallback.
         preview: state.preview ?? base.preview,
         pr: state.pr,

package/dist/lib/session/db.d.ts

@@ -35,6 +35,7 @@ export interface SessionRow {
     pr_number: number | null;
     worktree_slug: string | null;
     ticket_id: string | null;
+    plan: string | null;
 }
 /** File stat snapshot used to detect changes between scan runs. */
 export interface ScanStamp {
@@ -199,10 +200,6 @@ export interface TopCostSession {
  * vanished, mirroring querySessions' liveness filter.
  */
 export declare function topSessionsByCost(n: number, options?: QueryOptions): TopCostSession[];
-/** Return the set of all file paths currently tracked in the sessions table. */
-export declare function getAllFilePaths(): Set<string>;
-/** Look up sessions by their source file paths. */
-export declare function getSessionsByFilePaths(paths: string[]): Map<string, SessionMeta>;
 /** Look up a single session by its unique ID. */
 export declare function getSessionById(id: string): SessionMeta | null;
 /**