@hi-man/himan 0.3.1 → 0.3.3

package/CHANGELOG.md

@@ -6,6 +6,27 @@ The format is based on Keep a Changelog, and this project follows semver for the
 
 ## [Unreleased]
 
+### Changed
+
+- Changed project guidance to require changelog updates for user-visible CLI behavior changes.
+
+## [0.3.3] - 2026-05-11
+
+### Added
+
+- Added `himan project list` and `himan list --installed` to show resources recorded in the current project's `himan.lock`.
+
+### Changed
+
+- Changed `himan list` without a resource type to group all source resources by `rule`, `command`, and `skill`.
+- Added `himan list --brief` to hide resource descriptions in concise list output.
+
+## [0.3.2] - 2026-05-08
+
+### Added
+
+- Added `himan install <type> <name[@version]> --global` to install a resource into the matching user-level agent directory, reusing the current project's resource agent when available and without writing the project lock file.
+
 ## [0.3.1] - 2026-05-07
 
 ### Added

package/README.md

@@ -56,11 +56,16 @@ himan publish rule my-rule --patch
   - `claude-code` -> `.claude/{rules|commands|skills}/<name>`
   - `codex` -> `.agents/{rules|commands|skills}/<name>`
   - `openclaw` -> `.openclaw/{rules|commands|skills}/<name>`
+- 加 `--global` 时会安装到用户级 agent 目录，并仍按当前项目生效的 agent 选择目标：
+  - `cursor` -> `~/.cursor/{rules|commands|skills}/<name>`
+  - `claude-code` -> `~/.claude/{rules|commands|skills}/<name>`
+  - `codex` -> `~/.agents/{rules|commands|skills}/<name>`
+  - `openclaw` -> `~/.openclaw/{rules|commands|skills}/<name>`
 - 开发态目录：
   - `rule` -> `.himan/dev/rule/<name>`
   - `command` -> `.himan/dev/command/<name>`
   - `skill` -> `.himan/dev/skill/<name>`
-- lock 文件：`install <type> <name[@version]>` 会写入 `himan.lock`，记录 source、精确版本、agent 和安装模式；`himan install`（无参数）会按 lock 记录的 source 批量恢复安装，不受当前 default source 切换影响。
+- lock 文件：项目安装 `install <type> <name[@version]>` 会写入 `himan.lock`，记录 source、精确版本、agent 和安装模式；`himan install`（无参数）会按 lock 记录的 source 批量恢复安装，不受当前 default source 切换影响。`--global` 安装不写当前项目的 `himan.lock`。
 - 安装模式：默认 `--mode link` 使用软链；也可用 `--mode copy` 将资源复制到目标 agent 目录，lock 会记录并复现该模式。
 - 默认 agent：`agent use <agent>` 默认写当前项目 `.himan/config.json`；加 `--global` 写入 `~/.himan/config.json`。当前项目配置优先于全局配置。
 
@@ -128,7 +133,7 @@ your-himan-source/
 
 | 命令                             | 说明                                                                                |
 | -------------------------------- | ----------------------------------------------------------------------------------- |
-| `list [type] [--agent a,b] [--json]` | 列出当前 default source 的资源；可按 agent 过滤；`type` 默认 `rule` |
+| `list [type] [--agent a,b] [--brief] [--installed] [--json]` | 默认列出当前 default source 的资源；未传 `type` 时按 `rule`/`command`/`skill` 分组展示全部资源；可按 agent 过滤；默认显示描述，`--brief` 可隐藏描述；`--installed` 改为查看当前项目 `himan.lock` 中的已安装资源 |
 | `history <type> <name> [--json]` | 按 tag 查看版本历史                                                                 |
 | `create <type> <name>`           | 脚手架；常用选项：`--description`、`--agent a,b`、`--dry-run`、`--force`、`--json` |
 
@@ -136,7 +141,8 @@ your-himan-source/
 
 | 命令                              | 说明                                                      |
 | --------------------------------- | --------------------------------------------------------- |
