@phnx-labs/agents-cli 1.22.83 → 1.22.85

package/dist/lib/summarizer/summarize.d.ts

@@ -20,6 +20,13 @@ export interface SummarizeProgress {
     plan?: string;
     /** Coarse lifecycle phase (running / waiting / idle / …), when known. */
     phase?: string;
+    /**
+     * The agent's own narration headlines, oldest first — the last K steps the
+     * daemon's timeline fold produced (PHNX-3939). Optional: many sessions never
+     * write a checklist, so this is often the only evidence of progress the model
+     * gets, but a row with no folded timeline simply passes none.
+     */
+    steps?: string[];
 }
 /** The validated model output. `at` timestamps are stamped by the caller. */
 export interface SummarizeResult {

package/dist/lib/summarizer/summarize.js

@@ -32,6 +32,9 @@ export function buildSummarizeUserMessage(prompt, progress) {
     }
     if (progress.plan)
         parts.push(`PLAN:\n${progress.plan.trim().slice(0, 4000)}`);
+    if (progress.steps?.length) {
+        parts.push(`WHAT THE AGENT SAID IT WAS DOING (oldest first):\n${progress.steps.map((step) => `- ${step}`).join('\n')}`);
+    }
     return parts.join('\n\n');
 }
 /**

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;

package/dist/lib/workflows-registry.js

@@ -0,0 +1,280 @@
+/**
+ * Workflow target registry — the ONE place that says how each
+ * workflows-capable harness stores a synced workflow on disk.
+ *
+ * `WORKFLOW_TARGETS` is the declarative shape (container dir, file layout,
+ * transform, ownership marker); the engine below (`listWorkflowsForAgent`,
+ * `syncWorkflowToVersion`, `removeWorkflowFromVersion`,
+ * `workflowContentMatches`) and the staleness detector are generic over it, so
+ * adding a harness is one entry here plus its `workflows` capability flag in
+ * `agent-spec/agents.ts` — never another `if (agent === '...')` arm in the
+ * writer, the lister, the remover, the doctor drift check, and the detector.
+ * A completeness test pins `Object.keys(WORKFLOW_TARGETS)` to
+ * `capableAgents('workflows')` so the flag and the shape cannot drift.
+ *
+ * Same pattern as `SUBAGENT_TARGETS` in `subagents-registry.ts`.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { getVersionHomePath } from './installations/versions.js';
+import { dirsContentMatch, normalizeResourceContent } from './resource-content-diff.js';
+import { antigravityWorkflowMarker, antigravityWorkflowsDir, grokWorkflowMarker, kimiWorkflowMarker, openclawWorkflowMarker, parseWorkflowFrontmatter, renderGooseRecipeYaml, selectedWorkflowSubagents, transformWorkflowForAntigravity, transformWorkflowForGrok, transformWorkflowForKimi, transformWorkflowForOpenClaw, writeGooseSubrecipe, } from './workflows.js';
+function readdirSafe(dir) {
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+function renderedMatches(homePath, expected) {
+    let actual;
+    try {
+        actual = fs.readFileSync(homePath, 'utf-8');
+    }
+    catch {
+        return false;
+    }
+    return normalizeResourceContent(actual) === normalizeResourceContent(expected);
+}
+// ── layouts ──────────────────────────────────────────────────────────────────
+/**
+ * One rendered `<name><ext>` file per workflow, owned via a marker the
+ * transform embeds (antigravity, openclaw, grok).
+ */
+function renderedFile(opts) {
+    const file = (dir, name) => path.join(dir, `${name}${opts.ext}`);
+    return {
+        label: opts.label,
+        dir: opts.dir,
+        names(dir) {
+            return readdirSafe(dir)
+                .filter((d) => d.isFile() && d.name.endsWith(opts.ext) && !d.name.startsWith('.'))
+                .map((d) => d.name.slice(0, -opts.ext.length))
+                .filter((base) => opts.marker(file(dir, base)) === base);
+        },
+        write(dir, wf) {
+            fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(file(dir, wf.name), opts.transform(wf.path, wf.name), 'utf-8');
+        },
+        occupied(dir, name) {
+            const target = file(dir, name);
+            return fs.existsSync(target) ? [target] : [];
+        },
+        managed(dir, name) {
+            const target = file(dir, name);
+            if (!fs.existsSync(target))
+                return null;
+            return opts.marker(target) === name;
+        },
+        matches(dir, wf) {
+            return renderedMatches(file(dir, wf.name), opts.transform(wf.path, wf.name));
+        },
+    };
+}
+/**
+ * Kimi flow skill: a `<name>/SKILL.md` directory whose frontmatter carries
+ * `type: flow` and the `agents_workflow` marker.
+ */
+const kimiFlowSkill = {
+    label: 'Kimi skill',
+    dir: (versionHome) => path.join(versionHome, '.kimi-code', 'skills'),
+    names(dir) {
+        return readdirSafe(dir)
+            .filter((d) => d.isDirectory() && fs.existsSync(path.join(dir, d.name, 'SKILL.md')))
+            .filter((d) => kimiWorkflowMarker(path.join(dir, d.name, 'SKILL.md')) === d.name)
+            .map((d) => d.name);
+    },
+    write(dir, wf) {
+        const skillDir = path.join(dir, wf.name);
+        fs.mkdirSync(skillDir, { recursive: true });
+        fs.writeFileSync(path.join(skillDir, 'SKILL.md'), transformWorkflowForKimi(wf.path, wf.name), 'utf-8');
+    },
+    occupied(dir, name) {
+        const skillDir = path.join(dir, name);
+        return fs.existsSync(skillDir) ? [skillDir] : [];
+    },
+    managed(dir, name) {
+        const skillDir = path.join(dir, name);
+        if (!fs.existsSync(skillDir))
+            return null;
+        return kimiWorkflowMarker(path.join(skillDir, 'SKILL.md')) === name;
+    },
+    matches(dir, wf) {
+        return renderedMatches(path.join(dir, wf.name, 'SKILL.md'), transformWorkflowForKimi(wf.path, wf.name));
+    },
+};
+/**
+ * Goose recipe: `<name>.yaml` plus a `<name>.subrecipes/` dir holding one YAML
+ * per selected workflow subagent. Goose has no ownership marker, so presence
+ * is ownership.
+ */
+const gooseRecipe = {
+    label: 'Goose recipe',
+    dir: (versionHome) => path.join(versionHome, '.config', 'goose', 'recipes'),
+    names(dir) {
+        return readdirSafe(dir)
+            .filter((d) => d.isFile() && d.name.endsWith('.yaml') && !d.name.startsWith('.'))
+            .map((d) => d.name.slice(0, -'.yaml'.length));
+    },
+    write(dir, wf) {
+        const frontmatter = parseWorkflowFrontmatter(wf.path);
+        const recipeYaml = frontmatter ? renderGooseRecipeYaml(wf.path, wf.name) : null;
+        if (!frontmatter || recipeYaml == null) {
+            throw new Error(`Workflow '${wf.name}' has invalid WORKFLOW.md frontmatter`);
+        }
+        const subrecipesDir = path.join(dir, `${wf.name}.subrecipes`);
+        fs.mkdirSync(dir, { recursive: true });
+        if (fs.existsSync(subrecipesDir)) {
+            fs.rmSync(subrecipesDir, { recursive: true, force: true });
+        }
+        for (const subagentName of selectedWorkflowSubagents(wf.path, frontmatter.allowedAgents)) {
+            writeGooseSubrecipe(wf.path, subagentName, subrecipesDir);
+        }
+        fs.writeFileSync(path.join(dir, `${wf.name}.yaml`), recipeYaml, 'utf-8');
+    },
+    occupied(dir, name) {
+        return [path.join(dir, `${name}.yaml`), path.join(dir, `${name}.subrecipes`)].filter((p) => fs.existsSync(p));
+    },
+    managed(dir, name) {
+        return gooseRecipe.occupied(dir, name).length > 0 ? true : null;
+    },
+    matches(dir, wf) {
+        const expected = renderGooseRecipeYaml(wf.path, wf.name);
+        if (expected == null)
+            return false;
+        return renderedMatches(path.join(dir, `${wf.name}.yaml`), expected);
+    },
+};
+/**
+ * The canonical bundle copied verbatim: `<name>/WORKFLOW.md` (plus its
+ * subagents/ tree) under `{versionHome}/workflows/`. No marker — the dir is
+ * agents-cli's by construction.
+ */
+const workflowBundle = {
+    label: 'Workflow',
+    dir: (versionHome) => path.join(versionHome, 'workflows'),
+    names(dir) {
+        return readdirSafe(dir)
+            .filter((d) => d.isDirectory() && fs.existsSync(path.join(dir, d.name, 'WORKFLOW.md')))
+            .map((d) => d.name);
+    },
+    write(dir, wf) {
+        const target = path.join(dir, wf.name);
+        fs.mkdirSync(dir, { recursive: true });
+        if (fs.existsSync(target)) {
+            fs.rmSync(target, { recursive: true, force: true });
+        }
+        fs.cpSync(wf.path, target, { recursive: true });
+    },
+    occupied(dir, name) {
+        const target = path.join(dir, name);
+        return fs.existsSync(target) ? [target] : [];
+    },
+    managed(dir, name) {
+        return fs.existsSync(path.join(dir, name)) ? true : null;
+    },
+    matches(dir, wf) {
+        return dirsContentMatch(wf.path, path.join(dir, wf.name));
+    },
+};
+// ── the registry ─────────────────────────────────────────────────────────────
+/**
+ * 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 const WORKFLOW_TARGETS = {
+    claude: workflowBundle,
+    kimi: kimiFlowSkill,
+    goose: gooseRecipe,
+    // Antigravity discovers workflows in the shared HOME-global dir `agy` scans
+    // at startup, never in a version home — see `antigravityWorkflowsDir`.
+    antigravity: renderedFile({
+        label: 'Antigravity workflow',
+        dir: () => antigravityWorkflowsDir(),
+        ext: '.md',
+        transform: transformWorkflowForAntigravity,
+        marker: antigravityWorkflowMarker,
+    }),
+    openclaw: renderedFile({
+        label: 'OpenClaw workflow',
+        dir: (versionHome) => path.join(versionHome, '.openclaw', 'workflows'),
+        ext: '.lobster',
+        transform: transformWorkflowForOpenClaw,
+        marker: openclawWorkflowMarker,
+    }),
+    grok: renderedFile({
+        label: 'Grok workflow',
+        dir: (versionHome) => path.join(versionHome, '.grok', 'workflows'),
+        ext: '.rhai',
+        transform: transformWorkflowForGrok,
+        marker: grokWorkflowMarker,
+    }),
+};
+/** The registered target for `agent`; throws for a harness that has none. */
+export function workflowTarget(agent) {
+    const target = WORKFLOW_TARGETS[agent];
+    if (!target) {
+        throw new Error(`${agent} has no workflow target (not in capableAgents('workflows'))`);
+    }
+    return target;
+}
+// ── the generic engine ───────────────────────────────────────────────────────
+/** Workflow names agents-cli has synced into `versionHome` for `agent`. */
+export function listWorkflowsForAgent(agent, versionHome) {
+    const target = workflowTarget(agent);
+    return target.names(target.dir(versionHome));
+}
+/**
+ * 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 function syncWorkflowToVersion(workflowPath, name, agent, versionHome) {
+    const target = workflowTarget(agent);
+    const dir = target.dir(versionHome);
+    try {
+        if (target.managed(dir, name) === false) {
+            return { success: false, error: `${target.label} '${name}' already exists and is not managed by agents-cli` };
+        }
+        target.write(dir, { name, path: workflowPath });
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+}
+/** Remove workflow `name` from `agent@version`; refuses a user-authored file. */
+export function removeWorkflowFromVersion(agent, version, name) {
+    const target = workflowTarget(agent);
+    const dir = target.dir(getVersionHomePath(agent, version));
+    const occupied = target.occupied(dir, name);
+    if (occupied.length === 0) {
+        return { success: false, error: `Workflow '${name}' not synced to ${agent}@${version}` };
+    }
+    if (target.managed(dir, name) === false) {
+        return { success: false, error: `${target.label} '${name}' is not managed by agents-cli` };
+    }
+    try {
+        for (const entry of occupied) {
+            fs.rmSync(entry, { recursive: true, force: true });
+        }
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+}
+/**
+ * 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 function workflowContentMatches(agent, versionHome, name, sourcePath) {
+    const target = workflowTarget(agent);
+    return target.matches(target.dir(versionHome), { name, path: sourcePath });
+}

package/dist/lib/workflows.d.ts

@@ -373,29 +373,29 @@ export declare function removeWorkflow(name: string): {
     success: boolean;
     error?: string;
 };
-/** List workflow names synced into a specific agent version home. */
-export declare function listWorkflowsForAgent(agent: AgentId, versionHome: string): string[];
 /**
- * True when workflow `name` materialized in `agent`'s version home byte-matches
- * what the writer would produce NOW from `sourcePath` — the content-drift
- * predicate `agents doctor` uses. Layout-aware per the same per-harness map the
- * writer (`syncWorkflowToVersion`) and detector use: Claude/default copy the
- * whole WORKFLOW.md tree (recursive dir compare); Kimi/Antigravity/OpenClaw/Grok
- * render one transformed file; Goose renders a recipe YAML. Antigravity's target
- * is the shared HOME-global dir, not a per-version path. Returns false when the
- * home copy is absent (surfaced as `missing` at the name level, not here).
+ * Antigravity user workflows are NOT version-isolated. `agy` scans a single,
+ * shared, HOME-global directory at startup — `~/.gemini/config/global_workflows/`
+ * — and that dir is a real directory in the user's home, never symlinked into a
+ * per-version home (only `~/.gemini/antigravity-cli` is version-scoped). Writing
+ * into a version home therefore lands somewhere agy never reads. So every
+ * antigravity version resolves to the same real shared dir; `versionHome` is
+ * intentionally ignored. (Verified via strace of `agy`: it opens
+ * `$HOME/.gemini/config/global_workflows/<name>.md` and never the version home.)
  */
-export declare function workflowContentMatches(agent: AgentId, versionHome: string, name: string, sourcePath: string): boolean;
-/** Copy a workflow directory into a version home at {versionHome}/workflows/<name>/. */
-export declare function syncWorkflowToVersion(workflowPath: string, name: string, agent: AgentId, versionHome: string): {
-    success: boolean;
-    error?: string;
-};
-/** Remove a workflow from a specific agent version home. */
-export declare function removeWorkflowFromVersion(agent: AgentId, version: string, name: string): {
-    success: boolean;
-    error?: string;
-};
+export declare function antigravityWorkflowsDir(): string;
+export declare function selectedWorkflowSubagents(workflowPath: string, allowedAgents?: string[]): string[];
+export declare function writeGooseSubrecipe(workflowPath: string, subrecipeName: string, destDir: string): void;
+/**
+ * Render the main Goose recipe YAML for a workflow — the exact bytes the Goose
+ * `WORKFLOW_TARGETS` entry writes to `<name>.yaml`. Extracted so the writer and
+ * the doctor content-drift check (`matches`) render from ONE source and can
+ * never disagree. Returns null on invalid frontmatter.
+ */
+export declare function renderGooseRecipeYaml(workflowPath: string, name: string): string | null;
+export declare function kimiWorkflowMarker(filePath: string): string | null;
+export declare function antigravityWorkflowMarker(filePath: string): string | null;
+export declare function openclawWorkflowMarker(filePath: string): string | null;
 /** Iterate all installed (agent, version) pairs that support workflows. */
 export declare function iterWorkflowsCapableVersions(filter?: {
     agent?: AgentId;