@phnx-labs/agents-cli 1.20.60 → 1.20.62

package/dist/lib/goose-commands.js

@@ -0,0 +1,176 @@
+/**
+ * Goose slash-command install/remove/list/compare.
+ *
+ * Goose has no native slash-command file format — a slash command is a recipe
+ * YAML file registered in `~/.config/goose/config.yaml` under a `slash_commands`
+ * array: `[{ command: "<name>", recipe_path: "<abs path to recipe.yaml>" }]`.
+ * (See goose-docs.ai context-engineering/slash-commands.)
+ *
+ * agents-cli writes each command's recipe to `<versionHome>/.config/goose/commands/
+ * <name>.yaml` — a dir distinct from the workflow recipes dir
+ * (`.config/goose/recipes/`) so the workflow detector never treats a command
+ * recipe as a workflow — and registers/unregisters the `slash_commands` entry in
+ * `config.yaml` via a read-modify-write that preserves every other key
+ * (`mcp_servers`, `extensions`, …). Under agents-cli version isolation HOME is the
+ * version home, so both files live under it and the absolute `recipe_path`
+ * resolves correctly at goose runtime.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'yaml';
+import { safeJoin } from './paths.js';
+import { markdownToGooseRecipe } from './convert.js';
+/** Directory holding Goose slash-command recipe YAML files in a version home. */
+export function gooseCommandsDir(versionHome) {
+    return path.join(versionHome, '.config', 'goose', 'commands');
+}
+/** Path to the Goose config.yaml (holds the `slash_commands` registry) in a version home. */
+export function gooseCommandConfigPath(versionHome) {
+    return path.join(versionHome, '.config', 'goose', 'config.yaml');
+}
+/**
+ * Read the goose config.yaml as a mutable object. Throws — rather than returning
+ * `{}` — when a NON-EMPTY file fails to parse or isn't a mapping, so the caller
+ * (which rewrites the whole file) never silently clobbers a real user config
+ * (`mcp_servers`, `GOOSE_MODEL`, `extensions`, …). A missing or genuinely empty
+ * file returns `{}`.
+ */
+function readGooseConfig(configPath) {
+    if (!fs.existsSync(configPath))
+        return {};
+    const raw = fs.readFileSync(configPath, 'utf-8');
+    if (raw.trim() === '')
+        return {};
+    let parsed;
+    try {
+        parsed = yaml.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Refusing to rewrite goose config at ${configPath}: existing file is not valid YAML ` +
+            `(${err.message}). Fix or remove it, then re-sync.`);
+    }
+    if (parsed === null || parsed === undefined)
+        return {}; // comments/whitespace only
+    if (typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`Refusing to rewrite goose config at ${configPath}: expected a YAML mapping but found ` +
+            `${Array.isArray(parsed) ? 'a list' : typeof parsed}.`);
+    }
+    return parsed;
+}
+function readSlashCommands(config) {
+    const raw = config.slash_commands;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((e) => !!e && typeof e === 'object' && typeof e.command === 'string');
+}
+/**
+ * Register (or update) a `slash_commands` entry for `commandName` pointing at
+ * `recipePath`, preserving every other config key and other entries. Idempotent.
+ */
+function registerSlashCommand(configPath, commandName, recipePath) {
+    const config = readGooseConfig(configPath);
+    const entries = readSlashCommands(config);
+    const existing = entries.find((e) => e.command === commandName);
+    if (existing && existing.recipe_path === recipePath)
+        return; // already current — no rewrite
+    const next = entries.filter((e) => e.command !== commandName);
+    next.push({ command: commandName, recipe_path: recipePath });
+    next.sort((a, b) => a.command.localeCompare(b.command));
+    config.slash_commands = next;
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, yaml.stringify(config), 'utf-8');
+}
+/** Remove the `slash_commands` entry for `commandName`, preserving all other config. */
+function unregisterSlashCommand(configPath, commandName) {
+    if (!fs.existsSync(configPath))
+        return;
+    const config = readGooseConfig(configPath);
+    const entries = readSlashCommands(config);
+    if (!entries.some((e) => e.command === commandName))
+        return; // nothing to do
+    const next = entries.filter((e) => e.command !== commandName);
+    if (next.length > 0) {
+        config.slash_commands = next;
+    }
+    else {
+        delete config.slash_commands;
+    }
+    fs.writeFileSync(configPath, yaml.stringify(config), 'utf-8');
+}
+/** Serialize a Goose command recipe from a central Markdown command file. */
+function buildGooseCommandRecipe(commandName, sourcePath) {
+    const markdown = fs.readFileSync(sourcePath, 'utf-8');
+    return yaml.stringify(markdownToGooseRecipe(commandName, markdown));
+}
+/**
+ * Install a command into a Goose version home: write its recipe YAML and register
+ * the `slash_commands` entry in config.yaml.
+ */
+export function installGooseCommandToVersion(versionHome, commandName, sourcePath) {
+    try {
+        const dir = gooseCommandsDir(versionHome);
+        fs.mkdirSync(dir, { recursive: true });
+        const recipePath = safeJoin(dir, `${commandName}.yaml`);
+        fs.writeFileSync(recipePath, buildGooseCommandRecipe(commandName, sourcePath), 'utf-8');
+        registerSlashCommand(gooseCommandConfigPath(versionHome), commandName, recipePath);
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+}
+/** List Goose command names (recipe files) installed in a version home. */
+export function listGooseCommandsInVersion(versionHome) {
+    const dir = gooseCommandsDir(versionHome);
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir)
+        .filter((f) => f.endsWith('.yaml'))
+        .map((f) => f.slice(0, -'.yaml'.length))
+        .sort();
+}
+/** Whether an installed Goose command recipe matches the central Markdown source. */
+export function gooseCommandMatches(versionHome, commandName, sourcePath) {
+    const recipePath = safeJoin(gooseCommandsDir(versionHome), `${commandName}.yaml`);
+    if (!fs.existsSync(recipePath) || !fs.existsSync(sourcePath))
+        return false;
+    try {
+        // The slash_commands entry must also be registered for the command to be live.
+        // (An unparseable config.yaml surfaces here as "not a match" → a re-sync, which
+        // fails loudly rather than clobbering, instead of a crash during a read-only diff.)
+        const registered = readSlashCommands(readGooseConfig(gooseCommandConfigPath(versionHome)))
+            .some((e) => e.command === commandName);
+        if (!registered)
+            return false;
+        const installed = fs.readFileSync(recipePath, 'utf-8').trim();
+        const expected = buildGooseCommandRecipe(commandName, sourcePath).trim();
+        return installed === expected;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Remove a Goose command from a version home: soft-delete the recipe to `trashDir`
+ * (when provided) and unregister its `slash_commands` entry.
+ */
+export function removeGooseCommandFromVersion(versionHome, commandName, trashDir) {
+    try {
+        const recipePath = safeJoin(gooseCommandsDir(versionHome), `${commandName}.yaml`);
+        if (fs.existsSync(recipePath)) {
+            if (trashDir) {
+                const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+                fs.mkdirSync(trashDir, { recursive: true, mode: 0o700 });
+                fs.renameSync(recipePath, path.join(trashDir, `${commandName}.yaml.${stamp}`));
+            }
+            else {
+                fs.unlinkSync(recipePath);
+            }
+        }
+        unregisterSlashCommand(gooseCommandConfigPath(versionHome), commandName);
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+}

package/dist/lib/hooks.js

@@ -1006,6 +1006,9 @@ export function registerHooksToSettings(agentId, versionHome, hookManifest, agen
     if (agentId === 'cursor') {
         return registerHooksForCursor(versionHome, manifest, resolveScript, managedPrefixes);
     }
+    if (agentId === 'hermes') {
+        return registerHooksForHermes(versionHome, manifest, resolveScript, managedPrefixes);
+    }
     return { registered: [], errors: [] };
 }
 /**
@@ -2186,3 +2189,134 @@ function registerHooksForCursor(versionHome, manifest, resolveScript, managedPre
     }
     return { registered, errors };
 }
+/**
+ * Canonical → Hermes (Nous Research) snake_case lifecycle events.
+ *
+ * Hermes ≥ 0.11.0 runs configurable hooks declared under `hooks:` in
+ * ~/.hermes/config.yaml. Only events with a documented Hermes equivalent are
+ * mapped; unmapped canonical events (the manifest may declare events for other
+ * agents) are skipped silently. UserPromptSubmit maps to `pre_llm_call` (the
+ * closest pre-turn phase) and Stop to `on_session_finalize`.
+ */
+const HERMES_EVENT_MAP = {
+    SessionStart: 'on_session_start',
+    SessionEnd: 'on_session_end',
+    PreToolUse: 'pre_tool_call',
+    PostToolUse: 'post_tool_call',
+    SubagentStop: 'subagent_stop',
+    UserPromptSubmit: 'pre_llm_call',
+    Stop: 'on_session_finalize',
+};
+/** Hermes caps hook timeouts at 300s (default 60s). */
+const HERMES_TIMEOUT_CAP = 300;
+const HERMES_TIMEOUT_DEFAULT = 60;
+/**
+ * Register hooks for Hermes Agent (Nous Research ≥ 0.11.0).
+ *
+ * Read-modify-writes the shared `~/.hermes/config.yaml` (under the version
+ * home): it merges a `hooks:` block of the form
+ *   hooks: { <event>: [ { command, timeout, matcher? } ] }
+ * into the YAML doc WITHOUT touching sibling keys (`mcp_servers` in
+ * particular — a naive overwrite would wipe the user's MCP servers). No
+ * `version` wrapper: Hermes' config is a flat YAML map.
+ *
+ * GC: rewrite managed entries by command path under managedPrefixes; preserve
+ * user-authored entries whose command is outside managed roots. Keyed by
+ * event|command|matcher so a matcher or event change drops the stale entry.
+ */
+function registerHooksForHermes(versionHome, manifest, resolveScript, managedPrefixes) {
+    const registered = [];
+    const errors = [];
+    const configDir = path.join(versionHome, '.hermes');
+    const configPath = path.join(configDir, 'config.yaml');
+    // Read-modify-write: preserve the full existing YAML doc (mcp_servers, etc.).
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        try {
+            const parsed = yaml.parse(fs.readFileSync(configPath, 'utf-8'));
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                config = parsed;
+            }
+        }
+        catch {
+            errors.push('Failed to parse existing config.yaml');
+            return { registered, errors };
+        }
+    }
+    const existingHooks = config.hooks && typeof config.hooks === 'object' && !Array.isArray(config.hooks)
+        ? config.hooks
+        : {};
+    // Desired managed entries keyed by event|command|matcher so a matcher or
+    // event change drops the stale entry instead of retaining it by command alone.
+    const desiredManaged = new Set();
+    for (const [hookName, hookDef] of Object.entries(manifest)) {
+        if (!hookDef.events || hookDef.events.length === 0)
+            continue;
+        const resolved = resolveHookCommand(hookName, hookDef, resolveScript);
+        if (!resolved)
+            continue;
+        for (const event of hookDef.events) {
+            const hermesEvent = HERMES_EVENT_MAP[event];
+            if (!hermesEvent)
+                continue;
+            desiredManaged.add(`${hermesEvent}|${resolved}|${hookDef.matcher ?? ''}`);
+        }
+    }
+    // GC managed entries that are no longer in the manifest; preserve user entries.
+    const hooks = {};
+    for (const [event, entries] of Object.entries(existingHooks)) {
+        if (!Array.isArray(entries))
+            continue;
+        hooks[event] = entries.filter((e) => {
+            if (typeof e?.command !== 'string')
+                return true;
+            if (!isManagedHookCommand(e.command, managedPrefixes))
+                return true;
+            return desiredManaged.has(`${event}|${e.command}|${e.matcher ?? ''}`);
+        });
+        if (hooks[event].length === 0)
+            delete hooks[event];
+    }
+    for (const [name, hookDef] of Object.entries(manifest)) {
+        if (!hookDef.events || hookDef.events.length === 0)
+            continue;
+        const commandPath = resolveHookCommand(name, hookDef, resolveScript);
+        if (!commandPath) {
+            errors.push(`${name}: script not found in user or system hooks dir`);
+            continue;
+        }
+        const timeout = Math.min(HERMES_TIMEOUT_CAP, hookDef.timeout ?? HERMES_TIMEOUT_DEFAULT);
+        for (const event of hookDef.events) {
+            const hermesEvent = HERMES_EVENT_MAP[event];
+            if (!hermesEvent)
+                continue;
+            if (!hooks[hermesEvent])
+                hooks[hermesEvent] = [];
+            const entry = { command: commandPath, timeout };
+            if (hookDef.matcher)
+                entry.matcher = hookDef.matcher;
+            const existingIdx = hooks[hermesEvent].findIndex((h) => h.command === entry.command && (h.matcher ?? '') === (entry.matcher ?? ''));
+            if (existingIdx >= 0) {
+                hooks[hermesEvent][existingIdx] = entry;
+            }
+            else {
+                hooks[hermesEvent].push(entry);
+            }
+            registered.push(`${name} -> ${hermesEvent}`);
+        }
+    }
+    if (Object.keys(hooks).length > 0) {
+        config.hooks = hooks;
+    }
+    else {
+        delete config.hooks;
+    }
+    try {
+        fs.mkdirSync(configDir, { recursive: true });
+        fs.writeFileSync(configPath, yaml.stringify(config), 'utf-8');
+    }
+    catch (err) {
+        errors.push(`Failed to write config.yaml: ${err.message}`);
+    }
+    return { registered, errors };
+}

package/dist/lib/permissions.d.ts

@@ -122,6 +122,21 @@ export declare function convertToDroidFormat(set: PermissionSet): {
     commandAllowlist: string[];
     commandDenylist: string[];
 };
+/**
+ * Convert canonical permission set to OpenClaw's `tools.alsoAllow`/`tools.deny`.
+ *
+ * OpenClaw's allowlist is tool-level only, so ONLY blanket (whole-tool) rules
+ * map — a rule is blanket iff it's a bare tool with no parens (`Bash`), it's in
+ * BLANKET_BASH_FORMS, or its pattern is `*`/`**` (`Read(**)`, `Write(*)`).
+ * Sub-command/path/domain rules (`Bash(git:*)`, `Write(secrets/**)`,
+ * `WebFetch(domain:x)`) are SKIPPED — coarse-mapping a specific deny to a whole
+ * tool would wrongly gate every use of that tool. Output arrays are deduped and
+ * sorted for deterministic writes/tests.
+ */
+export declare function convertToOpenClawFormat(set: PermissionSet): {
+    alsoAllow: string[];
+    deny: string[];
+};
 /**
  * Convert canonical permission set to Antigravity format.
  * Antigravity reads ~/.gemini/antigravity-cli/settings.json with

package/dist/lib/permissions.js

@@ -560,6 +560,60 @@ export function convertToDroidFormat(set) {
         commandDenylist: commands(set.deny ?? []),
     };
 }
+/**
+ * Canonical tool -> OpenClaw tool id. OpenClaw gates at TOOL granularity only
+ * (no sub-command/path/domain patterns), so only these whole-tool ids exist.
+ * Any canonical tool not in this map is unsupported and skipped.
+ */
+const CANONICAL_TO_OPENCLAW_TOOL = {
+    bash: 'exec',
+    read: 'read',
+    write: 'write',
+    edit: 'write',
+    webfetch: 'web_fetch',
+    websearch: 'web_search',
+};
+/**
+ * Convert canonical permission set to OpenClaw's `tools.alsoAllow`/`tools.deny`.
+ *
+ * OpenClaw's allowlist is tool-level only, so ONLY blanket (whole-tool) rules
+ * map — a rule is blanket iff it's a bare tool with no parens (`Bash`), it's in
+ * BLANKET_BASH_FORMS, or its pattern is `*`/`**` (`Read(**)`, `Write(*)`).
+ * Sub-command/path/domain rules (`Bash(git:*)`, `Write(secrets/**)`,
+ * `WebFetch(domain:x)`) are SKIPPED — coarse-mapping a specific deny to a whole
+ * tool would wrongly gate every use of that tool. Output arrays are deduped and
+ * sorted for deterministic writes/tests.
+ */
+export function convertToOpenClawFormat(set) {
+    const map = (permissions) => {
+        const tools = new Set();
+        for (const perm of permissions) {
+            // Bare tool name with no parens (e.g. "Bash", "Read") is a blanket grant;
+            // parseCanonicalPattern requires parens, so handle it first.
+            const bare = perm.match(/^(\w+)$/);
+            if (bare) {
+                const id = CANONICAL_TO_OPENCLAW_TOOL[bare[1].toLowerCase()];
+                if (id)
+                    tools.add(id);
+                continue;
+            }
+            const parsed = parseCanonicalPattern(perm);
+            if (!parsed)
+                continue;
+            const isBlanket = BLANKET_BASH_FORMS.has(perm) || parsed.pattern === '*' || parsed.pattern === '**';
+            if (!isBlanket)
+                continue;
+            const id = CANONICAL_TO_OPENCLAW_TOOL[parsed.tool];
+            if (id)
+                tools.add(id);
+        }
+        return Array.from(tools).sort();
+    };
+    return {
+        alsoAllow: map(set.allow),
+        deny: map(set.deny ?? []),
+    };
+}
 /**
  * Convert canonical permission set to Antigravity format.
  * Antigravity reads ~/.gemini/antigravity-cli/settings.json with
@@ -1570,6 +1624,51 @@ export function applyPermissionsToVersion(agentId, set, versionHome, merge = tru
             fs.writeFileSync(permissionsPath, yaml.stringify(config), 'utf-8');
             return { success: true };
         }
+        if (agentId === 'openclaw') {
+            // OpenClaw's allowlist lives in ~/.openclaw/openclaw.json under `tools`.
+            // Only blanket tool-level rules map (see convertToOpenClawFormat). We
+            // read-modify-write to preserve all other keys (mcp, exec, agents, …) and
+            // never touch `tools.allow` (the absolute allowlist that replaces defaults).
+            const configPath = path.join(versionHome, '.openclaw', 'openclaw.json');
+            let config = {};
+            if (fs.existsSync(configPath)) {
+                config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            }
+            const converted = convertToOpenClawFormat(set);
+            const existingTools = (typeof config.tools === 'object' && config.tools !== null && !Array.isArray(config.tools))
+                ? config.tools
+                : {};
+            let alsoAllow;
+            let deny;
+            if (merge) {
+                const existingAllow = Array.isArray(existingTools.alsoAllow) ? existingTools.alsoAllow : [];
+                const existingDeny = Array.isArray(existingTools.deny) ? existingTools.deny : [];
+                alsoAllow = Array.from(new Set([...existingAllow, ...converted.alsoAllow]));
+                deny = Array.from(new Set([...existingDeny, ...converted.deny]));
+            }
+            else {
+                alsoAllow = converted.alsoAllow;
+                deny = converted.deny;
+            }
+            // Set or delete each key: avoid writing empty arrays (churn). On a
+            // non-merge replace with nothing to write, delete the stale key.
+            const tools = { ...existingTools };
+            if (alsoAllow.length > 0)
+                tools.alsoAllow = alsoAllow;
+            else
+                delete tools.alsoAllow;
+            if (deny.length > 0)
+                tools.deny = deny;
+            else
+                delete tools.deny;
+            if (Object.keys(tools).length > 0)
+                config.tools = tools;
+            else
+                delete config.tools;
+            fs.mkdirSync(path.dirname(configPath), { recursive: true });
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+            return { success: true };
+        }
         return { success: false, error: `Agent '${agentId}' does not support permissions` };
     }
     catch (err) {

package/dist/lib/plugins.d.ts

@@ -211,6 +211,26 @@ export declare function goosePluginsDir(versionHome: string): string;
 export declare function installGoosePlugin(plugin: DiscoveredPlugin, versionHome: string): boolean;
 export declare function isGoosePluginInstalled(pluginName: string, versionHome: string): boolean;
 export declare function removeGoosePlugin(pluginName: string, versionHome: string): boolean;
+/**
+ * Hermes (Nous Research) loads plugins from a flat `$HOME/.hermes/plugins/<name>/`
+ * directory holding a `plugin.yaml` manifest — NOT the Claude marketplace layout.
+ * Under agents-cli version isolation HOME is the version home, so we install to:
+ *   {versionHome}/.hermes/plugins/<name>/
+ * A plugin does not load until its name is added to `plugins.enabled` (a YAML
+ * array) in `{versionHome}/.hermes/config.yaml`; a deny-list `plugins.disabled`
+ * wins on conflict, so agents-cli only manages the `enabled` allowlist and never
+ * touches `disabled` (user-owned).
+ */
+export declare function hermesPluginsDir(versionHome: string): string;
+/**
+ * Add or remove a plugin name in `plugins.enabled` within ~/.hermes/config.yaml,
+ * preserving every other key (read → mutate → write). Never touches
+ * `plugins.disabled`. No-op (no rewrite) when the desired state already holds.
+ */
+export declare function setHermesPluginEnabled(pluginName: string, versionHome: string, enabled: boolean): void;
+export declare function installHermesPlugin(plugin: DiscoveredPlugin, versionHome: string, enable: boolean): boolean;
+export declare function isHermesPluginInstalled(pluginName: string, versionHome: string): boolean;
+export declare function removeHermesPlugin(pluginName: string, versionHome: string): boolean;
 /**
  * Check if a plugin is synced to a version. True when the plugin lives at the
  * native marketplace install path. Legacy dual-dash entries are not counted —

package/dist/lib/plugins.js

@@ -10,6 +10,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import * as yaml from 'yaml';
 import { execFileSync } from 'child_process';
 import { getPluginsDir, getTrashPluginsDir, getExtraPluginsDir, getProjectPluginsDir, getSystemPluginsDir } from './state.js';
 import { IS_WINDOWS, isWindowsAbsolutePath, homeDir } from './platform/index.js';
@@ -22,6 +23,7 @@ import { copyPluginToMarketplace, syncMarketplaceManifest, registerMarketplace,
 const PLUGIN_MANIFEST_DIR = '.claude-plugin';
 const PLUGIN_MANIFEST_FILE = 'plugin.json';
 const GEMINI_EXTENSION_MANIFEST_FILE = 'gemini-extension.json';
+const HERMES_PLUGIN_MANIFEST_FILE = 'plugin.yaml';
 const USER_CONFIG_FILE = '.user-config.json';
 const SOURCE_FILE = '.source';
 export const PLUGIN_EXEC_SURFACE_LABELS = {
@@ -533,6 +535,16 @@ export function syncPluginToVersion(plugin, agent, versionHome, options = {}) {
             result.skills.push(plugin.name);
         return result;
     }
+    // Hermes loads plugins from a flat $HOME/.hermes/plugins/<name>/ dir with a
+    // plugin.yaml manifest, gated by a plugins.enabled allowlist in config.yaml.
+    if (agent === 'hermes') {
+        const enablePlugin = options.allowExecSurfaces === true || !hasPluginExecSurfaces(inspectPluginCapabilities(plugin.root));
+        const ok = installHermesPlugin(plugin, versionHome, enablePlugin);
+        result.success = ok;
+        if (ok)
+            result.skills.push(plugin.name);
+        return result;
+    }
     const userConfig = loadUserConfig(plugin.name);
     // Route every marketplace op through the plugin's own marketplace, so a plugin
     // discovered in an extra/project repo installs under its own
@@ -1035,6 +1047,102 @@ export function removeGoosePlugin(pluginName, versionHome) {
     fs.rmSync(destRoot, { recursive: true, force: true });
     return true;
 }
+// ─── Hermes plugins (flat ~/.hermes/plugins/ + config.yaml enable toggle) ─────
+/**
+ * Hermes (Nous Research) loads plugins from a flat `$HOME/.hermes/plugins/<name>/`
+ * directory holding a `plugin.yaml` manifest — NOT the Claude marketplace layout.
+ * Under agents-cli version isolation HOME is the version home, so we install to:
+ *   {versionHome}/.hermes/plugins/<name>/
+ * A plugin does not load until its name is added to `plugins.enabled` (a YAML
+ * array) in `{versionHome}/.hermes/config.yaml`; a deny-list `plugins.disabled`
+ * wins on conflict, so agents-cli only manages the `enabled` allowlist and never
+ * touches `disabled` (user-owned).
+ */
+export function hermesPluginsDir(versionHome) {
+    return path.join(versionHome, '.hermes', 'plugins');
+}
+function hermesConfigPath(versionHome) {
+    return path.join(versionHome, '.hermes', 'config.yaml');
+}
+function writeHermesPluginManifest(plugin, destRoot) {
+    const manifest = {
+        name: plugin.manifest.name,
+        version: plugin.manifest.version,
+        description: plugin.manifest.description,
+    };
+    fs.writeFileSync(path.join(destRoot, HERMES_PLUGIN_MANIFEST_FILE), yaml.stringify(manifest), 'utf-8');
+}
+/**
+ * Add or remove a plugin name in `plugins.enabled` within ~/.hermes/config.yaml,
+ * preserving every other key (read → mutate → write). Never touches
+ * `plugins.disabled`. No-op (no rewrite) when the desired state already holds.
+ */
+export function setHermesPluginEnabled(pluginName, versionHome, enabled) {
+    const configPath = hermesConfigPath(versionHome);
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        const parsed = yaml.parse(fs.readFileSync(configPath, 'utf-8'));
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            config = parsed;
+        }
+    }
+    if (!config.plugins || typeof config.plugins !== 'object' || Array.isArray(config.plugins)) {
+        config.plugins = {};
+    }
+    const plugins = config.plugins;
+    const current = Array.isArray(plugins.enabled) ? plugins.enabled.filter((n) => typeof n === 'string') : [];
+    const has = current.includes(pluginName);
+    if (enabled && !has) {
+        plugins.enabled = [...current, pluginName];
+    }
+    else if (!enabled && has) {
+        plugins.enabled = current.filter((n) => n !== pluginName);
+    }
+    else {
+        return; // desired state already holds — no rewrite
+    }
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, yaml.stringify(config), 'utf-8');
+}
+export function installHermesPlugin(plugin, versionHome, enable) {
+    const destRoot = path.join(hermesPluginsDir(versionHome), plugin.name);
+    try {
+        if (fs.existsSync(destRoot)) {
+            fs.rmSync(destRoot, { recursive: true, force: true });
+        }
+        fs.cpSync(plugin.root, destRoot, { recursive: true });
+        const userConfig = loadUserConfig(plugin.name);
+        if (Object.keys(userConfig).length > 0) {
+            expandUserConfigInDir(destRoot, userConfig);
+        }
+        writeHermesPluginManifest(plugin, destRoot);
+        fs.writeFileSync(path.join(destRoot, '.agents-cli-managed'), `plugin=${plugin.name}\n`, 'utf-8');
+        // Enable only when trusted — never DOWN-toggle here. An un-flagged background
+        // re-sync of an exec-surface plugin passes enable=false; forcing the allowlist
+        // to false then would clobber a plugin the user deliberately enabled with
+        // --allow-exec-surfaces. Mirror addPluginToSettings: add-if-trusted, else leave
+        // the existing enabled state untouched. (Removal still unregisters explicitly.)
+        if (enable) {
+            setHermesPluginEnabled(plugin.name, versionHome, true);
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isHermesPluginInstalled(pluginName, versionHome) {
+    return fs.existsSync(path.join(hermesPluginsDir(versionHome), pluginName, HERMES_PLUGIN_MANIFEST_FILE));
+}
+export function removeHermesPlugin(pluginName, versionHome) {
+    const destRoot = path.join(hermesPluginsDir(versionHome), pluginName);
+    const existed = fs.existsSync(destRoot);
+    if (existed)
+        fs.rmSync(destRoot, { recursive: true, force: true });
+    // Always drop it from the enabled allowlist, even if the dir was already gone.
+    setHermesPluginEnabled(pluginName, versionHome, false);
+    return existed;
+}
 // ─── Sync status ──────────────────────────────────────────────────────────────
 /**
  * Check if a plugin is synced to a version. True when the plugin lives at the
@@ -1053,6 +1161,9 @@ export function isPluginSynced(plugin, agent, versionHome) {
     if (agent === 'goose') {
         return isGoosePluginInstalled(plugin.name, versionHome);
     }
+    if (agent === 'hermes') {
+        return isHermesPluginInstalled(plugin.name, versionHome);
+    }
     const spec = marketplaceSpecForName(plugin.marketplace);
     if (!isInstalledInMarketplace(plugin.name, spec, agent, versionHome))
         return false;
@@ -1101,6 +1212,13 @@ export function removePluginFromVersion(pluginName, pluginRoot, agent, versionHo
         }
         return result;
     }
+    // Hermes: remove the flat plugin dir and drop it from config.yaml plugins.enabled.
+    if (agent === 'hermes') {
+        if (removeHermesPlugin(pluginName, versionHome)) {
+            result.skills.push(pluginName);
+        }
+        return result;
+    }
     // 1. Remove the plugin from every marketplace it's installed under. A name can
     //    appear in more than one (collision across repos), so we sweep them all.
     let removedAny = false;

package/dist/lib/resources/permissions.js

@@ -75,6 +75,8 @@ function getAgentConfigPath(agent, versionHome) {
             return path.join(versionHome, '.factory', 'settings.json');
         case 'kiro':
             return path.join(versionHome, '.kiro', 'settings', 'permissions.yaml');
+        case 'openclaw':
+            return path.join(versionHome, '.openclaw', 'openclaw.json');
         case 'goose':
             return path.join(versionHome, '.config', 'goose', 'permission.yaml');
         default:

package/dist/lib/routines.d.ts

@@ -75,6 +75,13 @@ export interface JobConfig {
     version?: string;
     runOnce?: boolean;
     endAt?: string;
+    /**
+     * When set, the job resumes this existing agent session id at fire time
+     * (`agents run <agent> --resume <id>`) instead of starting a fresh conversation,
+     * so the actual session reopens with full context and `prompt` becomes its next
+     * turn. Powers self-scheduled wake-ups (e.g. /hibernate). claude/codex only.
+     */
+    resume?: string;
     /** When set, executeJob runs this job through the loop driver instead of once. */
     loop?: LoopConfig;
 }