@phnx-labs/agents-cli 1.22.84 → 1.22.86

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';

package/dist/lib/types.d.ts

@@ -11,6 +11,61 @@ import type { FeedBroadcastConfig } from './feed-broadcast.js';
 export declare const AGENT_IDS: readonly ["claude", "codex", "gemini", "cursor", "opencode", "openclaw", "copilot", "amp", "goose", "antigravity", "grok", "kimi", "droid", "hermes", "muse", "warp"];
 export type AgentId = typeof AGENT_IDS[number];
 export declare function isAgentId(value: string): value is AgentId;
+/**
+ * How THIS box authenticates one account slot (PHNX-3940). Native OAuth stays
+ * on the headed device that minted it; a worker uses a durable credential;
+ * per-device harnesses log in on each box.
+ */
+export type AccountAuthMode = 'native' | 'durable' | 'per-device';
+/**
+ * Live auth verdict vocabulary (mirrors lib/auth-health.ts AuthVerdict).
+ * Duplicated here so Meta can name the field without importing the probe module.
+ */
+export type AuthVerdictName = 'live' | 'revoked' | 'expired' | 'rate_limited' | 'unverified' | 'unconfigured' | 'error';
+/**
+ * Per-(account, device) materialization of an Account row. Lives in the device
+ * doc (`deviceAccounts.slots`), never the fleet-synced central file — slot
+ * paths are per box. Native OAuth files stay inside `slotDir` on this device.
+ */
+export interface DeviceAccountSlot {
+    accountId: string;
+    /** `~/.agents/.history/accounts/<harness>/<accountId>/` — HOME-shaped, no binary. */
+    slotDir: string;
+    authMode: AccountAuthMode;
+    verdict: AuthVerdictName;
+    checkedAt?: string;
+    /** Onboarding in flight; cleared once the account row is registered. */
+    pending?: boolean;
+}
+/** Whether a worker can be provisioned from a durable credential, or must log in per box. */
+export type AccountProvisioning = 'portable' | 'per-device';
+/**
+ * Pointer to the durable worker credential in a reserved store. Never the
+ * secret value itself — that stays in the secrets backend.
+ */
+export interface NativeAccountWorkerCredential {
+    bundle: string;
+    key: string;
+    kind: 'setup-token' | 'api-key';
+    mintedAt: string;
+}
+/**
+ * Fleet-synced native-account row (central `accounts.native` or a device-scoped
+ * copy). Additive fields from account-model v2 (PHNX-3940); existing rows
+ * migrate in place with these absent.
+ */
+export interface NativeAccountRecord {
+    id: string;
+    name: string;
+    agent: AgentId;
+    identityKey: string;
+    identityLabel?: string;
+    scope: 'version' | 'device';
+    workerCredential?: NativeAccountWorkerCredential;
+    provisioning?: AccountProvisioning;
+    /** Device that minted this row (the headed origin). */
+    createdOn?: string;
+}
 /** How `agents run <agent>` chooses an installed version when none is pinned. */
 export type RunStrategy = 'pinned' | 'available' | 'balanced';
 export type RunEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max' | 'auto';
@@ -833,14 +888,7 @@ export interface Meta {
          * the harness home. Central-synced via agents.yaml; labels bind to
          * `(agent, identityKey)`.
          */
-        native?: Record<string, {
-            id: string;
-            name: string;
-            agent: AgentId;
-            identityKey: string;
-            identityLabel?: string;
-            scope: 'version' | 'device';
-        }>;
+        native?: Record<string, NativeAccountRecord>;
         /** Exact installation/custom-harness target -> stable account id. */
         bindings?: Record<string, string>;
     };
@@ -854,38 +902,31 @@ export interface Meta {
      * natives) and every device doc's block; only this machine writes this key.
      */
     deviceAccounts?: {
-        native?: Record<string, {
-            id: string;
-            name: string;
-            agent: AgentId;
-            identityKey: string;
-            identityLabel?: string;
-            scope: 'version' | 'device';
-        }>;
+        native?: Record<string, NativeAccountRecord>;
         bindings?: Record<string, string>;
         /**
-         * THIS box's account⇄home map (PHNX-3940): stable account id → the local
-         * installation label whose isolated home hosts that account's native login,
-         * as created by `agents accounts connect`. It is DEVICE-scoped on purpose —
-         * one account materializes a different home per host, and the label a box
-         * minted must never be assumed to exist on another box — so it lives in the
-         * device doc, never the fleet-synced central `accounts.native` identity row.
-         * A reconnect reads this to reuse the exact home even when its credential has
-         * expired (so local signed-in discovery can no longer find it).
+         * THIS box's leftover account⇄home map (PHNX-3940): stable account id → a
+         * local installation label (`acct-*` from the retired connect verb). Device-
+         * scoped: a label minted here is not assumed to exist on another box, so it
+         * lives in the device doc, never the fleet-synced central `accounts.native`
+         * identity row. `nativeAccountHome` still reads it so T5/T7 can resolve a
+         * legacy home; spawn-time HOME is {@link DeviceAccountSlot slots}.
          */
         homes?: Record<string, string>;
         /**
-         * THIS box's IN-FLIGHT `agents accounts connect` attempts (PHNX-3940):
-         * `${agent}:${name}` (lowercased) → the opaque slot minted for that attempt,
-         * BEFORE its login completed. It exists so a failed/cancelled named connect
-         * retries into the SAME fresh home instead of orphaning a new one each time,
-         * WITHOUT a deterministic name→slot function (which would recompute an
-         * already-taken slot after a rename and overwrite another account's login —
-         * the security flaw this replaces). It is cleared the moment the account is
-         * registered, so a live pending slot is by definition not yet an account's
-         * home. Device-scoped for the same reason as {@link homes}.
+         * Leftover in-flight connect map from the retired verb
+         * (PHNX-3940). No writer remains; state still round-trips the field so an
+         * older device doc does not fail to load.
          */
         pendingConnects?: Record<string, string>;
+        /**
+         * THIS box's account slots (PHNX-3940): stable account id → HOME-shaped
+         * dir under `~/.agents/.history/accounts/<harness>/<accountId>/`. Device-
+         * scoped: a slot path is local and a native OAuth file never leaves this
+         * box. Replaces `homes` as the spawn-time HOME; `homes` remains the
+         * installation-label map so leftover `acct-*` labels still resolve.
+         */
+        slots?: Record<string, DeviceAccountSlot>;
     };
     agents?: Partial<Record<AgentId, string>>;
     /**

package/dist/lib/view-types.d.ts

@@ -2,7 +2,7 @@ import type { ConfiguredModelSource } from './models.js';
 import type { ProfileSummary } from './profiles.js';
 import type { AgentId } from './types.js';
 import type { AuthVerdict } from './auth-health.js';
-import type { NativeAccountCatalogRow } from './account-catalog.js';
+import type { AccountListEntryJson } from './account-catalog.js';
 export type SyncState = 'synced' | 'new' | 'modified' | 'deleted';
 export interface ViewJsonVersion {
     /** Stable installation label; retained for existing machine consumers. */
