@phnx-labs/agents-cli 1.15.0 → 1.17.0

package/dist/lib/pty-server.js

@@ -14,7 +14,7 @@ import * as path from 'path';
 import * as crypto from 'crypto';
 import { execFileSync } from 'child_process';
 import { fileURLToPath } from 'url';
-import { getAgentsDir } from './state.js';
+import { getPtyDir as getPtyDirRoot } from './state.js';
 /**
  * Capture a stable identifier for a process at the moment it was started.
  * Used to defeat PID reuse: a kill(pid, ...) is only safe when the process
@@ -53,7 +53,6 @@ export function captureProcessStartTime(pid) {
 }
 // --- Constants ---
 const SENTINEL = '__AGENTS_PTY_DONE__';
-const PTY_DIR = 'helpers/pty';
 const SOCKET_NAME = 'pty.sock';
 const PID_FILE = 'pty.pid';
 const LOG_FILE = 'logs.jsonl';
@@ -84,7 +83,7 @@ function buildPtyEnv() {
 }
 /** Get the PTY helper directory, creating it if needed. */
 function getPtyDir() {
-    const dir = path.join(getAgentsDir(), PTY_DIR);
+    const dir = getPtyDirRoot();
     fs.mkdirSync(dir, { recursive: true });
     return dir;
 }
@@ -178,7 +177,7 @@ export async function runPtyServer() {
     }
     catch (err) {
         console.error('node-pty is required for PTY support.');
-        console.error('Install: cd ' + getAgentsDir() + '/../agents-cli && bun add node-pty');
+        console.error('Install: cd ' + '~/agents-cli && bun add node-pty');
         process.exit(1);
     }
     try {
@@ -188,7 +187,7 @@ export async function runPtyServer() {
     }
     catch {
         console.error('@xterm/headless is required for PTY support.');
-        console.error('Install: cd ' + getAgentsDir() + '/../agents-cli && bun add @xterm/headless');
+        console.error('Install: cd ' + '~/agents-cli && bun add @xterm/headless');
         process.exit(1);
     }
     const sessions = new Map();
@@ -493,11 +492,11 @@ export async function runPtyServer() {
         });
         conn.on('error', () => { });
     });
-    // Lock down ~/.agents-system/ before opening the socket — without this, any local
-    // user with execute on the parent dir could connect to the socket during
-    // the listen()-to-chmod() window. macOS BSD AF_UNIX semantics make socket
-    // mode advisory only, so the parent dir is the real boundary.
-    const agentsDir = getAgentsDir();
+    // Lock down the PTY scratch dir before opening the socket — without this,
+    // any local user with execute on the parent dir could connect to the socket
+    // during the listen()-to-chmod() window. macOS BSD AF_UNIX semantics make
+    // socket mode advisory only, so the parent dir is the real boundary.
+    const agentsDir = getPtyDirRoot();
     fs.mkdirSync(agentsDir, { recursive: true });
     fs.chmodSync(agentsDir, 0o700);
     // umask covers any inherited group/other bits while listen() is creating

package/dist/lib/resource-patterns.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Resource selection patterns for agents.yaml versions: entries.
+ *
+ * Pattern syntax: [!]source:name
+ *   "system:*"     — all resources from ~/.agents-system/
+ *   "user:*"       — all resources from ~/.agents/
+ *   "rush:*"       — all resources from ~/.agents-rush/  (extra repo alias)
+ *   "project:*"    — all resources from .agents/ in the project root
+ *   "user:foo"     — specifically the resource named "foo" from ~/.agents/
+ *   "!user:temp"   — exclude "temp" from the user repo
+ *
+ * Evaluation rule: union all inclusions, then subtract all exclusions.
+ */
+export interface ParsedPattern {
+    negate: boolean;
+    source: string;
+    name: string;
+}
+export declare function parsePattern(p: string): ParsedPattern;
+/** Returns true if the string is a legacy plain name with no source: prefix. */
+export declare function isLegacyName(p: string): boolean;
+/**
+ * Expand a list of patterns against an available name→source map.
+ * Returns the union of matching names with exclusions subtracted.
+ *
+ * Supports comma-grouped names to avoid repeating the source prefix:
+ *   "system:brain-scan,mq"  →  includes brain-scan and mq from system
+ *   "!user:temp,draft"      →  excludes temp and draft from user
+ *
+ * Note: in YAML flow sequences ([...]) a comma inside a pattern requires
+ * quoting ("system:brain-scan,mq"). Block-style items and yaml.stringify
+ * output handle this automatically.
+ */
+export declare function expandPatterns(patterns: string[], available: Map<string, string>): string[];
+/**
+ * Build the default pattern list for a resource type.
+ * Order: system → user → alias1 → alias2 → ... → project (base-to-override).
+ * @param extraAliases  Alias names of enabled extra repos, in insertion order.
+ * @param includeProject  Whether to append "project:*". False for hooks (security).
+ */
+export declare function defaultPatterns(extraAliases?: string[], includeProject?: boolean): string[];

