@phnx-labs/agents-cli 1.22.84 → 1.22.85

package/dist/lib/secrets-types.js

@@ -0,0 +1,24 @@
+/**
+ * Wire-shared types for the standalone `secrets` CLI (PHNX-3989).
+ *
+ * The standalone engine (`@phnx-labs/secrets-cli`, extracted from what used to
+ * be `cli/src/lib/secrets/**`) owns every one of these shapes; this module only
+ * re-declares them so `secrets-client.ts` and its consumers keep exact static
+ * types across the process-client boundary with no runtime dependency on the
+ * (now deleted) in-repo engine. Keep byte-for-byte in sync with
+ * `secrets-cli/src/schema.ts` / `src/core/bundles.ts` — this is the one seam
+ * both sides legitimately re-declare rather than share a package for (see the
+ * `secrets-client.ts` docblock).
+ */
+// --- bundle document ---------------------------------------------------
+export const SECRET_TYPES = [
+    'api-key',
+    'token',
+    'password',
+    'url',
+    'database-url',
+    'ssh-key',
+    'certificate',
+    'webhook',
+    'note',
+];

package/dist/lib/service-manifest.js

@@ -27,10 +27,9 @@
  * module is the single place both rules live, so a new manifest has one obvious
  * thing to call.
  *
- * It is not yet the only consumer of the identifier rule: `lib/secrets/agent.ts`
- * keeps a literal `SERVICE_LABEL` for its `bootout`. That path is retire-only —
- * it detects and removes a plist an older version installed and generates none
- * of its own — so it has no HOME to bake and was deliberately left alone.
+ * A third consumer that used to keep its own literal `SERVICE_LABEL` for a
+ * retire-only `bootout` — the in-repo secrets broker's launchd cleanup — moved
+ * out of this repo entirely with the standalone `secrets` engine (PHNX-3989).
  */
 import * as crypto from 'crypto';
 import * as os from 'os';

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

