pi-code 1.0.22 → 1.0.24

package/extensions/claude-rules.ts

@@ -21,8 +21,10 @@ import * as os from 'node:os'
 import * as path from 'node:path'
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
+import { claudeMdExcludeFiles, isExcludedPath, readClaudeMdExcludes } from './context-imports.js'
 import { claudeConfigDir } from './internal/config-dir.js'
 import { publishInstructionLoad } from './internal/instruction-events.js'
+import { readManagedSettings } from './internal/managed-settings.js'
 import { type CompiledGlob, compileGlobs, matchesCompiledGlobs } from './internal/path-rules.js'
 import { isProjectApproved } from './internal/project-approval.js'
 import { findNearestDir } from './internal/project-root.js'
@@ -147,12 +149,36 @@ interface RuleSet {
 
 const EMPTY_RULES: RuleSet = { inline: [], scoped: [] }
 
+/** The canonical form of a path. A target that does not exist yet (a write
+ * creating a new file) canonicalises its nearest existing ancestor and keeps the
+ * remaining segments, so both sides of the attach match compare realpaths even
+ * for brand-new files in a symlinked checkout. */
+function realpathOr(target: string): string {
+  try {
+    return fs.realpathSync(target)
+  } catch {
+    const dir = path.dirname(target)
+    if (dir === target) return target
+    return path.join(realpathOr(dir), path.basename(target))
+  }
+}
+
 /** Unscoped rules are inlined; path-scoped ones keep their scope as pointers,
- * mirroring Claude Code, where scoped rules attach only to matching files. */
-function readRules(rulesDir: string): RuleSet {
+ * mirroring Claude Code, where scoped rules attach only to matching files. Files
+ * matching `claudeMdExcludes` are skipped entirely, as the docs' monorepo recipe
+ * (excluding another team's `.claude/rules/**`) relies on; the check runs on the
+ * realpath so a symlink cannot dodge an exclusion. */
+function readRules(rulesDir: string, isExcluded?: (realPath: string) => boolean): RuleSet {
   const inline: string[] = []
   const scoped: ScopedRule[] = []
   for (const file of findMarkdownFiles(rulesDir)) {
+    if (isExcluded) {
+      // Both spellings count: a glob written against the lexical path and one
+      // written against the resolved real path each exclude, which can only
+      // widen an exclusion, never dodge one.
+      const lexical = path.join(rulesDir, file)
+      if (isExcluded(lexical) || isExcluded(realpathOr(lexical))) continue
+    }
     let parsed: Frontmatter
     try {
       parsed = parseFrontmatter(fs.readFileSync(path.join(rulesDir, file), 'utf-8'))
@@ -223,15 +249,20 @@ export default function claudeRulesExtension(pi: ExtensionAPI) {
   let attachTargets: AttachTarget[] = []
 
   pi.on('session_start', async (_event, ctx) => {
-    globalRules = readRules(globalRulesDir)
     // Project rules are repository text landing in the system prompt, so they load
     // only once the project is approved. isProjectTrusted alone is true for a repo
     // pi never asked about; see project-approval.
     const approved = await isProjectApproved(ctx)
+    // Claude's claudeMdExcludes covers rules files too (the docs' monorepo recipe
+    // excludes another team's .claude/rules/**), so the same merged glob list the
+    // context loader honors gates rule files here.
+    const excludeGlobs = readClaudeMdExcludes(claudeMdExcludeFiles(ctx.cwd, os.homedir(), approved), readManagedSettings())
+    const isExcluded = (realPath: string): boolean => isExcludedPath(realPath, excludeGlobs, os.homedir())
+    globalRules = readRules(globalRulesDir, isExcluded)
     // Nearest at-or-above cwd, so a subdirectory session still reads the rules the
     // approval walk gated on.
     const projectRulesDir = approved ? findNearestDir(ctx.cwd, path.join('.claude', 'rules')) : null
-    projectRules = projectRulesDir ? readRules(projectRulesDir) : EMPTY_RULES
+    projectRules = projectRulesDir ? readRules(projectRulesDir, isExcluded) : EMPTY_RULES
 
     // Global globs are relative to cwd; project globs to the project root (the dir
     // holding .claude), so `db/**` in a repo rule matches repo-relative paths even
@@ -239,8 +270,8 @@ export default function claudeRulesExtension(pi: ExtensionAPI) {
     // than on every tool result; rebuilt per session so a re-run re-attaches.
     const projectRoot = projectRulesDir ? path.dirname(path.dirname(projectRulesDir)) : ctx.cwd
     attachTargets = [
-      ...globalRules.scoped.map((rule) => ({ globs: rule.paths, compiled: compileGlobs(rule.paths), body: rule.body, root: ctx.cwd, file: path.join(globalRulesDir, rule.rel), memoryType: 'User' as const })),
-      ...projectRules.scoped.map((rule) => ({ globs: rule.paths, compiled: compileGlobs(rule.paths), body: rule.body, root: projectRoot, file: path.join(projectRulesDir ?? path.join(ctx.cwd, '.claude', 'rules'), rule.rel), memoryType: 'Project' as const })),
+      ...globalRules.scoped.map((rule) => ({ globs: rule.paths, compiled: compileGlobs(rule.paths), body: rule.body, root: realpathOr(ctx.cwd), file: path.join(globalRulesDir, rule.rel), memoryType: 'User' as const })),
+      ...projectRules.scoped.map((rule) => ({ globs: rule.paths, compiled: compileGlobs(rule.paths), body: rule.body, root: realpathOr(projectRoot), file: path.join(projectRulesDir ?? path.join(ctx.cwd, '.claude', 'rules'), rule.rel), memoryType: 'Project' as const })),
     ]
     pendingScopedRules = attachTargets.length
     // Relative to cwd, which the read tool resolves: an ancestor dir yields a
@@ -274,7 +305,9 @@ export default function claudeRulesExtension(pi: ExtensionAPI) {
     if (event.toolName !== 'read' && event.toolName !== 'edit' && event.toolName !== 'write') return
     const rel = (event.input as { path?: unknown } | undefined)?.path
     if (typeof rel !== 'string' || rel.length === 0) return
-    const abs = path.resolve(ctx.cwd, rel)
+    // Realpath both sides (roots canonicalise at session_start): a tool reporting
+    // the resolved real path in a symlinked checkout must still match.
+    const abs = realpathOr(path.resolve(ctx.cwd, rel))
 
     const bodies: string[] = []
     const remaining: AttachTarget[] = []

package/extensions/commands.ts

@@ -52,7 +52,7 @@ import { capForContext } from './internal/output-guard.js'
 import { matchesPathRules } from './internal/path-rules.js'
 import { type InstalledPlugin, installedPlugins } from './internal/plugins.js'
 import { isProjectApproved } from './internal/project-approval.js'
-import { findNearestDir, repoRoot } from './internal/project-root.js'
+import { ancestorDirs, repoRoot } from './internal/project-root.js'
 import { claudeSettingsChain } from './internal/settings-chain.js'
 import { createTurnOverride } from './internal/turn-override.js'
 
@@ -120,7 +120,10 @@ function isDirectory(target: string): boolean {
  * the approval walk) and is included only for approved projects. */
 export function commandDirs(cwd: string, home: string, trusted: boolean): string[] {
   const candidates = [path.join(claudeConfigDir(home), 'commands')]
-  if (trusted) candidates.push(findNearestDir(cwd, path.join('.claude', 'commands')) ?? path.join(cwd, '.claude', 'commands'))
+  // Claude scans every .claude/commands between cwd and the repository root, the
+  // nearest winning a name clash: collectCommands lets later directories win, so
+  // the project list goes root-first with the nearest last.
+  if (trusted) candidates.push(...ancestorDirs(cwd, path.join('.claude', 'commands')).reverse())
   const dirs: string[] = []
   for (const dir of candidates) {
     if (!dirs.includes(dir) && isDirectory(dir)) dirs.push(dir)

package/extensions/internal/path-rules.ts

@@ -7,8 +7,10 @@
  * root (the settings source), and bare or `./` from the current directory. As
  * allow rules, a single-segment directory pattern anchors at cwd; a bare
  * filename matches at any depth. `*` stays within one segment, `**` crosses
- * directories. Matching is lexical, on resolved paths; bracket expressions are
- * not supported and match literally, which can only over-block, never widen.
+ * directories. Matching is lexical, on resolved paths. Bracket expressions parse
+ * per Claude's documented glob contract: `[abc]` classes with ranges and `!`
+ * negation, an unreadable `[` making the pattern match nothing, and `\[` for a
+ * literal bracket.
  */
 
 import * as path from 'node:path'
@@ -79,26 +81,63 @@ function expandBraces(pattern: string): string[] | null {
   return expanded
 }
 
-/** One glob pattern, braces already expanded, as a regular expression source. */
-function translateGlob(pattern: string): string {
+/** The end index of a bracket expression starting at `start` (`[`), or -1 when it
+ * cannot be read as one, which per Claude makes the whole pattern invalid. A `]`
+ * directly after the opening (or after a leading negation) is a literal member. */
+function bracketEnd(pattern: string, start: number): number {
+  let i = start + 1
+  if (pattern[i] === '!' || pattern[i] === '^') i += 1
+  if (pattern[i] === ']') i += 1
+  for (; i < pattern.length; i += 1) {
+    if (pattern[i] === ']') return i
+  }
+  return -1
+}
+
+/** A bracket expression body as a regex character class, escaping regex-relevant
+ * characters while keeping `-` ranges; a leading `!` (or `^`) negates. */
+function bracketClass(body: string): string {
+  const negated = body.startsWith('!') || body.startsWith('^')
+  const members = (negated ? body.slice(1) : body).replace(/[\\\]^]/g, (ch) => `\\${ch}`)
+  return `[${negated ? '^' : ''}${members}]`
+}
+
+/** A `*` run starting at `i`: a double star followed by a slash spans whole
+ * directories, a bare double star crosses segments, and a single `*` stays within
+ * one. Returns the regex source and the index after the run. */
+function translateStar(pattern: string, i: number): { source: string; next: number } {
+  if (pattern[i + 1] === '*') {
+    const prevSlash = i === 0 || pattern[i - 1] === '/'
+    if (prevSlash && pattern[i + 2] === '/') return { source: '(?:[^/]+/)*', next: i + 3 }
+    return { source: '.*', next: i + 2 }
+  }
+  return { source: '[^/]*', next: i + 1 }
+}
+
+function translateGlob(pattern: string): string | null {
   let out = ''
   let i = 0
   while (i < pattern.length) {
     const ch = pattern[i]
+    // Claude: to match a literal bracket, escape it; the escape consumes both chars.
+    if (ch === '\\' && (pattern[i + 1] === '[' || pattern[i + 1] === ']')) {
+      out += escapeRegExp(pattern[i + 1])
+      i += 2
+      continue
+    }
+    // Claude: `[` starts a bracket expression such as `[abc]`; a `[` that cannot be
+    // read as one makes the pattern invalid, matching nothing.
+    if (ch === '[') {
+      const end = bracketEnd(pattern, i)
+      if (end === -1) return null
+      out += bracketClass(pattern.slice(i + 1, end))
+      i = end + 1
+      continue
+    }
     if (ch === '*') {
-      if (pattern[i + 1] === '*') {
-        const prevSlash = i === 0 || pattern[i - 1] === '/'
-        if (prevSlash && pattern[i + 2] === '/') {
-          out += '(?:[^/]+/)*' // `**/` spans zero or more whole directories
-          i += 3
-          continue
-        }
-        out += '.*'
-        i += 2
-        continue
-      }
-      out += '[^/]*'
-      i += 1
+      const star = translateStar(pattern, i)
+      out += star.source
+      i = star.next
       continue
     }
     if (ch === '?') {
@@ -112,13 +151,20 @@ function translateGlob(pattern: string): string {
   return out
 }
 
+/** A regex source that matches nothing: the compiled form of an invalid pattern. */
+const NEVER_MATCH = '(?!)'
+
 /** One gitignore-style pattern as an anchored regular expression source. Brace
  * groups (`{ts,tsx}`, nested, Cartesian across groups) expand into ORed
- * alternatives; an over-budget expansion falls back to the literal pattern. */
+ * alternatives; an over-budget expansion falls back to the literal pattern. An
+ * invalid pattern (an unreadable bracket expression) matches nothing, as Claude
+ * documents, rather than matching its literal spelling. */
 export function globToRegExpSource(pattern: string): string {
   const alternatives = expandBraces(pattern) ?? [pattern]
-  if (alternatives.length === 1) return translateGlob(alternatives[0])
-  return `(?:${alternatives.map(translateGlob).join('|')})`
+  const sources = alternatives.map(translateGlob)
+  if (sources.includes(null)) return NEVER_MATCH
+  if (sources.length === 1) return sources[0] as string
+  return `(?:${sources.join('|')})`
 }
 
 /** A rule resolved to an absolute glob per its anchor form. */

package/extensions/internal/project-root.ts

@@ -60,6 +60,24 @@ export function findNearestFile(cwd: string, relative: string): string | null {
   return findNearest(cwd, relative, false)
 }
 
+/** Every `relative` directory between cwd and the repository root, nearest first,
+ * matching Claude's "every .claude/<kind> between the working directory and the
+ * repository root" discovery where the entry closest to cwd wins a name clash. */
+export function ancestorDirs(cwd: string, relative: string): string[] {
+  const boundary = repoRoot(cwd) ?? cwd
+  const found: string[] = []
+  let currentDir = cwd
+  while (true) {
+    const candidate = path.join(currentDir, relative)
+    if (statOf(candidate)?.isDirectory()) found.push(candidate)
+    if (currentDir === boundary) break
+    const parentDir = path.dirname(currentDir)
+    if (parentDir === currentDir) break
+    currentDir = parentDir
+  }
+  return found
+}
+
 /** Every `relative` file between the repository root and cwd, ordered root first,
  * matching Claude's root-down ordering for hierarchy-loaded context. */
 export function ancestorFiles(cwd: string, relative: string): string[] {

package/extensions/output-styles.ts

@@ -27,7 +27,7 @@ import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 import { claudeConfigDir } from './internal/config-dir.js'
 import { installedPlugins } from './internal/plugins.js'
 import { isProjectApproved } from './internal/project-approval.js'
-import { findNearestDir, findNearestFile } from './internal/project-root.js'
+import { ancestorDirs, findNearestDir, findNearestFile } from './internal/project-root.js'
 import { claudeSettingsChain } from './internal/settings-chain.js'
 
 export interface OutputStyle {
@@ -85,7 +85,10 @@ function isDirectory(target: string): boolean {
  */
 export function styleDirs(cwd: string, home: string, trusted: boolean): string[] {
   const dirs = [path.join(claudeConfigDir(home), 'output-styles')]
-  if (trusted) dirs.push(findNearestDir(cwd, path.join('.claude', 'output-styles')) ?? path.join(cwd, '.claude', 'output-styles'))
+  // Claude loads every .claude/output-styles between cwd and the repository root,
+  // using the one closest to cwd for a name clash: styleForName is first-match,
+  // so the nearest directory goes first.
+  if (trusted) dirs.push(...ancestorDirs(cwd, path.join('.claude', 'output-styles')))
   return dirs.filter((dir) => isDirectory(dir))
 }
 

package/extensions/skills.ts

@@ -29,7 +29,7 @@ import { parseCommandFile } from './internal/command-file.js'
 import { claudeConfigDir } from './internal/config-dir.js'
 import { installedPlugins } from './internal/plugins.js'
 import { isProjectApprovedSilently } from './internal/project-approval.js'
-import { findNearestDir } from './internal/project-root.js'
+import { ancestorDirs } from './internal/project-root.js'
 
 function isDirectory(target: string): boolean {
   try {
@@ -53,7 +53,10 @@ export function skillDirs(cwd: string, home: string, trusted: boolean): string[]
     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'))
+  // Claude loads skills from every .claude/skills between cwd and the repository
+  // root; the list goes nearest-first so findClaudeSkill's first match is the
+  // closest definition (pi's loader receives the same order).
+  if (trusted) candidates.push(...ancestorDirs(cwd, path.join('.claude', 'skills')))
   const dirs: string[] = []
   for (const dir of candidates) {
     if (!dirs.includes(dir) && isDirectory(dir)) dirs.push(dir)

package/extensions/subagent/agents.ts

@@ -13,7 +13,7 @@ import { getAgentDir, parseFrontmatter, stripFrontmatter } from '@earendil-works
 import { parseToolGrants } from '../internal/command-file.js'
 import { claudeConfigDir } from '../internal/config-dir.js'
 import { installedPlugins } from '../internal/plugins.js'
-import { findNearestDir } from '../internal/project-root.js'
+import { ancestorDirs, findNearestDir } from '../internal/project-root.js'
 
 /**
  * `tools:` may be a comma-separated string (the Claude Code format) or a YAML block
@@ -337,13 +337,16 @@ export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryRe
   const userDir = path.join(getAgentDir(), 'agents')
   const claudeUserDir = path.join(claudeConfigDir(os.homedir()), 'agents')
   const projectPiDir = findNearestDir(cwd, path.join('.pi', 'agents'))
-  const projectClaudeDir = findNearestDir(cwd, path.join('.claude', 'agents'))
+  // Claude scans every .claude/agents between cwd and the repository root, the
+  // definition closest to cwd winning a name clash; root-first load order makes
+  // the nearer directory's entry overwrite in the map below.
+  const projectClaudeDirs = ancestorDirs(cwd, path.join('.claude', 'agents')).reverse()
 
   // 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') : [])]
+  const projectAgents = scope === 'user' ? [] : [...projectClaudeDirs.flatMap((dir) => loadAgentsFromDir(dir, 'project')), ...(projectPiDir ? loadAgentsFromDir(projectPiDir, 'project') : [])]
 
   const agentMap = buildAgentMap(userAgents, projectAgents, scope)
   return { agents: Array.from(agentMap.values()), projectAgentsDir: projectPiDir }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "description": "Claude Code experience for the pi coding agent: reads your .claude config (rules, commands, skills, hooks, output styles, MCP servers, agents) and adds todo, checkpoints, memory, web, and subagents",
   "keywords": [
     "pi",