package/dist/lib/resource-patterns.js

@@ -0,0 +1,82 @@
+/**
+ * Resource selection patterns for agents.yaml versions: entries.
+ *
+ * Pattern syntax: [!]source:name
+ *   "system:*"     — all resources from ~/.agents-system/
+ *   "user:*"       — all resources from ~/.agents/
+ *   "rush:*"       — all resources from ~/.agents-rush/  (extra repo alias)
+ *   "project:*"    — all resources from .agents/ in the project root
+ *   "user:foo"     — specifically the resource named "foo" from ~/.agents/
+ *   "!user:temp"   — exclude "temp" from the user repo
+ *
+ * Evaluation rule: union all inclusions, then subtract all exclusions.
+ */
+export function parsePattern(p) {
+    const negate = p.startsWith('!');
+    const raw = negate ? p.slice(1) : p;
+    const colon = raw.indexOf(':');
+    if (colon === -1) {
+        throw new Error(`Invalid resource pattern "${p}": expected "source:name" format`);
+    }
+    return { negate, source: raw.slice(0, colon), name: raw.slice(colon + 1) };
+}
+/** Returns true if the string is a legacy plain name with no source: prefix. */
+export function isLegacyName(p) {
+    return !p.startsWith('!') && !p.includes(':');
+}
+/**
+ * Expand a list of patterns against an available name→source map.
+ * Returns the union of matching names with exclusions subtracted.
+ *
+ * Supports comma-grouped names to avoid repeating the source prefix:
+ *   "system:brain-scan,mq"  →  includes brain-scan and mq from system
+ *   "!user:temp,draft"      →  excludes temp and draft from user
+ *
+ * Note: in YAML flow sequences ([...]) a comma inside a pattern requires
+ * quoting ("system:brain-scan,mq"). Block-style items and yaml.stringify
+ * output handle this automatically.
+ */
+export function expandPatterns(patterns, available) {
+    const included = new Set();
+    const excluded = new Set();
+    for (const p of patterns) {
+        try {
+            const { negate, source, name } = parsePattern(p);
+            const target = negate ? excluded : included;
+            // Comma-grouped names: "system:brain-scan,mq" → ['brain-scan', 'mq']
+            const names = name === '*' ? ['*'] : name.split(',').map(n => n.trim()).filter(Boolean);
+            for (const n of names) {
+                if (n === '*') {
+                    for (const [rn, rs] of available) {
+                        if (rs === source)
+                            target.add(rn);
+                    }
+                }
+                else {
+                    if (available.has(n))
+                        target.add(n);
+                }
+            }
+        }
+        catch {
+            // Skip malformed patterns
+        }
+    }
+    return [...included].filter(n => !excluded.has(n));
+}
+/**
+ * Build the default pattern list for a resource type.
+ * Order: system → user → alias1 → alias2 → ... → project (base-to-override).
+ * @param extraAliases  Alias names of enabled extra repos, in insertion order.
+ * @param includeProject  Whether to append "project:*". False for hooks (security).
+ */
+export function defaultPatterns(extraAliases = [], includeProject = true) {
+    const patterns = ['system:*', 'user:*'];
+    for (const alias of extraAliases) {
+        patterns.push(`${alias}:*`);
+    }
+    if (includeProject) {
+        patterns.push('project:*');
+    }
+    return patterns;
+}

package/dist/lib/resources/hooks.d.ts

