pi-code 1.0.3 → 1.0.5

package/extensions/plan-mode/utils.ts

@@ -3,6 +3,8 @@
  * Extracted for testability.
  */
 
+import { hasSubstitution, splitSegments } from '../internal/shell-split.js'
+
 // Destructive commands blocked in plan mode
 const DESTRUCTIVE_PATTERNS = [
   /\brm\b/i,
@@ -90,62 +92,6 @@ const SAFE_PATTERNS = [
   /^\s*eza\b/,
 ]
 
-// The shell can hide an arbitrary command inside any of these, so they are refused
-// outright rather than parsed.
-const SUBSTITUTION = /\$\(|`|<\(|>\(/
-
-/**
- * Split on the shell separators Claude Code documents (`&&`, `||`, `;`, `|`, `|&`, `&`,
- * newline) so every subcommand is checked on its own, ignoring separators inside quotes:
- * `grep 'a|b'` is one read, not a pipe. Returns nothing on an unbalanced quote, which
- * fails the caller closed rather than guessing at the intended split.
- *
- * A shell AST would be exact; this is the honest approximation for a quoting-only concern.
- */
-/** Length of the separator at `i`, or 0 when there is none. */
-function separatorAt(command: string, i: number): number {
-  const pair = command.slice(i, i + 2)
-  if (pair === '&&' || pair === '||' || pair === '|&') return 2
-  const ch = command[i]
-  return ch === ';' || ch === '|' || ch === '&' || ch === '\n' ? 1 : 0
-}
-
-function splitSegments(command: string): string[] {
-  const segments: string[] = []
-  let current = ''
-  let quote: "'" | '"' | undefined
-
-  for (let i = 0; i < command.length; i++) {
-    const ch = command[i]
-    if (quote !== undefined) {
-      current += ch
-      if (ch === quote) quote = undefined
-      continue
-    }
-    if (ch === "'" || ch === '"') {
-      quote = ch
-      current += ch
-      continue
-    }
-    if (ch === '\\' && i + 1 < command.length) {
-      current += ch + command[++i]
-      continue
-    }
-    const separator = separatorAt(command, i)
-    if (separator > 0) {
-      segments.push(current)
-      current = ''
-      i += separator - 1
-      continue
-    }
-    current += ch
-  }
-
-  if (quote !== undefined) return []
-  segments.push(current)
-  return segments.map((segment) => segment.trim()).filter(Boolean)
-}
-
 // find is allowlisted for traversal only; these actions run commands or delete.
 const FIND_ACTIONS = /\s-(exec|execdir|ok|okdir|delete|fls|fprint|fprintf)\b/
 
@@ -163,7 +109,7 @@ function isSafeSegment(segment: string): boolean {
  * containing a determined one. Only OS-level isolation would be a boundary.
  */
 export function isSafeCommand(command: string): boolean {
-  if (SUBSTITUTION.test(command)) return false
+  if (hasSubstitution(command)) return false
   const segments = splitSegments(command)
   return segments.length > 0 && segments.every(isSafeSegment)
 }

package/extensions/question.ts

@@ -35,7 +35,7 @@ const OptionSchema = Type.Object({
 const SingleQuestion = Type.Object({
   question: Type.String({ description: 'The question to ask the user' }),
   header: Type.Optional(Type.String({ description: 'Short label for the question, shown above it, kept to 12 characters' })),
-  options: Type.Array(OptionSchema, { description: 'Options for the user to choose from (1-4)', minItems: 1, maxItems: 4 }),
+  options: Type.Array(OptionSchema, { description: 'Options for the user to choose from (2-4)', minItems: 2, maxItems: 4 }),
   multiSelect: Type.Optional(Type.Boolean({ description: 'Allow selecting several options (space toggles, enter confirms)' })),
 })
 
@@ -44,7 +44,7 @@ const SingleQuestion = Type.Object({
  * shapes gave smaller models nothing to follow, and they produced neither. */
 export const QuestionParams = Type.Object({
   question: Type.Optional(Type.String({ description: 'The question to ask. Required, unless asking several via questions.' })),
-  options: Type.Optional(Type.Array(OptionSchema, { description: 'The 1-4 choices for this question, each {label, description?}. Required with question.', minItems: 1, maxItems: 4 })),
+  options: Type.Optional(Type.Array(OptionSchema, { description: 'The 2-4 choices for this question, each {label, description?}. Required with question.', minItems: 2, maxItems: 4 })),
   header: Type.Optional(Type.String({ description: 'Optional short label shown above the question, kept to 12 characters' })),
   multiSelect: Type.Optional(Type.Boolean({ description: 'Optional: allow selecting several options (space toggles, enter confirms)' })),
   questions: Type.Optional(Type.Array(SingleQuestion, { description: 'Only to ask 2-4 questions in one call: each entry takes the same fields as above. Leave unset for a single question.', minItems: 1, maxItems: 4 })),

package/extensions/skills.ts

@@ -15,7 +15,9 @@ import * as os from 'node:os'
 import * as path from 'node:path'
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
+import { installedPlugins } from './internal/plugins.js'
 import { isProjectApprovedSilently } from './internal/project-approval.js'
+import { findNearestDir } from './internal/project-root.js'
 
 function isDirectory(target: string): boolean {
   try {
@@ -32,7 +34,15 @@ function isDirectory(target: string): boolean {
  * text into the prompt without the user ever agreeing to load its config. */
 export function skillDirs(cwd: string, home: string, trusted: boolean): string[] {
   const candidates = [path.join(home, '.claude', 'skills')]
-  if (trusted) candidates.push(path.join(cwd, '.claude', 'skills'))
+  // Enabled plugins contribute their skills directories. pi's loader names a
+  // skill by its directory, so a plugin skill registers without Claude's
+  // /plugin: prefix; a rename-free approximation, disclosed in the README.
+  for (const plugin of installedPlugins(home)) {
+    const declared = plugin.manifest.skills
+    const dirs = Array.isArray(declared) ? declared : [typeof declared === 'string' ? declared : 'skills']
+    candidates.push(...dirs.map((dir) => path.resolve(plugin.root, String(dir))))
+  }
+  if (trusted) candidates.push(findNearestDir(cwd, path.join('.claude', 'skills')) ?? path.join(cwd, '.claude', 'skills'))
   const dirs: string[] = []
   for (const dir of candidates) {
     if (!dirs.includes(dir) && isDirectory(dir)) dirs.push(dir)

package/extensions/status-line.ts

@@ -21,6 +21,7 @@
 
 import * as fs from 'node:fs'
 import * as os from 'node:os'
+import * as path from 'node:path'
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
 
 import { hookFiles, runHookCommand } from './hooks.js'
@@ -31,6 +32,15 @@ import { readActiveStyleName, settingsFiles } from './output-styles.js'
 const COMMAND_TIMEOUT_MS = 5_000
 const DEBOUNCE_MS = 300
 
+/** Claude sends its CLI version; pi-code's own version is the honest analogue. */
+const PACKAGE_VERSION = (() => {
+  try {
+    return String(JSON.parse(fs.readFileSync(path.join(import.meta.dirname, '..', 'package.json'), 'utf-8')).version ?? '')
+  } catch {
+    return ''
+  }
+})()
+
 interface UsageEntry {
   type: string
   message?: { usage?: { cost?: { total?: number } } }
@@ -84,6 +94,17 @@ export default function statusLine(pi: ExtensionAPI) {
   let commandLine: string | undefined
   let permissionMode = 'default'
   let projectApproved = false
+  let sessionStartMs = Date.now()
+  // Lines changed, counted from successful edit/write inputs: newText and content
+  // lines add, oldText lines remove. An approximation of Claude's counters, which
+  // is honest for the tools pi has; bash-side changes are invisible to both.
+  let linesAdded = 0
+  let linesRemoved = 0
+  // API timing and the last message's token usage, from provider/message events:
+  // the fields ctx.getContextUsage() does not expose (output/cache tokens, API time).
+  let apiDurationMs = 0
+  let requestStartMs: number | undefined
+  let lastUsage: { input: number; output: number; cacheRead: number; cacheWrite: number; totalTokens: number } | undefined
   let refreshTimer: ReturnType<typeof setInterval> | undefined
   let debounceTimer: ReturnType<typeof setTimeout> | undefined
   let running = false
@@ -104,21 +125,57 @@ export default function statusLine(pi: ExtensionAPI) {
   /** The stdin payload per Claude's documented statusline contract. */
   function buildPayload(ctx: ExtensionContext): Record<string, unknown> {
     const usage = ctx.getContextUsage() ?? { tokens: null, contextWindow: 0, percent: null }
+    const model = ctx.model as { id?: string; name?: string } | undefined
     // Same gate as the config read above: an unapproved project's style is not applied,
     // so reporting it here would describe a style the session is not using.
     const styleName = readActiveStyleName(settingsFiles(ctx.cwd, os.homedir(), projectApproved))
     const payload: Record<string, unknown> = {
+      hook_event_name: 'Status',
       session_id: ctx.sessionManager.getSessionId(),
       cwd: ctx.cwd,
+      version: PACKAGE_VERSION,
       workspace: { current_dir: ctx.cwd, project_dir: ctx.cwd },
-      model: { id: (ctx.model as { id?: string } | undefined)?.id ?? '' },
-      cost: { total_cost_usd: sessionCost(ctx) },
-      context_window: { context_window_size: usage.contextWindow, used_percentage: usage.percent, total_input_tokens: usage.tokens },
+      // Both fields, per Claude's documented contract: published statusline scripts
+      // read .model.display_name and render the literal "null" when it is missing.
+      model: { id: model?.id ?? '', display_name: model?.name ?? model?.id ?? '' },
+      cost: {
+        total_cost_usd: sessionCost(ctx),
+        total_duration_ms: Date.now() - sessionStartMs,
+        total_api_duration_ms: apiDurationMs,
+        total_lines_added: linesAdded,
+        total_lines_removed: linesRemoved,
+      },
+      context_window: {
+        context_window_size: usage.contextWindow,
+        used_percentage: usage.percent,
+        remaining_percentage: usage.percent === null ? null : 100 - usage.percent,
+        total_input_tokens: usage.tokens,
+        // The per-component breakdown from the last message's usage, which
+        // ctx.getContextUsage() (input-side estimate only) cannot provide.
+        ...(lastUsage
+          ? {
+              total_output_tokens: lastUsage.output,
+              current_usage: {
+                input_tokens: lastUsage.input,
+                output_tokens: lastUsage.output,
+                cache_read_input_tokens: lastUsage.cacheRead,
+                cache_creation_input_tokens: lastUsage.cacheWrite,
+              },
+            }
+          : {}),
+      },
+      // The true combined total when a message usage is known, else the input-side estimate.
+      exceeds_200k_tokens: (lastUsage?.totalTokens ?? usage.tokens ?? 0) > 200_000,
       permission_mode: permissionMode,
     }
     const transcript = ctx.sessionManager.getSessionFile()
     if (transcript) payload.transcript_path = transcript
-    if (ctx.thinkingLevel) payload.effort = { level: ctx.thinkingLevel }
+    const sessionName = ctx.sessionManager.getSessionName?.()
+    if (sessionName) payload.session_name = sessionName
+    if (ctx.thinkingLevel) {
+      payload.effort = { level: ctx.thinkingLevel }
+      payload.thinking = { enabled: ctx.thinkingLevel !== 'off' }
+    }
     if (styleName) payload.output_style = { name: styleName }
     return payload
   }
@@ -167,11 +224,47 @@ export default function statusLine(pi: ExtensionAPI) {
     scheduleRefresh()
   })
 
+  // Counted here rather than in buildPayload so the numbers accumulate across the
+  // session the way Claude's counters do.
+  pi.on('tool_result', async (event) => {
+    if (event.isError) return
+    const input = event.input as Record<string, unknown>
+    const lines = (text: unknown): number => (typeof text === 'string' && text.length > 0 ? text.split('\n').length : 0)
+    if (event.toolName === 'write') linesAdded += lines(input.content)
+    if (event.toolName === 'edit' && Array.isArray(input.edits)) {
+      for (const edit of input.edits as Array<{ oldText?: unknown; newText?: unknown }>) {
+        linesAdded += lines(edit.newText)
+        linesRemoved += lines(edit.oldText)
+      }
+    }
+  })
+
+  // API round-trip timing: the window between the request and its response, summed
+  // across the session. ctx exposes no API-duration getter, so it is measured here.
+  pi.on('before_provider_request', async () => {
+    requestStartMs = Date.now()
+  })
+  pi.on('after_provider_response', async () => {
+    if (requestStartMs !== undefined) apiDurationMs += Date.now() - requestStartMs
+    requestStartMs = undefined
+  })
+  // The last message's token usage, for the breakdown getContextUsage() omits.
+  pi.on('message_end', async (event) => {
+    const usage = (event as { message?: { usage?: typeof lastUsage } }).message?.usage
+    if (usage) lastUsage = usage
+  })
+
   pi.on('session_start', async (_event, ctx) => {
     // One instance serves every session, so a fresh session must not inherit state.
     turnCount = 0
     commandLine = undefined
     sessionCtx = ctx
+    sessionStartMs = Date.now()
+    linesAdded = 0
+    linesRemoved = 0
+    apiDurationMs = 0
+    requestStartMs = undefined
+    lastUsage = undefined
     clearInterval(refreshTimer)
     // Reading config must never open a trust dialog: several extensions resolve
     // approval at session start, and a second prompt stacks over the first and eats

package/extensions/subagent/agents.ts

@@ -10,22 +10,31 @@ import { getAgentDir, parseFrontmatter, stripFrontmatter } from '@earendil-works
 // The same mapping a command's `allowed-tools` gets: an agent's `tools:` is the same
 // Claude field, and `--tools` is an exact-name allowlist, so a name pi has no tool for
 // is not merely ignored, it narrows the child's registry.
-import { parseToolList } from '../internal/command-file.js'
+import { parseToolGrants } from '../internal/command-file.js'
+import { installedPlugins } from '../internal/plugins.js'
+import { findNearestDir } from '../internal/project-root.js'
 
 /**
  * `tools:` may be a comma-separated string (the Claude Code format) or a YAML block
  * list. Anything else returns null: a restriction that failed to parse must not run
  * the agent unrestricted.
+ *
+ * An argument-scoped grant (`Bash(git log:*)`) cannot be expressed in the child's
+ * --tools allowlist, and the parent cannot reach into the child process to enforce
+ * it at call time the way commands.ts does, so on the granting side it is rejected
+ * like any other unexpressable restriction. A scoped *disallow* only denies more
+ * than the file asked for, which is the safe direction, so it stands.
  */
-function parseToolsField(raw: unknown): string[] | undefined | null {
+function parseToolsField(raw: unknown, granting: boolean): string[] | undefined | null {
   if (raw === undefined) return undefined
   // Shares the command parser's splitting, so a comma inside an argument scope stays
   // inside it here too: `Bash(mv, write, cp)` used to hand the child pi's real `write`.
   if (raw !== null && !Array.isArray(raw) && typeof raw !== 'string') return null
   if (Array.isArray(raw) && raw.some((item) => typeof item !== 'string')) return null
-  const tools = parseToolList(raw)
-  if (!tools) return null
-  return tools.length > 0 ? tools : undefined
+  const grants = parseToolGrants(raw)
+  if (!grants) return null
+  if (granting && grants.scopedEntries.length > 0) return null
+  return grants.tools.length > 0 ? grants.tools : undefined
 }
 
 /**
@@ -35,7 +44,7 @@ function parseToolsField(raw: unknown): string[] | undefined | null {
  * (Claude's `inherit`) is the degradation that works everywhere; users who want a
  * tier pinned should name a concrete model id.
  */
-const CLAUDE_MODEL_ALIASES = new Set(['sonnet', 'opus', 'haiku', 'inherit'])
+const CLAUDE_MODEL_ALIASES = new Set(['sonnet', 'opus', 'haiku', 'fable', 'inherit'])
 
 function parseModelField(raw: unknown): string | undefined {
   if (typeof raw !== 'string') return undefined
@@ -70,6 +79,20 @@ function parseEffortField(raw: unknown): string | undefined {
   return THINKING_LEVELS.has(effort) ? effort : undefined
 }
 
+/** Claude's agent `memory:` scopes: a persistent per-agent store for cross-session
+ * learning, separate from the parent conversation's auto memory. */
+export type AgentMemoryScope = 'user' | 'project' | 'local'
+
+const MEMORY_SCOPES: ReadonlySet<string> = new Set(['user', 'project', 'local'])
+
+/** Anything other than the three scopes is ignored, so the agent still runs, just
+ * without memory; a typo in an optional enhancement should not drop the agent. */
+function parseMemoryField(raw: unknown): AgentMemoryScope | undefined {
+  if (typeof raw !== 'string') return undefined
+  const scope = raw.trim().toLowerCase()
+  return MEMORY_SCOPES.has(scope) ? (scope as AgentMemoryScope) : undefined
+}
+
 /** Claude's `skills` frontmatter: a comma string or YAML list of skill names. */
 function parseSkillsField(raw: unknown): string[] | undefined {
   let names: string[] = []
@@ -145,9 +168,15 @@ function parseAgentFile(content: string, source: AgentSource, filePath: string):
   const name = typeof frontmatter.name === 'string' ? frontmatter.name : ''
   const description = typeof frontmatter.description === 'string' ? frontmatter.description : ''
   if (!name || !description) return null
-  const tools = parseToolsField(frontmatter.tools)
-  if (tools === null) return null
-  const disallowedTools = parseToolsField(frontmatter.disallowedTools)
+  const tools = parseToolsField(frontmatter.tools, true)
+  if (tools === null) {
+    // A silent drop reads as "agent does not exist"; say why, since an
+    // argument-scoped grant is a shape Claude's own docs recommend but pi cannot
+    // enforce on a child process.
+    console.warn(`pi-code-subagent: ignoring agent ${filePath}: its tools: grant could not be applied (an argument scope like Bash(git log:*) cannot be enforced on a subagent; grant the whole tool or drop it)`)
+    return null
+  }
+  const disallowedTools = parseToolsField(frontmatter.disallowedTools, false)
   if (disallowedTools === null) return null
   return {
     name,
@@ -158,12 +187,20 @@ function parseAgentFile(content: string, source: AgentSource, filePath: string):
     effort: parseEffortField(frontmatter.effort),
     modelAlias: parseModelAlias(frontmatter.model),
     skills: parseSkillsField(frontmatter.skills),
+    memory: parseMemoryField(frontmatter.memory),
+    maxTurns: parseMaxTurns(frontmatter.maxTurns),
     systemPrompt: body,
     source,
     filePath,
   }
 }
 
+/** Claude's `maxTurns`: a positive integer cap on the subagent's agentic turns.
+ * Anything else (0, negative, non-number) is ignored, so the run is uncapped. */
+function parseMaxTurns(raw: unknown): number | undefined {
+  return typeof raw === 'number' && Number.isInteger(raw) && raw > 0 ? raw : undefined
+}
+
 export type AgentScope = 'user' | 'project' | 'both'
 
 export interface AgentConfig {
@@ -177,6 +214,10 @@ export interface AgentConfig {
   modelAlias?: string
   /** Skill names to inline into the child's prompt, per Claude's `skills` field. */
   skills?: string[]
+  /** Persistent per-agent memory scope, per Claude's `memory:` field. */
+  memory?: AgentMemoryScope
+  /** Cap on the child's agentic turns, enforced by killing at the turn boundary. */
+  maxTurns?: number
   systemPrompt: string
   source: AgentSource
   filePath: string
@@ -187,25 +228,27 @@ export interface AgentDiscoveryResult {
   projectAgentsDir: string | null
 }
 
+/** Claude scans .claude/agents recursively so agents can be organized into
+ * subfolders (agents/review/, agents/research/); the walk mirrors that. */
 function loadAgentsFromDir(dir: string, source: AgentSource): AgentConfig[] {
   const agents: AgentConfig[] = []
 
-  if (!fs.existsSync(dir)) {
-    return agents
-  }
-
   let entries: fs.Dirent[]
   try {
     entries = fs.readdirSync(dir, { withFileTypes: true })
   } catch {
-    return agents
+    return agents // a missing or unreadable directory contributes nothing
   }
 
   for (const entry of entries) {
+    const filePath = path.join(dir, entry.name)
+    if (entry.isDirectory()) {
+      agents.push(...loadAgentsFromDir(filePath, source))
+      continue
+    }
     if (!entry.name.endsWith('.md')) continue
     if (!entry.isFile() && !entry.isSymbolicLink()) continue
 
-    const filePath = path.join(dir, entry.name)
     let content: string
     try {
       content = fs.readFileSync(filePath, 'utf-8')
@@ -220,49 +263,6 @@ function loadAgentsFromDir(dir: string, source: AgentSource): AgentConfig[] {
   return agents
 }
 
-function isDirectory(p: string): boolean {
-  try {
-    return fs.statSync(p).isDirectory()
-  } catch {
-    return false
-  }
-}
-
-/** Project root at or above `from`. `.git` is a file in worktrees and submodules. */
-const ROOT_MARKERS = ['.git', 'package.json']
-
-function repoRoot(from: string): string | undefined {
-  let currentDir = from
-  while (true) {
-    if (ROOT_MARKERS.some((marker) => fs.existsSync(path.join(currentDir, marker)))) return currentDir
-    const parentDir = path.dirname(currentDir)
-    if (parentDir === currentDir) return undefined
-    currentDir = parentDir
-  }
-}
-
-/**
- * Nearest `relative` directory at or above `cwd`, stopping at the repository root.
- *
- * Without the boundary the search runs to the filesystem root, so an agent planted in a
- * world-writable ancestor such as /tmp is offered as a project agent for every session
- * beneath it. With no project marker (.git, package.json) the extent is unknown, so only
- * `cwd` is considered.
- */
-function findNearestDir(cwd: string, relative: string): string | null {
-  const boundary = repoRoot(cwd) ?? cwd
-  let currentDir = cwd
-  while (true) {
-    const candidate = path.join(currentDir, relative)
-    if (isDirectory(candidate)) return candidate
-
-    if (currentDir === boundary) return null
-    const parentDir = path.dirname(currentDir)
-    if (parentDir === currentDir) return null
-    currentDir = parentDir
-  }
-}
-
 function buildAgentMap(userAgents: AgentConfig[], projectAgents: AgentConfig[], scope: AgentScope): Map<string, AgentConfig> {
   const agentMap = new Map<string, AgentConfig>()
   const register = (agents: AgentConfig[]): void => {
@@ -274,19 +274,30 @@ function buildAgentMap(userAgents: AgentConfig[], projectAgents: AgentConfig[],
   return agentMap
 }
 
-export type AgentSource = 'user' | 'project' | 'builtin'
+export type AgentSource = 'user' | 'project' | 'builtin' | 'plugin'
 
 /** Bundled default agents (Explore, Plan, general-purpose), lowest precedence. */
 export const BUILTIN_AGENTS_DIR = path.join(import.meta.dirname, 'agents')
 
+/** Agent directories of every enabled plugin: `agents/` unless the manifest
+ * points elsewhere. Plugins are user-installed, so user scope only decides. */
+function pluginAgentDirs(home: string): string[] {
+  return installedPlugins(home).flatMap((plugin) => {
+    const declared = plugin.manifest.agents
+    const dirs = Array.isArray(declared) ? declared : [typeof declared === 'string' ? declared : 'agents']
+    return dirs.map((dir) => path.resolve(plugin.root, String(dir)))
+  })
+}
+
 export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {
   const userDir = path.join(getAgentDir(), 'agents')
   const claudeUserDir = path.join(os.homedir(), '.claude', 'agents')
   const projectPiDir = findNearestDir(cwd, path.join('.pi', 'agents'))
   const projectClaudeDir = findNearestDir(cwd, path.join('.claude', 'agents'))
 
-  // ~/.claude/agents loads first so ~/.pi/agent/agents wins on name conflicts
-  const userAgents = scope === 'project' ? [] : [...loadAgentsFromDir(BUILTIN_AGENTS_DIR, 'builtin'), ...loadAgentsFromDir(claudeUserDir, 'user'), ...loadAgentsFromDir(userDir, 'user')]
+  // Plugins load after builtins and before the user's own dirs, so a user agent
+  // wins a name clash with a plugin's, and ~/.pi/agent/agents wins over ~/.claude.
+  const userAgents = scope === 'project' ? [] : [...loadAgentsFromDir(BUILTIN_AGENTS_DIR, 'builtin'), ...pluginAgentDirs(os.homedir()).flatMap((dir) => loadAgentsFromDir(dir, 'plugin')), ...loadAgentsFromDir(claudeUserDir, 'user'), ...loadAgentsFromDir(userDir, 'user')]
   // project .claude/agents loads first so project .pi/agents wins on name conflicts
   const projectAgents = scope === 'user' ? [] : [...(projectClaudeDir ? loadAgentsFromDir(projectClaudeDir, 'project') : []), ...(projectPiDir ? loadAgentsFromDir(projectPiDir, 'project') : [])]