@@ -817,6 +817,22 @@ export declare function buildFtsQuery(input: string): {
  * so "higher = better" is consistent across all tiers.
  */
 export declare function ftsSearch(input: string, limit?: number): FtsHit[];
+/**
+ * Rewrite file_path for sessions whose path starts with any of `moves.from`,
+ * replacing that prefix with `moves.to` and clearing the matching scan_ledger
+ * entries so the next scan re-indexes from the new location.
+ *
+ * One transaction for the whole batch (PHNX-3940 T7): a migration that moves
+ * several homes into slots and several version dirs into trash must not leave
+ * the index half-rewritten. Longest `from` wins when prefixes nest, and each
+ * session row is rewritten at most once.
+ *
+ * Returns the number of session rows updated.
+ */
+export declare function reindexMovedSessionPaths(moves: ReadonlyArray<{
+    from: string;
+    to: string;
+}>): number;
 /**
  * Rewrite file_path for all sessions whose path starts with oldPrefix, replacing
  * it with newPrefix + the unchanged suffix. Also clears the matching scan_ledger
@@ -827,6 +843,8 @@ export declare function ftsSearch(input: string, limit?: number): FtsHit[];
  * Returns the number of session rows updated.
  */
 export declare function updateSessionFilePaths(oldPrefix: string, newPrefix: string): number;
+/** Count indexed sessions whose transcript path sits under `prefix`. */
+export declare function countSessionsWithFilePrefix(prefix: string): number;
 /** Per-kind capture tallies for a browser task. Counts only -- never the bytes. */
 interface BrowserCaptureCounts {
     screenshot: number;

package/dist/lib/session/db.js

@@ -4317,6 +4317,44 @@ export function ftsSearch(input, limit = 200) {
     hits.sort((a, b) => b.score - a.score);
     return hits.slice(0, limit);
 }
+/**
+ * Rewrite file_path for sessions whose path starts with any of `moves.from`,
+ * replacing that prefix with `moves.to` and clearing the matching scan_ledger
+ * entries so the next scan re-indexes from the new location.
+ *
+ * One transaction for the whole batch (PHNX-3940 T7): a migration that moves
+ * several homes into slots and several version dirs into trash must not leave
+ * the index half-rewritten. Longest `from` wins when prefixes nest, and each
+ * session row is rewritten at most once.
+ *
+ * Returns the number of session rows updated.
+ */
+export function reindexMovedSessionPaths(moves) {
+    const usable = moves.filter((m) => m.from && m.from !== m.to);
+    if (usable.length === 0)
+        return 0;
+    const db = getDB();
+    const sorted = [...usable].sort((a, b) => b.from.length - a.from.length);
+    return db.transaction(() => {
+        let n = 0;
+        const seen = new Set();
+        const update = db.prepare(`UPDATE sessions SET file_path = ? WHERE id = ?`);
+        const dropLedger = db.prepare(`DELETE FROM scan_ledger WHERE file_path = ?`);
+        const select = db.prepare(`SELECT id, file_path FROM sessions WHERE file_path LIKE ?`);
+        for (const { from, to } of sorted) {
+            const rows = select.all(from + '%');
+            for (const { id, file_path } of rows) {
+                if (seen.has(id))
+                    continue;
+                seen.add(id);
+                update.run(to + file_path.slice(from.length), id);
+                dropLedger.run(canonicalLedgerKey(file_path));
+                n++;
+            }
+        }
+        return n;
+    })();
+}
 /**
  * Rewrite file_path for all sessions whose path starts with oldPrefix, replacing
  * it with newPrefix + the unchanged suffix. Also clears the matching scan_ledger
@@ -4327,21 +4365,16 @@ export function ftsSearch(input, limit = 200) {
  * Returns the number of session rows updated.
  */
 export function updateSessionFilePaths(oldPrefix, newPrefix) {
-    const db = getDB();
-    const rows = db
-        .prepare(`SELECT id, file_path FROM sessions WHERE file_path LIKE ?`)
-        .all(oldPrefix + '%');
-    if (rows.length === 0)
+    return reindexMovedSessionPaths([{ from: oldPrefix, to: newPrefix }]);
+}
+/** Count indexed sessions whose transcript path sits under `prefix`. */
+export function countSessionsWithFilePrefix(prefix) {
+    if (!prefix)
         return 0;
-    const txn = db.transaction(() => {
-        for (const { id, file_path } of rows) {
-            const newPath = newPrefix + file_path.slice(oldPrefix.length);
-            db.prepare(`UPDATE sessions SET file_path = ? WHERE id = ?`).run(newPath, id);
-            db.prepare(`DELETE FROM scan_ledger WHERE file_path = ?`).run(canonicalLedgerKey(file_path));
-        }
-    });
-    txn();
-    return rows.length;
+    const row = getDB()
+        .prepare(`SELECT COUNT(*) AS c FROM sessions WHERE file_path LIKE ?`)
+        .get(prefix + '%');
+    return row.c;
 }
 /**
  * Upsert one browser task's durable metadata.

package/dist/lib/session/sync/config.js

@@ -11,7 +11,7 @@
  * background sync. Credentials come from the `r2.backups` secrets bundle (OS
  * keychain on macOS, libsecret on Linux) — never from env or disk.
  */
-import { readAndResolveBundleEnv } from '../../secrets/bundles.js';
+import { readAndResolveBundleEnvSync } from '../../secrets-client.js';
 /** Secrets bundle holding the R2 credentials. */
 export const SYNC_BUNDLE = 'r2.backups';
 /**
@@ -30,7 +30,7 @@ function resolveR2Config() {
     // and degrades to no-transport (sync disabled) with no prompt and no crash —
     // unlock once (`agents secrets unlock r2.backups`) or set it no-ACL
     // (`agents secrets policy r2.backups never`) for silent zero-friction sync.
-    const { env } = readAndResolveBundleEnv(SYNC_BUNDLE, { caller: 'session-transport', agentOnly: true });
+    const { env } = readAndResolveBundleEnvSync(SYNC_BUNDLE, { caller: 'session-transport', agentOnly: true });
     const accountId = env.R2_ACCOUNT_ID?.trim();
     const bucket = env.R2_BUCKET_NAME?.trim();
     const accessKeyId = env.R2_ACCESS_KEY_ID?.trim();

package/dist/lib/sha256-asset.d.ts

@@ -3,22 +3,17 @@
  *
  * These live in their own LEAF module — importing only `node:crypto` and
  * `node:fs` — on purpose. They used to sit in `computer/ssh-tunnel.ts`, whose
- * own import graph reaches `browser/drivers/ssh.ts` -> `browser/chrome.ts` ->
- * `secrets/*`. `helper-download.ts` needs nothing from that graph but these two
- * pure functions, and importing them from there closed a module-initialization
- * cycle:
- *
- *   helper-download.ts
- *     -> computer/ssh-tunnel.ts        (evaluated BEFORE `EXPECTED_TEAM_ID`)
- *       -> browser/drivers/ssh.ts -> browser/chrome.ts
- *         -> secrets/bundles.ts -> secrets/index.ts -> secrets/install-helper.ts
- *           -> secrets/download-keychain.ts
- *             -> helper-download.ts    (still evaluating; const not yet bound)
- *
- * which threw `ReferenceError: Cannot access 'EXPECTED_TEAM_ID' before
- * initialization` at `secrets/download-keychain.ts:45` for any entry point that
- * reached `helper-download.ts` first (RUSH-3113). Keep this module a leaf: adding
- * a local import here can reintroduce that cycle.
+ * own import graph reached `browser/drivers/ssh.ts` -> `browser/chrome.ts` ->
+ * the in-repo secrets engine's own keychain-helper downloader, which imported
+ * back into `helper-download.ts` while it was still evaluating — before
+ * `EXPECTED_TEAM_ID` was bound, throwing `ReferenceError: Cannot access
+ * 'EXPECTED_TEAM_ID' before initialization` for any entry point that reached
+ * `helper-download.ts` first (RUSH-3113). The secrets engine that closed that
+ * cycle is gone now (PHNX-3989 — the standalone `secrets` CLI downloads its own
+ * helper), but the discipline that fixed it still holds: keep this module a
+ * leaf, since `helper-download.ts` needs nothing beyond these two pure
+ * functions and adding a local import here can reintroduce a cycle with
+ * whatever imports it next.
  */
 /** Pull the digest out of a `<sha256>  <filename>` release asset. */
 export declare function parseSha256Asset(text: string): string;

package/dist/lib/sha256-asset.js

@@ -3,22 +3,17 @@
  *
  * These live in their own LEAF module — importing only `node:crypto` and
  * `node:fs` — on purpose. They used to sit in `computer/ssh-tunnel.ts`, whose
- * own import graph reaches `browser/drivers/ssh.ts` -> `browser/chrome.ts` ->
- * `secrets/*`. `helper-download.ts` needs nothing from that graph but these two
- * pure functions, and importing them from there closed a module-initialization
- * cycle:
- *
- *   helper-download.ts
- *     -> computer/ssh-tunnel.ts        (evaluated BEFORE `EXPECTED_TEAM_ID`)
- *       -> browser/drivers/ssh.ts -> browser/chrome.ts
- *         -> secrets/bundles.ts -> secrets/index.ts -> secrets/install-helper.ts
- *           -> secrets/download-keychain.ts
- *             -> helper-download.ts    (still evaluating; const not yet bound)
- *
- * which threw `ReferenceError: Cannot access 'EXPECTED_TEAM_ID' before
- * initialization` at `secrets/download-keychain.ts:45` for any entry point that
- * reached `helper-download.ts` first (RUSH-3113). Keep this module a leaf: adding
- * a local import here can reintroduce that cycle.
+ * own import graph reached `browser/drivers/ssh.ts` -> `browser/chrome.ts` ->
+ * the in-repo secrets engine's own keychain-helper downloader, which imported
+ * back into `helper-download.ts` while it was still evaluating — before
+ * `EXPECTED_TEAM_ID` was bound, throwing `ReferenceError: Cannot access
+ * 'EXPECTED_TEAM_ID' before initialization` for any entry point that reached
+ * `helper-download.ts` first (RUSH-3113). The secrets engine that closed that
+ * cycle is gone now (PHNX-3989 — the standalone `secrets` CLI downloads its own
+ * helper), but the discipline that fixed it still holds: keep this module a
+ * leaf, since `helper-download.ts` needs nothing beyond these two pure
+ * functions and adding a local import here can reintroduce a cycle with
+ * whatever imports it next.
  */
 import { createHash } from 'node:crypto';
 import * as fs from 'node:fs';

package/dist/lib/share/config.js

@@ -9,8 +9,7 @@
 //   `cloudflare` bundle.
 import { randomBytes } from 'node:crypto';
 import { readMeta, updateMeta } from '../state.js';
-import { bundleExists, bundleItemStore, bundlePolicy, keychainRef, readAndResolveBundleEnv, readBundle, writeBundle, } from '../secrets/bundles.js';
-import { secretsKeychainItem } from '../secrets/index.js';
+import { bundleExistsSync as bundleExists, keychainRef, readAndResolveBundleEnvSync as readAndResolveBundleEnv, readBundleSync as readBundle, secretsKeychainItem, writeBundleWithItemsSync as writeBundleWithItems, } from '../secrets-client.js';
 export const SHARE_BUNDLE = 'share';
 export const SHARE_TOKEN_KEY = 'WRITE_TOKEN';
 export const SHARE_TOKEN_ENV_KEY = 'SHARE_WRITE_TOKEN';
@@ -113,10 +112,12 @@ export function storeWriteToken(token) {
             vars: {},
         };
     }
-    const store = bundleItemStore(bundle.backend, { noAcl: bundlePolicy(bundle) === 'never' });
-    store.set(secretsKeychainItem(bundle.name, SHARE_TOKEN_KEY), token);
+    // writeBundleWithItems decides the ACL (keychain backend) purely from
+    // `bundle.policy === 'never'` — the fresh-bundle case above sets it
+    // explicitly, and an existing bundle already carries its own explicit tier.
     bundle.vars[SHARE_TOKEN_KEY] = keychainRef(SHARE_TOKEN_KEY);
-    writeBundle(bundle);
+    const item = secretsKeychainItem(bundle.name, SHARE_TOKEN_KEY);
+    writeBundleWithItems(bundle, new Map([[item, token]]));
 }
 /** Read the raw write token from the `share` secrets bundle. */
 export function readWriteTokenFromBundle() {
@@ -178,6 +179,14 @@ export function readCloudflareCreds(bundle = DEFAULT_CF_BUNDLE, override) {
     if (override?.apiToken) {
         return { apiToken: override.apiToken, accountId: override.accountId ?? '' };
     }
+    // Check existence first (same guard as readShareToken above): resolving a
+    // missing bundle through the process client surfaces an opaque transport code
+    // (e.g. LOCKED), never naming the bundle the user typed — so name it here.
+    if (!bundleExists(bundle)) {
+        throw new Error(`The '${bundle}' bundle does not exist. ` +
+            `Pass credentials directly with --token <t> [--account <id>], or create it: ` +
+            `agents secrets add ${bundle} CLOUDFLARE_API_TOKEN`);
+    }
     const { env } = readAndResolveBundleEnv(bundle, {
         caller: 'share',
         // Setup is still a read; only `agents secrets unlock` may authenticate.

package/dist/lib/signin-badge.d.ts

@@ -1,5 +1,8 @@
 import type { AccountInfo } from './agents.js';
+import type { AuthVerdict } from './auth-health.js';
 import type { AgentId } from './types.js';
+export type AccountVerdict = Exclude<AuthVerdict, 'unconfigured' | 'error'> | 'missing' | 'per-device' | 'ready';
+export type AccountProvisioning = 'portable' | 'per-device';
 /**
  * The exact command that logs a given agent in — for warn banners and nudges.
  * Driven off the registry `cliCommand` with the per-agent subcommand overrides
@@ -8,6 +11,29 @@ import type { AgentId } from './types.js';
  * remaining agents (kimi, gemini, …) start their device/oauth flow on launch.
  */
 export declare function loginHint(agentId: AgentId): string;
+/**
+ * Exact action shown beside a non-live account. Every emitted command exists
+ * today — never a planned surface and never a hidden verb:
+ * - Per-device harnesses repair per box via `agents devices login`.
+ * - Named accounts re-auth through `agents accounts login <harness>#<name>`.
+ *   A known account with no slot on a headed device is onboarded with
+ *   `agents accounts add <harness> <name>`. A worker never runs an
+ *   interactive login — the hint is `add.ts`'s worker refusal (add on the
+ *   personal device; this box is provisioned from the durable credential).
+ * - Unnamed legacy homes use the same version-targeted command shape as
+ *   doctor, so the hint never logs a different/default home in by accident.
+ * - `unverified` emits nothing: the probe could not confirm state (e.g. a
+ *   worker whose token lacks the usage scope), so there is nothing to repair.
+ */
+export declare function fixFor(input: {
+    agent: AgentId;
+    verdict: AccountVerdict;
+    name?: string | null;
+    version?: string | null;
+    provisioning?: AccountProvisioning;
+    /** When false, this named account has no slot on this device yet. */
+    hasSlot?: boolean;
+}): string | null;
 /**
  * Whether `agents run` should probe login state before launching. True only for
  * a launch that actually opens the interactive TUI — where discovering a logged-out

package/dist/lib/signin-badge.js

@@ -9,7 +9,9 @@
  * on it (the run preflight) WARN and continue; they never block.
  */
 import chalk from 'chalk';
+import { addWorkerRefusal } from './accounts/add.js';
 import { AGENTS } from './agents.js';
+import { CONFIG_ENV_ISOLATED_AGENTS } from './installations/shims.js';
 /**
  * The exact command that logs a given agent in — for warn banners and nudges.
  * Driven off the registry `cliCommand` with the per-agent subcommand overrides
@@ -34,6 +36,46 @@ export function loginHint(agentId) {
             return cli;
     }
 }
+/**
+ * Exact action shown beside a non-live account. Every emitted command exists
+ * today — never a planned surface and never a hidden verb:
+ * - Per-device harnesses repair per box via `agents devices login`.
+ * - Named accounts re-auth through `agents accounts login <harness>#<name>`.
+ *   A known account with no slot on a headed device is onboarded with
+ *   `agents accounts add <harness> <name>`. A worker never runs an
+ *   interactive login — the hint is `add.ts`'s worker refusal (add on the
+ *   personal device; this box is provisioned from the durable credential).
+ * - Unnamed legacy homes use the same version-targeted command shape as
+ *   doctor, so the hint never logs a different/default home in by accident.
+ * - `unverified` emits nothing: the probe could not confirm state (e.g. a
+ *   worker whose token lacks the usage scope), so there is nothing to repair.
+ */
+export function fixFor(input) {
+    const { agent, verdict } = input;
+    if (verdict === 'live' || verdict === 'rate_limited' || verdict === 'unverified' || verdict === 'ready')
+        return null;
+    if (input.provisioning === 'per-device' || verdict === 'per-device') {
+        return `agents devices login --agents ${agent}`;
+    }
+    if (input.name) {
+        const worker = addWorkerRefusal(agent, input.name);
+        if (worker)
+            return worker;
+        if (input.hasSlot === false)
+            return `agents accounts add ${agent} ${input.name}`;
+        return `agents accounts login ${agent}#${input.name}`;
+    }
+    const version = input.version ?? null;
+    if (!version || !CONFIG_ENV_ISOLATED_AGENTS.includes(agent))
+        return loginHint(agent);
+    if (agent === 'claude')
+        return `agents run ${agent}@${version}, then /login`;
+    if (agent === 'codex' || agent === 'grok')
+        return `agents run ${agent}@${version} -- login`;
+    if (agent === 'opencode')
+        return `agents run ${agent}@${version} -- auth login`;
+    return `agents run ${agent}@${version}`;
+}
 /**
  * Whether `agents run` should probe login state before launching. True only for
  * a launch that actually opens the interactive TUI — where discovering a logged-out

package/dist/lib/staleness/detectors/workflows.js

@@ -1,115 +1,13 @@
-/**
- * Workflows detector — scans the agent-specific on-disk layout for synced
- * workflow names (Claude WORKFLOW.md trees, Kimi flow skills, Antigravity
- * global_workflows, Goose recipes, OpenClaw Lobster, Grok Rhai).
- */
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import * as yaml from 'yaml';
 import { capableAgents } from '../../capabilities.js';
-import { grokWorkflowMarker } from '../../workflows.js';
+import { workflowTarget } from '../../workflows-registry.js';
 import { lazyAgentMap } from '../writers/lazy-map.js';
 function buildWorkflowsDetector(agent) {
     return {
         kind: 'workflows',
         agent,
         list({ versionHome }) {
-            if (agent === 'kimi') {
-                const skillsDir = path.join(versionHome, '.kimi-code', 'skills');
-                if (!fs.existsSync(skillsDir))
-                    return [];
-                return fs.readdirSync(skillsDir, { withFileTypes: true })
-                    .filter(d => d.isDirectory() && fs.existsSync(path.join(skillsDir, d.name, 'SKILL.md')))
-                    .filter(d => {
-                    try {
-                        const skill = fs.readFileSync(path.join(skillsDir, d.name, 'SKILL.md'), 'utf-8');
-                        const lines = skill.split('\n');
-                        if (lines[0] !== '---')
-                            return false;
-                        const endIndex = lines.slice(1).findIndex(l => l === '---');
-                        if (endIndex < 0)
-                            return false;
-                        const parsed = yaml.parse(lines.slice(1, endIndex + 1).join('\n'));
-                        return parsed?.type === 'flow' && parsed.agents_workflow === d.name;
-                    }
-                    catch {
-                        return false;
-                    }
-                })
-                    .map(d => d.name);
-            }
-            if (agent === 'antigravity') {
-                // Antigravity user workflows are HOME-global and shared across versions,
-                // not version-isolated — see workflows.ts:antigravityWorkflowsDir(). agy
-                // scans the real ~/.gemini/config/global_workflows/, so the detector reads
-                // the same shared dir the writer targets (versionHome is intentionally unused).
-                const dir = path.join(process.env.HOME ?? os.homedir(), '.gemini', 'config', 'global_workflows');
-                if (!fs.existsSync(dir))
-                    return [];
-                return fs.readdirSync(dir, { withFileTypes: true })
-                    .filter(d => d.isFile() && d.name.endsWith('.md') && !d.name.startsWith('.'))
-                    .filter(d => {
-                    try {
-                        const content = fs.readFileSync(path.join(dir, d.name), 'utf-8');
-                        const lines = content.split('\n');
-                        if (lines[0] !== '---')
-                            return false;
-                        const endIndex = lines.slice(1).findIndex(l => l === '---');
-                        if (endIndex < 0)
-                            return false;
-                        const parsed = yaml.parse(lines.slice(1, endIndex + 1).join('\n'));
-                        return parsed?.agents_workflow === d.name.slice(0, -'.md'.length);
-                    }
-                    catch {
-                        return false;
-                    }
-                })
-                    .map(d => d.name.slice(0, -'.md'.length));
-            }
-            if (agent === 'goose') {
-                const recipesDir = path.join(versionHome, '.config', 'goose', 'recipes');
-                if (!fs.existsSync(recipesDir))
-                    return [];
-                return fs.readdirSync(recipesDir, { withFileTypes: true })
-                    .filter(d => d.isFile() && d.name.endsWith('.yaml') && !d.name.startsWith('.'))
-                    .map(d => d.name.slice(0, -'.yaml'.length));
-            }
-            if (agent === 'openclaw') {
-                const dir = path.join(versionHome, '.openclaw', 'workflows');
-                if (!fs.existsSync(dir))
-                    return [];
-                return fs.readdirSync(dir, { withFileTypes: true })
-                    .filter(d => d.isFile() && d.name.endsWith('.lobster') && !d.name.startsWith('.'))
-                    .filter(d => {
-                    try {
-                        const parsed = yaml.parse(fs.readFileSync(path.join(dir, d.name), 'utf-8'));
-                        const env = parsed && typeof parsed === 'object' && parsed.env && typeof parsed.env === 'object' && !Array.isArray(parsed.env)
-                            ? parsed.env
-                            : {};
-                        return env.AGENTS_CLI_WORKFLOW === d.name.slice(0, -'.lobster'.length);
-                    }
-                    catch {
-                        return false;
-                    }
-                })
-                    .map(d => d.name.slice(0, -'.lobster'.length));
-            }
-            if (agent === 'grok') {
-                const workflowsDir = path.join(versionHome, '.grok', 'workflows');
-                if (!fs.existsSync(workflowsDir))
-                    return [];
-                return fs.readdirSync(workflowsDir, { withFileTypes: true })
-                    .filter(d => d.isFile() && d.name.endsWith('.rhai') && !d.name.startsWith('.'))
-                    .filter(d => grokWorkflowMarker(path.join(workflowsDir, d.name)) === d.name.slice(0, -'.rhai'.length))
-                    .map(d => d.name.slice(0, -'.rhai'.length));
-            }
-            const workflowsDir = path.join(versionHome, 'workflows');
-            if (!fs.existsSync(workflowsDir))
-                return [];
-            return fs.readdirSync(workflowsDir, { withFileTypes: true })
-                .filter(d => d.isDirectory() && fs.existsSync(path.join(workflowsDir, d.name, 'WORKFLOW.md')))
-                .map(d => d.name);
+            const target = workflowTarget(agent);
+            return target.names(target.dir(versionHome));
         },
     };
 }

package/dist/lib/staleness/writers/workflows.js

@@ -1,5 +1,6 @@
 import { capableAgents } from '../../capabilities.js';
-import { listInstalledWorkflows, syncWorkflowToVersion } from '../../workflows.js';
+import { listInstalledWorkflows } from '../../workflows.js';
+import { syncWorkflowToVersion } from '../../workflows-registry.js';
 import { lazyAgentMap } from './lazy-map.js';
 function buildWorkflowsWriter(agent) {
     return {

package/dist/lib/state.d.ts

@@ -123,10 +123,13 @@ export declare function getUserSecretsDir(): string;
  * AGENTS_SECRETS_DB without racing the module-load capture of USER_SECRETS_DIR —
  * mirrors the AGENTS_EVENTS_PATH / AGENTS_DEVICES_DIR escape hatches. Holds only
  * value-free usage telemetry (which bundle was created/imported/exported/viewed/
- * accessed/unlocked, when, by whom), never a secret value. It is a derived index
- * fed FROM the emitSecretAudit chokepoint alongside the append-only
- * ~/.agents/.history/events/YYYY-MM-DD audit log — the same way sessions.db indexes session
- * metadata off the real session flow — not a second write path.
+ * accessed/unlocked, when, by whom), never a secret value. It used to be a
+ * derived index fed FROM the in-repo secrets engine's own emitSecretAudit
+ * chokepoint — not a second write path — the same way sessions.db indexes
+ * session metadata off the real session flow. That engine (and its audit
+ * emission) moved out of this repo entirely with the standalone `secrets`
+ * engine (PHNX-3989), so nothing writes this DB from agents-cli today; the
+ * read-side queries in `analytics/usage-db.ts` have no current caller.
  */
 export declare function getSecretsDbPath(): string;
 /**

package/dist/lib/state.js

@@ -396,10 +396,13 @@ export function getUserSecretsDir() { return USER_SECRETS_DIR; }
  * AGENTS_SECRETS_DB without racing the module-load capture of USER_SECRETS_DIR —
  * mirrors the AGENTS_EVENTS_PATH / AGENTS_DEVICES_DIR escape hatches. Holds only
  * value-free usage telemetry (which bundle was created/imported/exported/viewed/
- * accessed/unlocked, when, by whom), never a secret value. It is a derived index
- * fed FROM the emitSecretAudit chokepoint alongside the append-only
- * ~/.agents/.history/events/YYYY-MM-DD audit log — the same way sessions.db indexes session
- * metadata off the real session flow — not a second write path.
+ * accessed/unlocked, when, by whom), never a secret value. It used to be a
+ * derived index fed FROM the in-repo secrets engine's own emitSecretAudit
+ * chokepoint — not a second write path — the same way sessions.db indexes
+ * session metadata off the real session flow. That engine (and its audit
+ * emission) moved out of this repo entirely with the standalone `secrets`
+ * engine (PHNX-3989), so nothing writes this DB from agents-cli today; the
+ * read-side queries in `analytics/usage-db.ts` have no current caller.
  */
 export function getSecretsDbPath() {
     return process.env.AGENTS_SECRETS_DB ?? path.join(USER_SECRETS_DIR, 'secrets.db');
@@ -1332,7 +1335,9 @@ export function writeMetaUnlocked(meta) {
     // In-flight connect attempts (PHNX-3940), device-scoped like homes.
     const accountsPending = deviceAccounts?.pendingConnects && Object.keys(deviceAccounts.pendingConnects).length > 0
         ? deviceAccounts.pendingConnects : undefined;
-    if (accountsNative || accountsBindings || accountsHomes || accountsPending) {
+    const accountsSlots = deviceAccounts?.slots && Object.keys(deviceAccounts.slots).length > 0
+        ? deviceAccounts.slots : undefined;
+    if (accountsNative || accountsBindings || accountsHomes || accountsPending || accountsSlots) {
         const da = {};
         if (accountsNative)
             da.native = accountsNative;
@@ -1342,6 +1347,8 @@ export function writeMetaUnlocked(meta) {
             da.homes = accountsHomes;
         if (accountsPending)
             da.pendingConnects = accountsPending;
+        if (accountsSlots)
+            da.slots = accountsSlots;
         doc.accounts = da;
     }
     else if (writesDeviceAccounts)
@@ -1487,12 +1494,16 @@ function overlayMachineLocal(meta) {
                 if (acc.pendingConnects !== undefined && !isMap(acc.pendingConnects)) {
                     throw new Error(`Device config corrupted at ${devicePath}: accounts.pendingConnects must be a map.`);
                 }
+                if (acc.slots !== undefined && !isMap(acc.slots)) {
+                    throw new Error(`Device config corrupted at ${devicePath}: accounts.slots must be a map.`);
+                }
                 const native = acc.native;
                 const bindings = acc.bindings;
                 const homes = acc.homes;
                 const pendingConnects = acc.pendingConnects;
-                if (native || bindings || homes || pendingConnects)
-                    meta.deviceAccounts = { ...(native ? { native } : {}), ...(bindings ? { bindings } : {}), ...(homes ? { homes } : {}), ...(pendingConnects ? { pendingConnects } : {}) };
+                const slots = acc.slots;
+                if (native || bindings || homes || pendingConnects || slots)
+                    meta.deviceAccounts = { ...(native ? { native } : {}), ...(bindings ? { bindings } : {}), ...(homes ? { homes } : {}), ...(pendingConnects ? { pendingConnects } : {}), ...(slots ? { slots } : {}) };
             }
             if (Object.prototype.hasOwnProperty.call(dm, 'routines')) {
                 if (!Array.isArray(dm.routines) || dm.routines.some((name) => typeof name !== 'string')) {

package/dist/lib/sync-umbrella.js

@@ -17,8 +17,8 @@
  */
 import { pullRepo, adoptUserRepoIfNeeded } from './git.js';
 import { getUserAgentsDir, getEnabledExtraRepos } from './state.js';
-import { listRemoteBundles, pullBundle } from './secrets/sync.js';
-import { SYNC_PASSPHRASE_ENV } from './secrets/sync-passphrase.js';
+import { listRemoteBundles, pullBundle } from './secrets-client.js';
+import { SYNC_PASSPHRASE_ENV } from './sync-passphrase.js';
 /**
  * Decide which stages run. Pure — no I/O. Semantics:
  *   bare (no flags)        fetch repos, then reconcile

package/dist/lib/teams/agents.js

@@ -21,7 +21,7 @@ import { debug } from './debug.js';
 import { getAgentsDir as getSystemAgentsDir, getShimsDir } from '../state.js';
 import { AGENTS, getAccountInfo } from '../agents.js';
 import { resolveVersion, isVersionInstalled, verifyInstalledBinaryLaunches } from '../installations/versions.js';
-import { sanitizeProcessEnv } from '../secrets/bundles.js';
+import { sanitizeProcessEnv } from '../secrets-client.js';
 import { resolveActor, actorEnv } from '../actor.js';
 import { recordRunName } from '../session/run-names.js';
 import { sshExec, shellQuote } from '../ssh-exec.js';