-| `install [type] [name[@version]] [--agent a,b] [--mode link\|copy]` | 有参数时从当前 default source 安装指定资源；**无参数**时按 `himan.lock` 记录的 source 批量安装；可覆盖安装目标 agent 或安装模式 |
+| `list [type] [--agent a,b] [--json]` | 查看当前项目 `himan.lock` 中记录的已安装资源；未传 `type` 时按 `rule`/`command`/`skill` 分组展示 |
+| `install [type] [name[@version]] [--global] [--agent a,b] [--mode link\|copy]` | 有参数时从当前 default source 安装指定资源；**无参数**时按 `himan.lock` 记录的 source 批量安装；加 `--global` 时安装到用户级 agent 目录且不写项目 lock；可覆盖安装目标 agent 或安装模式 |
 | `dev <type> <name>`               | 切换到开发态，并按安装模式将项目目标指向或复制自 `.himan/dev/...` |
 | `uninstall <type> <name>`         | 从项目移除安装目标，并同步删除 `himan.lock` 条目           |
 | `publish <type> <name>`           | 默认 `--patch`；可选 `--minor` / `--major`（勿同时使用多个） |
@@ -154,12 +160,12 @@ your-himan-source/
 
 - `himan resource list|history|create ...`
 - `himan-resource list|history|create ...`（兼容保留：也可执行 install/dev/uninstall/publish）
-- `himan project install|dev|uninstall|publish ...`
-- `himan-project install|dev|uninstall|publish ...`
+- `himan project list|install|dev|uninstall|publish ...`
+- `himan-project list|install|dev|uninstall|publish ...`
 - `himan agent list|use|current|clear ...`
 
 说明：资源与项目相关命令统一使用 `--agent` 指定目标 Agent。
-若未显式传 `--agent`，`create` / `install` 会使用当前项目默认 agent、全局默认 agent、资源 metadata 或内置默认 `cursor` 中最合适的一项；`dev` 会优先使用 lock 中记录的 agent。
+若未显式传 `--agent`，`create` / `install` 会使用当前项目默认 agent、全局默认 agent、资源 metadata 或内置默认 `cursor` 中最合适的一项；`dev` 会优先使用 lock 中记录的 agent。`install --global` 会优先复用当前项目 lock 里该资源的 agent，未命中时再使用默认 install 解析顺序，但目标根目录是用户 home 下对应 agent 目录。
 
 `publish` 优先使用项目里 `.himan/dev` 对应目录，否则用源仓库里对应目录。若资源目录包含 `himan.yaml`，发布前会校验元数据与入口文件；若没有 `himan.yaml`，则按默认入口推断最小元数据并发布，不会强制创建 `himan.yaml`。发布需要可推送的 Git 权限。发布 commit 会包含资源目录以及自动维护的 source 根目录 `README.md` / `CHANGELOG.md`。发布成功后会从新版本 store 以 `copy` 模式重新安装到项目目标、更新 lock，并删除对应 `.himan/dev/<type>/<name>` 开发目录。
 

package/dist/cli/builders.js