@@ -1,7 +1,11 @@
 /**
  * HooksHandler - ResourceHandler implementation for hooks.
  *
- * Hooks are declared in hooks.yaml at each layer (system, user, project).
+ * Hook declarations live in:
+ *   - System: ~/.agents-system/hooks.yaml (npm-shipped defaults)
+ *   - User:   `hooks:` section of ~/.agents/agents.yaml
+ *   - Project: <project>/.agents/hooks.yaml
+ *
  * Resolution: project > user > system (higher layer wins on name conflict).
  * Non-conflicting hooks from all layers are unioned together.
  */

package/dist/lib/resources/hooks.js

@@ -1,7 +1,11 @@
 /**
  * HooksHandler - ResourceHandler implementation for hooks.
  *
- * Hooks are declared in hooks.yaml at each layer (system, user, project).
+ * Hook declarations live in:
+ *   - System: ~/.agents-system/hooks.yaml (npm-shipped defaults)
+ *   - User:   `hooks:` section of ~/.agents/agents.yaml
+ *   - Project: <project>/.agents/hooks.yaml
+ *
  * Resolution: project > user > system (higher layer wins on name conflict).
  * Non-conflicting hooks from all layers are unioned together.
  */
@@ -10,13 +14,20 @@ import * as path from 'path';
 import * as yaml from 'yaml';
 import { getSystemAgentsDir, getUserAgentsDir, getProjectAgentsDir, } from '../state.js';
 /**
- * Get the hooks.yaml path for a given layer directory.
+ * Get the hook manifest path for a layer dir. The user layer reads from
+ * agents.yaml (hooks: section) since that's where user hooks now live.
+ * Other layers continue to use a standalone hooks.yaml.
  */
 function getHooksYamlPath(layerDir) {
+    if (layerDir === getUserAgentsDir()) {
+        return path.join(layerDir, 'agents.yaml');
+    }
     return path.join(layerDir, 'hooks.yaml');
 }
 /**
- * Parse hooks.yaml from a directory.
+ * Parse hooks for a layer directory.
+ * - User layer: read `hooks:` section from agents.yaml.
+ * - System / project layer: read top-level map from hooks.yaml.
  * Returns empty object if file doesn't exist or is invalid.
  */
 function parseHooksYaml(dir) {
@@ -27,7 +38,13 @@ function parseHooksYaml(dir) {
     try {
         const content = fs.readFileSync(manifestPath, 'utf-8');
         const parsed = yaml.parse(content);
-        return parsed || {};
+        if (!parsed)
+            return {};
+        if (dir === getUserAgentsDir()) {
+            const hooks = parsed.hooks;
+            return (hooks && typeof hooks === 'object') ? hooks : {};
+        }
+        return parsed;
     }
     catch {
         return {};

package/dist/lib/resources/index.d.ts

@@ -13,6 +13,7 @@ export { RulesHandler, type RuleItem } from './rules.js';
 export { McpHandler, getMcpConfigPath, type McpItem } from './mcp.js';
 export { PermissionsHandler, type PermissionItem } from './permissions.js';
 export { SubagentsHandler, subagentsHandler, type SubagentItem } from './subagents.js';
+export { WorkflowsHandler, type WorkflowItem } from './workflows.js';
 import type { ResourceKind, ResourceHandler } from './types.js';
 /** All resource handlers keyed by kind. */
 export declare const handlers: {
@@ -29,6 +30,22 @@ export declare const handlers: {
     readonly permissions: ResourceHandler<import("../types.js").PermissionSet>;
     readonly subagent: import("./subagents.js").SubagentsHandler;
     readonly subagents: import("./subagents.js").SubagentsHandler;
+    readonly workflow: {
+        readonly kind: "workflow";
+        listAll(_agent: import("./types.js").AgentId, cwd?: string): import("./types.js").ResolvedItem<import("./workflows.js").WorkflowItem>[];
+        resolve(_agent: import("./types.js").AgentId, name: string, cwd?: string): import("./types.js").ResolvedItem<import("./workflows.js").WorkflowItem> | null;
+        sync(_agent: import("./types.js").AgentId, _versionHome: string, _cwd?: string): void;
+        format(_agent: import("./types.js").AgentId): "md";
+        targetDir(_agent: import("./types.js").AgentId): string;
+    };
+    readonly workflows: {
+        readonly kind: "workflow";
+        listAll(_agent: import("./types.js").AgentId, cwd?: string): import("./types.js").ResolvedItem<import("./workflows.js").WorkflowItem>[];
+        resolve(_agent: import("./types.js").AgentId, name: string, cwd?: string): import("./types.js").ResolvedItem<import("./workflows.js").WorkflowItem> | null;
+        sync(_agent: import("./types.js").AgentId, _versionHome: string, _cwd?: string): void;
+        format(_agent: import("./types.js").AgentId): "md";
+        targetDir(_agent: import("./types.js").AgentId): string;
+    };
 };
 /** Get a handler by resource kind. */
 export declare function getHandler(kind: ResourceKind): ResourceHandler<unknown> | null;

package/dist/lib/resources/index.js

@@ -13,6 +13,7 @@ export { RulesHandler } from './rules.js';
 export { McpHandler, getMcpConfigPath } from './mcp.js';
 export { PermissionsHandler } from './permissions.js';
 export { SubagentsHandler, subagentsHandler } from './subagents.js';
+export { WorkflowsHandler } from './workflows.js';
 import { commandsHandler } from './commands.js';
 import { HooksHandler } from './hooks.js';
 import { SkillsHandler } from './skills.js';
@@ -20,6 +21,7 @@ import { RulesHandler } from './rules.js';
 import { McpHandler } from './mcp.js';
 import { PermissionsHandler } from './permissions.js';
 import { subagentsHandler } from './subagents.js';
+import { WorkflowsHandler } from './workflows.js';
 /** All resource handlers keyed by kind. */
 export const handlers = {
     command: commandsHandler,
@@ -35,6 +37,8 @@ export const handlers = {
     permissions: PermissionsHandler,
     subagent: subagentsHandler,
     subagents: subagentsHandler,
+    workflow: WorkflowsHandler,
+    workflows: WorkflowsHandler,
 };
 /** Get a handler by resource kind. */
 export function getHandler(kind) {
@@ -53,6 +57,8 @@ export function getHandler(kind) {
             return PermissionsHandler;
         case 'subagent':
             return subagentsHandler;
+        case 'workflow':
+            return WorkflowsHandler;
         default:
             return null;
     }
@@ -66,4 +72,5 @@ export const RESOURCE_KINDS = [
     'mcp',
     'permission',
     'subagent',
+    'workflow',
 ];

package/dist/lib/resources/types.d.ts

@@ -7,7 +7,7 @@
  */
 export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw';
 export type Layer = 'system' | 'user' | 'project';
-export type ResourceKind = 'command' | 'hook' | 'skill' | 'rule' | 'mcp' | 'permission' | 'subagent';
+export type ResourceKind = 'command' | 'hook' | 'skill' | 'rule' | 'mcp' | 'permission' | 'subagent' | 'workflow';
 /** A resolved resource with its origin layer. */
 export interface ResolvedItem<T> {
     name: string;

package/dist/lib/resources/workflows.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Workflows resource handler.
+ *
+ * Workflows are directory bundles with a WORKFLOW.md containing YAML frontmatter.
+ * They optionally contain subagents/, skills/, and plugins/ subdirectories.
+ * Resolution order: project > user > system.
+ */
+import type { AgentId, ResolvedItem, ResourceHandler } from './types.js';
+export interface WorkflowItem {
+    name: string;
+    description: string;
+    model?: string;
+    subagentCount: number;
+}
+declare class WorkflowsHandlerImpl implements ResourceHandler<WorkflowItem> {
+    readonly kind: "workflow";
+    listAll(_agent: AgentId, cwd?: string): ResolvedItem<WorkflowItem>[];
+    resolve(_agent: AgentId, name: string, cwd?: string): ResolvedItem<WorkflowItem> | null;
+    sync(_agent: AgentId, _versionHome: string, _cwd?: string): void;
+    format(_agent: AgentId): 'md';
+    targetDir(_agent: AgentId): string;
+}
+export declare const WorkflowsHandler: WorkflowsHandlerImpl;
+export {};

package/dist/lib/resources/workflows.js

@@ -0,0 +1,110 @@
+/**
+ * Workflows resource handler.
+ *
+ * Workflows are directory bundles with a WORKFLOW.md containing YAML frontmatter.
+ * They optionally contain subagents/, skills/, and plugins/ subdirectories.
+ * Resolution order: project > user > system.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { getProjectAgentsDir, getUserWorkflowsDir, getSystemWorkflowsDir, getEnabledExtraRepos, } from '../state.js';
+import { parseWorkflowFrontmatter, countWorkflowSubagents } from '../workflows.js';
+function getLayerDirs(cwd) {
+    const projectDir = getProjectAgentsDir(cwd);
+    const extraRepos = getEnabledExtraRepos();
+    return {
+        system: getSystemWorkflowsDir(),
+        user: getUserWorkflowsDir(),
+        project: projectDir ? path.join(projectDir, 'workflows') : null,
+        extra: extraRepos.map(e => path.join(e.dir, 'workflows')),
+    };
+}
+function listWorkflowsInDir(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true })
+            .filter(e => e.isDirectory() && !e.name.startsWith('.') &&
+            fs.existsSync(path.join(dir, e.name, 'WORKFLOW.md')))
+            .map(e => ({ name: e.name, path: path.join(dir, e.name) }));
+    }
+    catch {
+        return [];
+    }
+}
+class WorkflowsHandlerImpl {
+    kind = 'workflow';
+    listAll(_agent, cwd) {
+        const dirs = getLayerDirs(cwd);
+        const seen = new Set();
+        const results = [];
+        const layerDirs = [];
+        if (dirs.project)
+            layerDirs.push({ dir: dirs.project, layer: 'project' });
+        layerDirs.push({ dir: dirs.user, layer: 'user' });
+        layerDirs.push({ dir: dirs.system, layer: 'system' });
+        for (const extraDir of dirs.extra)
+            layerDirs.push({ dir: extraDir, layer: 'system' });
+        for (const { dir, layer } of layerDirs) {
+            for (const { name, path: workflowPath } of listWorkflowsInDir(dir)) {
+                if (seen.has(name))
+                    continue;
+                const fm = parseWorkflowFrontmatter(workflowPath);
+                if (!fm)
+                    continue;
+                seen.add(name);
+                results.push({
+                    name,
+                    item: {
+                        name: fm.name || name,
+                        description: fm.description,
+                        model: fm.model,
+                        subagentCount: countWorkflowSubagents(workflowPath),
+                    },
+                    layer,
+                    path: workflowPath,
+                });
+            }
+        }
+        return results.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    resolve(_agent, name, cwd) {
+        const dirs = getLayerDirs(cwd);
+        const searchDirs = [];
+        if (dirs.project)
+            searchDirs.push({ dir: dirs.project, layer: 'project' });
+        searchDirs.push({ dir: dirs.user, layer: 'user' });
+        searchDirs.push({ dir: dirs.system, layer: 'system' });
+        for (const extraDir of dirs.extra)
+            searchDirs.push({ dir: extraDir, layer: 'system' });
+        for (const { dir, layer } of searchDirs) {
+            const workflowPath = path.join(dir, name);
+            const fm = parseWorkflowFrontmatter(workflowPath);
+            if (fm) {
+                return {
+                    name,
+                    item: {
+                        name: fm.name || name,
+                        description: fm.description,
+                        model: fm.model,
+                        subagentCount: countWorkflowSubagents(workflowPath),
+                    },
+                    layer,
+                    path: workflowPath,
+                };
+            }
+        }
+        return null;
+    }
+    sync(_agent, _versionHome, _cwd) {
+        // Version-home copies are written by syncResourcesToVersion in versions.ts.
+        // exec.ts resolves workflows at run time from source dirs directly.
+    }
+    format(_agent) {
+        return 'md';
+    }
+    targetDir(_agent) {
+        return 'workflows';
+    }
+}
+export const WorkflowsHandler = new WorkflowsHandlerImpl();

package/dist/lib/resources.d.ts

@@ -11,7 +11,11 @@ export interface ResolvedResource {
     name: string;
     /** Absolute path to the resource file or directory. */
     path: string;
-    source: 'project' | 'user' | 'system';
+    /**
+     * Source layer: 'project' | 'user' | 'system' for built-in layers,
+     * or the alias name (e.g. 'rush') for extra repos registered in agents.yaml.
+     */
+    source: string;
 }
 /**
  * Resolve a single resource by kind + name using project > user > system precedence.
@@ -52,6 +56,7 @@ export interface AgentResources {
     mcp: McpResourceEntry[];
     memory: ResourceEntry[];
     hooks: ResourceEntry[];
+    workflows: ResourceEntry[];
 }
 /** Options for resource discovery. */
 export interface GetAgentResourcesOptions {

package/dist/lib/resources.js

@@ -11,6 +11,8 @@ import { listInstalledHooksWithScope } from './hooks.js';
 import { listInstalledInstructionsWithScope } from './rules/rules.js';
 import { getEffectiveHome } from './versions.js';
 import { listMcpServerConfigs } from './mcp.js';
+import { WorkflowsHandler } from './resources/workflows.js';
+import { WORKFLOW_CAPABLE_AGENTS } from './workflows.js';
 import { getProjectAgentsDir, getUserAgentsDir, getSystemAgentsDir, getEnabledExtraRepos, } from './state.js';
 /**
  * Resolve a single resource by kind + name using project > user > system precedence.
@@ -26,7 +28,7 @@ export function resolveResource(kind, name, cwd) {
         ...(projectDir ? [[path.join(projectDir, kind), 'project']] : []),
         [path.join(getUserAgentsDir(), kind), 'user'],
         [path.join(getSystemAgentsDir(), kind), 'system'],
-        ...extraRepos.map((e) => [path.join(e.dir, kind), 'system']),
+        ...extraRepos.map((e) => [path.join(e.dir, kind), e.alias]),
     ];
     for (const [dir, source] of candidates) {
         if (!fs.existsSync(dir))
@@ -60,7 +62,7 @@ export function listResources(kind, cwd) {
         ...(projectDir ? [[path.join(projectDir, kind), 'project']] : []),
         [path.join(getUserAgentsDir(), kind), 'user'],
         [path.join(getSystemAgentsDir(), kind), 'system'],
-        ...extraRepos.map((e) => [path.join(e.dir, kind), 'system']),
+        ...extraRepos.map((e) => [path.join(e.dir, kind), e.alias]),
     ];
     for (const [dir, source] of roots) {
         if (!fs.existsSync(dir))
@@ -159,6 +161,13 @@ export function getAgentResources(agentId, options = {}) {
             hooks.push({ name: hook.name, path: hook.path, scope: hook.scope });
         }
     }
+    // Workflows (claude only)
+    const workflows = [];
+    if (WORKFLOW_CAPABLE_AGENTS.includes(agentId)) {
+        for (const w of WorkflowsHandler.listAll(agentId, cwd)) {
+            workflows.push({ name: w.name, path: w.path, scope: w.layer === 'project' ? 'project' : 'user' });
+        }
+    }
     return {
         agentId,
         commands,
@@ -167,6 +176,7 @@ export function getAgentResources(agentId, options = {}) {
         mcp,
         memory,
         hooks,
+        workflows,
     };
 }
 /**

package/dist/lib/rotate.js

@@ -8,12 +8,11 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
 import { getAccountInfo } from './agents.js';
-import { readMeta, writeMeta, getAgentsDir } from './state.js';
+import { readMeta, writeMeta, getHelpersDir, getUserAgentsDir } from './state.js';
 import { listInstalledVersions, getVersionHomePath, resolveVersion } from './versions.js';
 import { getUsageInfoByIdentity, getUsageLookupKey, isClaudeAuthValid, } from './usage.js';
-const ROTATE_DIR = 'helpers/rotate';
 function getRotateDir() {
-    const dir = path.join(getAgentsDir(), ROTATE_DIR);
+    const dir = path.join(getHelpersDir(), 'rotate');
     fs.mkdirSync(dir, { recursive: true });
     return dir;
 }
@@ -35,7 +34,7 @@ export function normalizeRunStrategy(value) {
 /** Read project-local run strategy from the nearest agents.yaml, if present. */
 export function getProjectRunStrategy(agent, startPath) {
     let dir = path.resolve(startPath);
-    const userAgentsYaml = path.join(getAgentsDir(), 'agents.yaml');
+    const userAgentsYaml = path.join(getUserAgentsDir(), 'agents.yaml');
     while (dir !== path.dirname(dir)) {
         const manifestPath = path.join(dir, 'agents.yaml');
         if (manifestPath !== userAgentsYaml && fs.existsSync(manifestPath)) {

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

@@ -8,7 +8,10 @@ export interface ActiveSession {
     pid?: number;
     sessionId?: string;
     cwd?: string;
+    /** User-given name from /rename command. */
     label?: string;
+    /** First meaningful line of the initial prompt (extracted topic). */
+    topic?: string;
     sessionFile?: string;
     startedAtMs?: number;
     status: ActiveStatus;