@@ -69,8 +69,11 @@ export interface ViewJsonVersion {
 export interface ViewJsonAgent {
     agent: AgentId;
     versions: ViewJsonVersion[];
-    /** Account-first projection, additive so older consumers keep working. */
-    accounts?: NativeAccountCatalogRow[];
+    /**
+     * The same public JSON v2 account projection `accounts list --json` emits —
+     * never the internal catalog row, so consumers (AGI EXT) read one shape.
+     */
+    accounts?: AccountListEntryJson[];
     harnesses: ProfileSummary[];
 }
 export type ResourceSection = 'commands' | 'skills' | 'mcp' | 'memory' | 'hooks' | 'workflows' | 'plugins';

package/dist/lib/workflows-registry.d.ts

@@ -0,0 +1,71 @@
+import type { AgentId } from './types.js';
+/** A central workflow bundle: its synced name and the source dir holding WORKFLOW.md. */
+export interface WorkflowSource {
+    name: string;
+    path: string;
+}
+/**
+ * The complete on-disk contract for one harness's workflows. Every operation
+ * is expressed here so the engine below never branches on the agent id.
+ */
+export interface WorkflowTarget {
+    /** Noun used in ownership errors, e.g. "Kimi skill", "Grok workflow". */
+    readonly label: string;
+    /**
+     * Absolute container dir for `versionHome`. A harness whose native store is
+     * HOME-global (antigravity) ignores `versionHome` and resolves from `$HOME`.
+     */
+    dir(versionHome: string): string;
+    /** Names of the workflows in `dir` that agents-cli manages (lister + detector). */
+    names(dir: string): string[];
+    /** Materialize `wf` into `dir`. Throws on an invalid source or fs error. */
+    write(dir: string, wf: WorkflowSource): void;
+    /** Paths workflow `name` occupies in `dir`; empty when it is not installed. */
+    occupied(dir: string, name: string): string[];
+    /**
+     * Ownership of what sits at `name` in `dir`: `null` when nothing is there,
+     * `true` when agents-cli wrote it (or the format has no ownership marker),
+     * `false` when a user-authored file of the same name is in the way.
+     */
+    managed(dir: string, name: string): boolean | null;
+    /**
+     * True when the installed copy byte-matches what `write` would render from
+     * `wf.path` NOW — the drift predicate `agents doctor` uses. Re-renders the
+     * current source through the same transform the writer uses (never a stored
+     * hash), so a body edit to the source surfaces as drift under an unchanged name.
+     */
+    matches(dir: string, wf: WorkflowSource): boolean;
+}
+/**
+ * Single source of truth for how each workflows-capable harness stores
+ * workflows. The keys MUST match `capableAgents('workflows')` (the `workflows`
+ * flag in `agent-spec/agents.ts`): the capability flag is the version gate,
+ * this table is the shape.
+ */
+export declare const WORKFLOW_TARGETS: Partial<Record<AgentId, WorkflowTarget>>;
+/** The registered target for `agent`; throws for a harness that has none. */
+export declare function workflowTarget(agent: AgentId): WorkflowTarget;
+/** Workflow names agents-cli has synced into `versionHome` for `agent`. */
+export declare function listWorkflowsForAgent(agent: AgentId, versionHome: string): string[];
+/**
+ * Materialize the central bundle at `workflowPath` as `name` in `agent`'s
+ * `versionHome`, in that harness's native layout. Refuses to clobber a
+ * user-authored file of the same name (the ownership marker is the tell) and
+ * is idempotent over an agents-cli-managed one.
+ */
+export declare function syncWorkflowToVersion(workflowPath: string, name: string, agent: AgentId, versionHome: string): {
+    success: boolean;
+    error?: string;
+};
+/** Remove workflow `name` from `agent@version`; refuses a user-authored file. */
+export declare function removeWorkflowFromVersion(agent: AgentId, version: string, name: string): {
+    success: boolean;
+    error?: string;
+};
+/**
+ * True when workflow `name` materialized in `agent`'s `versionHome` byte-matches
+ * what the writer would produce NOW from `sourcePath` — the content-drift
+ * predicate `agents doctor` uses. Returns false when the home copy is absent
+ * (surfaced as `missing` at the name level, not here).
+ */
+export declare function workflowContentMatches(agent: AgentId, versionHome: string, name: string, sourcePath: string): boolean;