@@ -25,7 +25,7 @@ export function buildCli() {
     registerAgentCommands(agentCmd, services);
     // Backward compatible top-level resource lifecycle commands.
     registerResourceCommands(program, services);
-    registerProjectCommands(program, services);
+    registerProjectCommands(program, services, { includeList: false });
     return program;
 }
 export function buildSourceCli() {
@@ -43,7 +43,7 @@ export function buildResourceCli() {
         .description("Manage default agent configuration");
     registerAgentCommands(agentCmd, services);
     // Backward compatible: keep project lifecycle commands in himan-resource.
-    registerProjectCommands(program, services);
+    registerProjectCommands(program, services, { includeList: false });
     return program;
 }
 export function buildProjectCli() {
@@ -62,10 +62,11 @@ Command groups:
   source   Data source management (git now, registry reserved)
            init, source init, source add, source use, source list, source init-docs
   resource Source resource discovery and metadata
-           list, history, create, resource list, resource history, resource create
-  project  Resource usage lifecycle in current project
-           install, dev, uninstall, publish,
-           project install, project dev, project uninstall, project publish
+           list, list --installed, history, create,
+           resource list, resource history, resource create
+  project  Resource usage lifecycle in current project or user-level agent dirs
+           list, install, dev, uninstall, publish,
+           project list, project install, project dev, project uninstall, project publish
   agent    Default agent configuration
            agent list, agent use, agent current, agent clear
 `);

package/dist/cli/installed-resource-list.js

@@ -0,0 +1,46 @@
+const RESOURCE_TYPES = ["rule", "command", "skill"];
+export async function listInstalledResourceGroups(services, projectDir, agents) {
+    const resources = await services.listInstalled(projectDir, undefined, agents);
+    return groupInstalledResources(resources);
+}
+export function groupInstalledResources(resources) {
+    return {
+        rule: resources.filter((resource) => resource.type === "rule"),
+        command: resources.filter((resource) => resource.type === "command"),
+        skill: resources.filter((resource) => resource.type === "skill"),
+    };
+}
+export function writeInstalledResourceGroups(groups) {
+    const hasResources = RESOURCE_TYPES.some((type) => groups[type].length > 0);
+    if (!hasResources) {
+        process.stdout.write("No installed resources found.\n");
+        return;
+    }
+    for (const type of RESOURCE_TYPES) {
+        const resources = groups[type];
+        if (resources.length === 0)
+            continue;
+        process.stdout.write(`${formatGroupTitle(type)}:\n`);
+        writeInstalledResources(resources);
+    }
+}
+export function writeInstalledResources(resources) {
+    if (resources.length === 0) {
+        process.stdout.write("No installed resources found.\n");
+        return;
+    }
+    for (const resource of resources) {
+        process.stdout.write(`- ${formatInstalledResource(resource)}\n`);
+    }
+}
+function formatInstalledResource(resource) {
+    const agents = resource.agents.length > 0 ? ` [${resource.agents.join(", ")}]` : "";
+    return `${resource.type}/${resource.name}@${resource.version}${agents} (${resource.mode})`;
+}
+function formatGroupTitle(type) {
+    if (type === "rule")
+        return "Rules";
+    if (type === "command")
+        return "Commands";
+    return "Skills";
+}

package/dist/cli/project-commands.js

@@ -1,19 +1,54 @@
 import { HimanError, errorCodes } from "../utils/errors.js";
 import { getSupportedAgentNames, normalizeAgent } from "../utils/agent-configs.js";
+import { listInstalledResourceGroups, writeInstalledResourceGroups, writeInstalledResources, } from "./installed-resource-list.js";
 import { runAction } from "./shared.js";
-export function registerProjectCommands(command, services) {
+export function registerProjectCommands(command, services, options = {}) {
+    if (options.includeList !== false) {
+        command
+            .command("list")
+            .argument("[type]", "resource type")
+            .option("--agent <list>", "agent list filter, comma separated")
+            .option("--json", "output json format")
+            .description("List resources installed in current project")
+            .action(async (type, commandOptions) => {
+            await runAction(async () => {
+                const agents = parseAgents(commandOptions.agent);
+                if (!type) {
+                    const groups = await listInstalledResourceGroups(services, process.cwd(), agents);
+                    if (commandOptions.json) {
+                        process.stdout.write(`${JSON.stringify(groups, null, 2)}\n`);
+                        return;
+                    }
+                    writeInstalledResourceGroups(groups);
+                    return;
+                }
+                const resourceType = ensureResourceType(type);
+                const resources = await services.listInstalled(process.cwd(), resourceType, agents);
+                if (commandOptions.json) {
+                    process.stdout.write(`${JSON.stringify(resources, null, 2)}\n`);
+                    return;
+                }
+                writeInstalledResources(resources);
+            });
+        });
+    }
     command
         .command("install")
         .argument("[type]", "resource type")
         .argument("[name[@version]]", "resource name with optional @version")
         .option("--agent <list>", "install target agents, comma separated")
         .option("--mode <mode>", "install mode: link or copy")
+        .option("--global", "install into user-level agent directories")
         .description("Install resource, or install from himan.lock")
         .action(async (type, nameVersion, options) => {
         await runAction(async () => {
             const agents = parseAgents(options.agent);
             const mode = parseInstallMode(options.mode);
             if (!type && !nameVersion) {
+                if (options.global) {
+                    throw new HimanError(errorCodes.CLI_USAGE, "Global install requires a resource:\n"
+                        + "  - himan install <type> <name[@version]> --global [--mode link|copy]");
+                }
                 const results = await services.installFromLock(process.cwd(), agents, mode);
                 if (results.length === 0) {
                     process.stdout.write("No resources in lock file.\n");
@@ -27,12 +62,15 @@ export function registerProjectCommands(command, services) {
             if (!type || !nameVersion) {
                 throw new HimanError(errorCodes.CLI_USAGE, "Install usage:\n"
                     + "  - himan install  # install from himan.lock\n"
-                    + "  - himan install <type> <name[@version]> [--mode link|copy]  # install single resource");
+                    + "  - himan install <type> <name[@version]> [--mode link|copy]  # install single resource\n"
+                    + "  - himan install <type> <name[@version]> --global [--mode link|copy]  # install single resource globally");
             }
             const resourceType = ensureResourceType(type);
             const { name, version } = parseNameVersion(nameVersion);
-            const result = await services.install(resourceType, name, version, process.cwd(), agents, mode);
-            process.stdout.write(`Installed ${result.type}/${result.name}@${result.version}\n`);
+            const result = options.global
+                ? await services.installGlobal(resourceType, name, version, process.cwd(), agents, mode)
+                : await services.install(resourceType, name, version, process.cwd(), agents, mode);
+            process.stdout.write(`Installed ${options.global ? "global " : ""}${result.type}/${result.name}@${result.version}\n`);
         });
     });
     command

package/dist/cli/resource-commands.js

@@ -1,28 +1,41 @@
 import { HimanError, errorCodes } from "../utils/errors.js";
 import { getSupportedAgentNames, normalizeAgent } from "../utils/agent-configs.js";
+import { listInstalledResourceGroups, writeInstalledResourceGroups, writeInstalledResources, } from "./installed-resource-list.js";
 import { runAction } from "./shared.js";
+const RESOURCE_TYPES = ["rule", "command", "skill"];
 export function registerResourceCommands(command, services) {
     command
         .command("list")
-        .argument("[type]", "resource type", "rule")
+        .argument("[type]", "resource type")
         .option("--agent <list>", "agent list filter, comma separated")
+        .option("--brief", "hide resource descriptions")
+        .option("--installed", "list resources installed in current project")
         .option("--json", "output json format")
-        .description("List resources from current default source")
+        .description("List resources from current default source or project installs")
         .action(async (type, options) => {
         await runAction(async () => {
-            const resourceType = ensureResourceType(type);
-            const resources = await services.list(resourceType, parseAgents(options.agent));
-            if (options.json) {
-                process.stdout.write(`${JSON.stringify(resources, null, 2)}\n`);
+            const agents = parseAgents(options.agent);
+            const showDescription = !options.brief;
+            if (options.installed) {
+                await writeInstalledList(services, type, agents, Boolean(options.json));
                 return;
             }
-            if (resources.length === 0) {
-                process.stdout.write("No resources found.\n");
+            if (!type) {
+                const groups = await listGroupedResources(services, agents);
+                if (options.json) {
+                    process.stdout.write(`${JSON.stringify(formatResourceGroups(groups, showDescription), null, 2)}\n`);
+                    return;
+                }
+                writeGroupedResources(groups, showDescription);
                 return;
             }
-            for (const resource of resources) {
-                process.stdout.write(`- ${resource.type}/${resource.name}${resource.description ? `: ${resource.description}` : ""}\n`);
+            const resourceType = ensureResourceType(type);
+            const resources = await services.list(resourceType, agents);
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(formatResources(resources, showDescription), null, 2)}\n`);
+                return;
             }
