@phnx-labs/agents-cli 1.20.51 → 1.20.52

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/discover.js

@@ -1826,8 +1826,7 @@ export async function scanClaudeSession(filePath) {
                         pendingTicketTools.add(b.id);
                     }
                     // ExitPlanMode plan markdown — last one wins so a re-planned session
-                    // reports its most recent plan (the semantic parsePlanFromClaudeJsonl
-                    // implemented in the extension).
+                    // reports its most recent plan.
                     if (b?.name === 'ExitPlanMode' && typeof b?.input?.plan === 'string') {
                         const p = b.input.plan.trim();
                         if (p)

package/dist/lib/session/state.js

@@ -17,6 +17,14 @@
 import { summarizeToolUse } from './parse.js';
 /** A healthy live session writes several times a minute; 2 min ⇒ "recently active". */
 const ACTIVE_WINDOW_MS = 2 * 60_000;
+/**
+ * A prose trailing question ("…?") is a HEURISTIC, so it decays: past this long
+ * with no session writes it stops classifying as waiting_input — otherwise a
+ * finished session that signed off with "anything else?" reads as needing input
+ * forever (RUSH-1522). The structural ExitPlanMode / AskUserQuestion signals are
+ * exempt: they are precise, still-unanswered decisions.
+ */
+const PROSE_QUESTION_FRESH_MS = 30 * 60_000;
 /** Claude tool names that structurally mean "the agent handed control back to you". */
 const PLAN_TOOL = 'ExitPlanMode';
 const ASK_TOOL = 'AskUserQuestion';
@@ -299,7 +307,11 @@ export function inferActivity(events, ctx = {}) {
         }
         // Assistant spoke last and stopped. A trailing question → waiting; else idle.
         // A prose question takes a free-text reply (no select-list), so no options/keys.
-        if (looksLikeQuestion(last.content ?? '')) {
+        // Unlike the structural plan/ask signals above, the prose heuristic DECAYS: a
+        // question nobody answered within PROSE_QUESTION_FRESH_MS is a session that
+        // ended, not one that needs you (RUSH-1522). Unknown mtime keeps the question.
+        const questionFresh = ctx.mtimeMs == null || Date.now() - ctx.mtimeMs < PROSE_QUESTION_FRESH_MS;
+        if (questionFresh && looksLikeQuestion(last.content ?? '')) {
             const text = oneLine(last.content ?? '');
             return { ...base, activity: 'waiting_input', awaitingReason: 'question', question: { text, reason: 'question' } };
         }

package/dist/lib/startup/command-registry.d.ts

@@ -83,6 +83,7 @@ export declare const loadSessions: ModuleLoader;
 export declare const loadTeams: ModuleLoader;
 export declare const loadCloud: ModuleLoader;
 export declare const loadMessage: ModuleLoader;
+export declare const loadFeed: ModuleLoader;
 export declare const loadServe: ModuleLoader;
 export declare const loadAudit: ModuleLoader;
 /**

package/dist/lib/startup/command-registry.js

@@ -61,6 +61,7 @@ export const loadSessions = async () => (await import('../../commands/sessions.j
 export const loadTeams = async () => (await import('../../commands/teams.js')).registerTeamsCommands;
 export const loadCloud = async () => (await import('../../commands/cloud.js')).registerCloudCommands;
 export const loadMessage = async () => (await import('../../commands/message.js')).registerMessageCommand;
+export const loadFeed = async () => (await import('../../commands/feed.js')).registerFeedCommand;
 export const loadServe = async () => (await import('../../commands/serve.js')).registerServeCommand;
 export const loadAudit = async () => (await import('../../commands/audit.js')).registerAuditCommands;
 /**
@@ -154,6 +155,7 @@ export const COMMAND_LOADERS = {
     teams: [loadTeams],
     cloud: [loadCloud],
     message: [loadMessage],
+    feed: [loadFeed],
     serve: [loadServe],
     audit: [loadAudit],
 };

package/dist/lib/state.d.ts

@@ -122,6 +122,8 @@ export declare function getProjectRoutinesDir(cwd?: string): string | null;
 export declare function getRunsDir(): string;
 /** Root for per-agent mailboxes (~/.agents/.history/mailbox/). */
 export declare function getMailboxRootDir(): string;
+/** Root for open-block feed records (~/.agents/.history/feed/). */
+export declare function getFeedDir(): string;
 /** Path to installed agent CLI binaries (~/.agents/.history/versions/). */
 export declare function getVersionsDir(): string;
 /** Path to version-switching shim scripts (~/.agents/.cache/shims/). */

package/dist/lib/state.js

@@ -89,6 +89,7 @@ const TEAMS_AGENTS_DIR = path.join(HISTORY_DIR, 'teams', 'agents');
 const BACKUPS_DIR = path.join(HISTORY_DIR, 'backups');
 const TRASH_DIR = path.join(HISTORY_DIR, 'trash');
 const MAILBOX_DIR = path.join(HISTORY_DIR, 'mailbox');
+const FEED_DIR = path.join(HISTORY_DIR, 'feed');
 // Cache bucket (regenerable).
 const SHIMS_DIR = path.join(CACHE_DIR, 'shims');
 const HOOK_SHIMS_DIR = path.join(SHIMS_DIR, 'hooks');
@@ -313,6 +314,8 @@ export function getProjectRoutinesDir(cwd = process.cwd()) {
 export function getRunsDir() { return RUNS_DIR; }
 /** Root for per-agent mailboxes (~/.agents/.history/mailbox/). */
 export function getMailboxRootDir() { return MAILBOX_DIR; }
+/** Root for open-block feed records (~/.agents/.history/feed/). */
+export function getFeedDir() { return FEED_DIR; }
 /** Path to installed agent CLI binaries (~/.agents/.history/versions/). */
 export function getVersionsDir() { return VERSIONS_DIR; }
 /** Path to version-switching shim scripts (~/.agents/.cache/shims/). */
@@ -569,25 +572,35 @@ function writeIfChanged(filePath, content) {
 /**
  * Partition the in-memory Meta across three files by sync-domain:
  *   - central  `~/.agents/agents.yaml`             — portable, everything else
- *   - device   `~/.agents/devices/<machine>/agents.yaml` — `agents:` pins (per-device)
+ *   - device   `~/.agents/devices/<machine>/agents.yaml` — `agents:` pins +
+ *              `defaultBrowserProfile:` (both per-device)
  *   - history  `~/.agents/.history/version-resources.json` — `versions:` (machine-local)
  * All callers funnel through writeMeta → here, so nothing else changes. Empty
  * `agents:` / `versions:` are not written (no empty committed files).
  */
 function writeMetaUnlocked(meta) {
-    const { agents, versions, ...central } = meta;
+    const { agents, versions, defaultBrowserProfile, ...central } = meta;
     // Write the machine-local files FIRST, then strip central — so a crash mid-write
     // never removes pins/versions from central before they're persisted elsewhere.
     const devicePath = getDeviceMetaPath();
-    if (agents && Object.keys(agents).length > 0) {
+    const hasAgents = !!agents && Object.keys(agents).length > 0;
+    const hasDefaultBrowser = !!defaultBrowserProfile;
+    if (hasAgents || hasDefaultBrowser) {
+        // Device-local doc carries `agents:` pins and `defaultBrowserProfile:` — both
+        // are per-machine and must never land in central agents.yaml (which syncs).
+        const deviceDoc = {};
+        if (hasAgents)
+            deviceDoc.agents = agents;
+        if (hasDefaultBrowser)
+            deviceDoc.defaultBrowserProfile = defaultBrowserProfile;
         fs.mkdirSync(path.dirname(devicePath), { recursive: true });
-        writeIfChanged(devicePath, META_HEADER + yaml.stringify({ agents }));
+        writeIfChanged(devicePath, META_HEADER + yaml.stringify(deviceDoc));
     }
     else if (fs.existsSync(devicePath)) {
-        // Every pin was cleared. Persist the emptied map instead of skipping the
-        // write — otherwise the stale device file survives and overlayMachineLocal
-        // re-applies the removed pin on the next read, leaving a dangling default
-        // (e.g. a launcher pointing at a version that was just uninstalled).
+        // Every device-local value was cleared. Persist the emptied doc instead of
+        // skipping the write — otherwise the stale device file survives and
+        // overlayMachineLocal re-applies the removed pin/default on the next read,
+        // leaving a dangling value (e.g. a default pointing at a deleted profile).
         writeIfChanged(devicePath, META_HEADER + yaml.stringify({ agents: {} }));
     }
     if (versions && Object.keys(versions).length > 0) {
@@ -602,6 +615,8 @@ function writeMetaUnlocked(meta) {
  * Overlay this machine's local state onto a central-portable Meta:
  *   - `agents:` from the device file (device wins; the union both preserves the
  *     one-level merge and self-heals a pre-migration central that still has pins)
+ *   - `defaultBrowserProfile:` from the device file (device is the sole source;
+ *     the field is stripped from central on write, so nothing to merge against)
  *   - `versions:` from the history JSON (wholesale replace; falls back to
  *     whatever central carried when the history file doesn't exist yet)
  */
@@ -612,6 +627,8 @@ function overlayMachineLocal(meta) {
             const dm = yaml.parse(fs.readFileSync(devicePath, 'utf-8'));
             if (dm?.agents)
                 meta.agents = { ...meta.agents, ...dm.agents };
+            if (dm?.defaultBrowserProfile)
+                meta.defaultBrowserProfile = dm.defaultBrowserProfile;
         }
         catch { /* ignore malformed device file */ }
     }

package/dist/lib/teams/agents.js

@@ -1693,6 +1693,7 @@ export class AgentManager {
         ];
         if (model)
             args.push('--model', model);
+        args.push('--env', 'AGENTS_RUNTIME=teams');
         return args;
     }
     buildCommand(agentType, prompt, mode, model, cwd = null, sessionId = null, effort = 'medium', version = null, profileName = null) {
@@ -1704,9 +1705,11 @@ export class AgentManager {
         ];
         if (cwd)
             cmd.push('--cwd', cwd);
-        // Pin Claude's session UUID to our agent_id so its session file lands at
-        // ~/.claude/projects/.../<agent_id>.jsonl — unified identity for status polling.
-        if (agentType === 'claude' && sessionId) {
+        // Pin the session UUID to our agent_id so buildExecEnv keys
+        // AGENTS_MAILBOX_DIR by the same id mailboxIdForActiveSession returns.
+        // Claude also forwards --session-id to its CLI (unified identity);
+        // other agents ignore the flag but still get the correct mailbox dir.
+        if (sessionId) {
             cmd.push('--session-id', sessionId);
         }
         // Claude: grant access to the teammate's working directory.

package/dist/lib/types.d.ts

@@ -652,6 +652,16 @@ export interface Meta {
      * lives separately in ~/.agents/.cache/browser/<profile>/.
      */
     browser?: Record<string, BrowserProfileConfig>;
+    /**
+     * Device-local pointer: the browser profile `agents browser start` resolves to
+     * when no `--profile` is passed (and what an explicit `--profile default`
+     * re-points to). Stored per-machine in `~/.agents/devices/<machine>/agents.yaml`,
+     * NOT central — the target profile may carry machine-local logins, so the choice
+     * must not ride `agents repo push/pull` to other machines. Unset = auto-detect an
+     * installed Chromium-family browser (legacy behavior). Set via
+     * `agents browser profiles set-default <name>`.
+     */
+    defaultBrowserProfile?: string;
     /**
      * Agent-host registry keyed by host name (`agents hosts`). Portable user
      * config synced with `agents repo push/pull`. For `ssh-config` hosts this is

package/dist/lib/whats-new.d.ts

@@ -1,8 +1,10 @@
 /**
  * Render a compact "What's new" summary from a CHANGELOG.md body: one bullet
- * per feature/fix heading (the `**...**` lines) for each version in the range
- * the user actually moved through, `(fromVersion, toVersion]`. The verbose
- * sub-bullets are intentionally dropped — the full notes live in the changelog.
+ * per feature/fix heading for each version in the range the user actually
+ * moved through, `(fromVersion, toVersion]`. Headings are recognized in both
+ * changelog formats — the current `- **Title.** prose…` single-line bullets
+ * and the older standalone `**Heading**` lines. The verbose prose/sub-bullets
+ * are intentionally dropped — the full notes live in the changelog.
  *
  * Returns colored lines ready to print, empty when nothing is in range.
  */

package/dist/lib/whats-new.js

@@ -2,15 +2,23 @@ import chalk from 'chalk';
 import { compareVersions } from './agent-spec/primitives.js';
 /**
  * Render a compact "What's new" summary from a CHANGELOG.md body: one bullet
- * per feature/fix heading (the `**...**` lines) for each version in the range
- * the user actually moved through, `(fromVersion, toVersion]`. The verbose
- * sub-bullets are intentionally dropped — the full notes live in the changelog.
+ * per feature/fix heading for each version in the range the user actually
+ * moved through, `(fromVersion, toVersion]`. Headings are recognized in both
+ * changelog formats — the current `- **Title.** prose…` single-line bullets
+ * and the older standalone `**Heading**` lines. The verbose prose/sub-bullets
+ * are intentionally dropped — the full notes live in the changelog.
  *
  * Returns colored lines ready to print, empty when nothing is in range.
  */
 export function renderWhatsNew(changelog, fromVersion, toVersion) {
     const out = [];
     let inRelevantSection = false;
+    // Whether the CURRENT version section uses the old standalone-heading format.
+    // Old sections nest `-` sub-bullets under each `**Heading**` line, and some
+    // sub-bullets are themselves bold-led (`- **Claim.** detail…`) — once a
+    // standalone heading is seen, `- **` lines in that section are sub-bullets,
+    // not entries, and must not render.
+    let sectionUsesStandaloneHeadings = false;
     for (const line of changelog.split('\n')) {
         const versionMatch = line.match(/^## (\d+\.\d+\.\d+)/);
         if (versionMatch) {
@@ -20,15 +28,27 @@ export function renderWhatsNew(changelog, fromVersion, toVersion) {
             inRelevantSection =
                 compareVersions(currentVersion, fromVersion) > 0 &&
                     compareVersions(currentVersion, toVersion) <= 0;
+            sectionUsesStandaloneHeadings = false;
             if (inRelevantSection) {
                 out.push('');
                 out.push(chalk.bold(`v${currentVersion}`));
             }
             continue;
         }
-        // Only the bold headings — one bullet per feature/fix.
-        if (inRelevantSection && line.startsWith('**') && line.endsWith('**')) {
+        // Only the entry headings — one bullet per feature/fix. Two formats exist
+        // across the changelog's history: the current single-line bullets
+        // (`- **Title.** verbose prose…`, heading kept, prose dropped) and the
+        // older standalone `**Heading**` lines with `-` sub-bullets beneath.
+        if (!inRelevantSection)
+            continue;
+        if (line.startsWith('**') && line.endsWith('**')) {
+            sectionUsesStandaloneHeadings = true;
             out.push(`  ${chalk.cyan('•')} ${line.replace(/\*\*/g, '')}`);
+            continue;
+        }
+        const entryBullet = sectionUsesStandaloneHeadings ? null : line.match(/^- \*\*(.+?)\*\*/);
+        if (entryBullet) {
+            out.push(`  ${chalk.cyan('•')} ${entryBullet[1].replace(/\*\*/g, '')}`);
         }
     }
     return out;