+            writeResourceList(resources, showDescription);
         });
     });
     command
@@ -79,12 +92,82 @@ export function registerResourceCommands(command, services) {
         });
     });
 }
+async function writeInstalledList(services, type, agents, json) {
+    if (!type) {
+        const groups = await listInstalledResourceGroups(services, process.cwd(), agents);
+        if (json) {
+            process.stdout.write(`${JSON.stringify(groups, null, 2)}\n`);
+            return;
+        }
+        writeInstalledResourceGroups(groups);
+        return;
+    }
+    const resourceType = ensureResourceType(type);
+    const resources = await services.listInstalled(process.cwd(), resourceType, agents);
+    if (json) {
+        process.stdout.write(`${JSON.stringify(resources, null, 2)}\n`);
+        return;
+    }
+    writeInstalledResources(resources);
+}
 function ensureResourceType(type) {
     if (type !== "rule" && type !== "command" && type !== "skill") {
         throw new HimanError(errorCodes.UNSUPPORTED_RESOURCE_TYPE, `Unsupported resource type: ${type}`);
     }
     return type;
 }
+async function listGroupedResources(services, agents) {
+    return {
+        rule: await services.list("rule", agents),
+        command: await services.list("command", agents),
+        skill: await services.list("skill", agents),
+    };
+}
+function formatResourceGroups(groups, showDescription) {
+    return {
+        rule: formatResources(groups.rule, showDescription),
+        command: formatResources(groups.command, showDescription),
+        skill: formatResources(groups.skill, showDescription),
+    };
+}
+function formatResources(resources, showDescription) {
+    if (showDescription)
+        return resources;
+    return resources.map((resource) => {
+        const { description: _description, ...withoutDescription } = resource;
+        return withoutDescription;
+    });
+}
+function writeGroupedResources(groups, showDescription) {
+    const hasResources = RESOURCE_TYPES.some((type) => groups[type].length > 0);
+    if (!hasResources) {
+        process.stdout.write("No resources found.\n");
+        return;
+    }
+    for (const type of RESOURCE_TYPES) {
+        const resources = groups[type];
+        if (resources.length === 0)
+            continue;
+        process.stdout.write(`${formatGroupTitle(type)}:\n`);
+        writeResourceList(resources, showDescription);
+    }
+}
+function writeResourceList(resources, showDescription) {
+    if (resources.length === 0) {
+        process.stdout.write("No resources found.\n");
+        return;
+    }
+    for (const resource of resources) {
+        process.stdout.write(`- ${resource.type}/${resource.name}${showDescription && resource.description ? `: ${resource.description}` : ""}\n`);
+    }
+}
+function formatGroupTitle(type) {
+    if (type === "rule")
+        return "Rules";
+    if (type === "command")
+        return "Commands";
+    return "Skills";
+}
 function parseAgents(input) {
     if (!input)
         return undefined;

package/dist/services/index.js

@@ -6,7 +6,7 @@ import { ProjectLockStore, } from "../state/project-lock-store.js";
 import { PathResolver } from "../utils/path-resolver.js";
 import { toRepoId } from "../utils/repo-id.js";
 import { HimanError, errorCodes } from "../utils/errors.js";
-import { getProjectResourcePaths, getSupportedAgentNames, normalizeAgents, } from "../utils/agent-configs.js";
+import { getGlobalResourcePaths, getProjectResourcePaths, getSupportedAgentNames, normalizeAgents, } from "../utils/agent-configs.js";
 import path from "node:path";
 import { promises as fs } from "node:fs";
 import { VersionResolver } from "../adapters/version/version-resolver.js";
@@ -157,6 +157,28 @@ export class ServiceFactory {
         const selected = normalizeAgents(agents);
         return resources.filter((resource) => normalizeAgents(resource.agents).some((agent) => selected.includes(agent)));
     }
+    async listInstalled(projectDir, type, agents) {
+        const { lock, state } = await this.lockStore.loadWithState(projectDir);
+        if (state === "invalid") {
+            throw new HimanError(errorCodes.LOCK_INVALID, `Lock file is invalid: ${this.lockStore.getLockPath(projectDir)}`);
+        }
+        if (state === "missing" || !lock) {
+            return [];
+        }
+        const selectedAgents = agents?.length ? normalizeAgents(agents) : undefined;
+        return lock.resources
+            .filter((resource) => !type || resource.type === type)
+            .map((resource) => ({
+            type: resource.type,
+            name: resource.name,
+            version: resource.version,
+            agents: normalizeAgents(resource.agents),
+            mode: this.resolveInstallMode(resource.mode),
+            updatedAt: resource.updatedAt,
+        }))
+            .filter((resource) => !selectedAgents ||
+            resource.agents.some((agent) => selectedAgents.includes(agent)));
+    }
     async history(type, name) {
         const source = await this.loadSourceFromConfig();
         return source.history(type, name);
@@ -165,6 +187,10 @@ export class ServiceFactory {
         const { source, sourceInfo } = await this.loadSourceWithInfoFromConfig();
         return this.installWithSource(source, sourceInfo, type, name, version, projectDir, agents, mode);
     }
+    async installGlobal(type, name, version, projectDir, agents, mode = "link") {
+        const source = await this.loadSourceFromConfig();
+        return this.installWithSource(source, undefined, type, name, version, projectDir, agents, mode, "global");
+    }
     async dev(type, name, projectDir) {
         const installInfo = await this.resolveInstalledResource(projectDir, type, name);
         const installedPath = installInfo.installedPath;
@@ -263,12 +289,12 @@ export class ServiceFactory {
         const lockSourceInfo = this.normalizeLockSourceInfo(lock.source);
         const lockedSource = await this.loadSourceFromLock(lockSourceInfo);
         for (const item of lock.resources) {
-            const result = await this.installWithSource(lockedSource, lockSourceInfo, item.type, item.name, item.version, projectDir, agents ?? item.agents, mode ?? this.resolveInstallMode(item.mode));
+            const result = await this.installWithSource(lockedSource, lockSourceInfo, item.type, item.name, item.version, projectDir, agents ?? item.agents, mode ?? this.resolveInstallMode(item.mode), "project");
             results.push(result);
         }
         return results;
     }
-    async installWithSource(source, sourceInfo, type, name, version, projectDir, agents, mode) {
+    async installWithSource(source, sourceInfo, type, name, version, projectDir, agents, mode, scope = "project") {
         const history = await source.history(type, name);
         if (history.length === 0) {
             throw new HimanError(errorCodes.RESOURCE_NOT_FOUND, `Resource not found: ${type}/${name}`);
@@ -279,18 +305,27 @@ export class ServiceFactory {
             await source.pull(type, name, resolvedVersion, storePath);
         }
         const resourceMeta = await this.readResourceMetaFromDir(storePath, type);
-        const effectiveTargets = await this.resolveEffectiveAgents(projectDir, agents, resourceMeta?.agents);
-        const linkPaths = getProjectResourcePaths(projectDir, type, name, effectiveTargets);
+        const effectiveTargets = scope === "global"
+            ? await this.resolveGlobalInstallAgents(projectDir, type, name, agents, resourceMeta?.agents)
+            : await this.resolveEffectiveAgents(projectDir, agents, resourceMeta?.agents);
+        const linkPaths = scope === "global"
+            ? getGlobalResourcePaths(this.paths.getHomeDir(), type, name, effectiveTargets)
+            : getProjectResourcePaths(projectDir, type, name, effectiveTargets);
         for (const linkPath of linkPaths) {
             await this.materializeResource(storePath, linkPath, mode);
         }
-        await this.lockStore.upsertResource(projectDir, sourceInfo, {
-            type,
-            name,
-            version: resolvedVersion,
-            agents: effectiveTargets,
-            mode,
-        });
+        if (scope === "project") {
+            if (!sourceInfo) {
+                throw new Error("Project install requires source lock information.");
+            }
+            await this.lockStore.upsertResource(projectDir, sourceInfo, {
+                type,
+                name,
+                version: resolvedVersion,
+                agents: effectiveTargets,
+                mode,
+            });
+        }
         return { type, name, version: resolvedVersion, linkPath: linkPaths[0], mode };
     }
     async loadSourceFromConfig() {
@@ -467,6 +502,16 @@ export class ServiceFactory {
         }
         return normalizeAgents(fallbackAgents);
     }
+    async resolveGlobalInstallAgents(projectDir, type, name, explicitAgents, fallbackAgents) {
+        if (explicitAgents?.length) {
+            return normalizeAgents(explicitAgents);
+        }
+        const locked = await this.getLockedResource(projectDir, type, name);
+        if (locked?.agents?.length) {
+            return normalizeAgents(locked.agents);
+        }
+        return this.resolveEffectiveAgents(projectDir, undefined, fallbackAgents);
+    }
     async getConfiguredAgents(projectDir) {
         const [globalConfig, projectConfig] = await Promise.all([
             this.stateStore.loadConfig(),

package/dist/utils/agent-configs.js

@@ -46,8 +46,14 @@ export function normalizeAgent(input) {
     return AGENT_ALIASES.get(input.trim().toLowerCase());
 }
 export function getProjectResourcePaths(projectDir, type, name, agents) {
+    return getResourcePaths(projectDir, type, name, agents);
+}
+export function getGlobalResourcePaths(homeDir, type, name, agents) {
+    return getResourcePaths(homeDir, type, name, agents);
+}
+function getResourcePaths(rootDir, type, name, agents) {
     const typeDir = getTypeDir(type);
-    return normalizeAgents(agents).map((agent) => path.join(projectDir, getAgentBaseDir(agent), typeDir, name));
+    return normalizeAgents(agents).map((agent) => path.join(rootDir, getAgentBaseDir(agent), typeDir, name));
 }
 export function getSupportedAgentNames() {
     return AGENT_CONFIGS.map((config) => config.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hi-man/himan",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Prompt and agent asset management CLI",
   "keywords": [
     "ai",