pi-code 1.0.21 → 1.0.23

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/env-settings.ts

@@ -13,19 +13,21 @@
  * approval-gated on purpose: a checked-out repository's env can redirect providers
  * (ANTHROPIC_BASE_URL and friends), so an untrusted repo must not reach process.env.
  *
- * Precedence is per key, managed > user > project, matching Claude's merge: a scope
- * only supplies keys it names and never wipes another scope's keys. Values must be
- * strings; a number or boolean is coerced via String, anything else is skipped.
+ * Precedence is per key, managed > project (settings.local.json overlaying
+ * settings.json inside the project scope) > user, matching Claude's settings
+ * precedence: a scope only supplies keys it names and never wipes another scope's
+ * keys. Values must be strings; a number or boolean is coerced via String,
+ * anything else is skipped.
  *
- * A variable already present in the real environment that this module did not set is
- * left untouched for the user and project scopes: a shell `export` outranks them. The
- * managed scope is the exception: an org policy env must win over an ambient export, so
- * a managed key overwrites a preexisting shell value. The keys this module sets are
- * recorded so a later refresh can update them without clobbering unrelated env, and a
- * key an earlier apply set that the current merge no longer defines is unset (deleted
- * from process.env), so an approved project's env cannot leak into a later session or
- * project that does not define it. A managed overwrite of a shell var is owned like any
- * other set key; its original shell value cannot be restored, so on unset it is deleted.
+ * A settings value replaces a value inherited from the shell, as Claude documents
+ * ("Claude Code writes each env entry into the process environment, replacing the
+ * value inherited from the shell"), and an empty string is the documented way to
+ * override an export that cannot be unset. The original value of each key is
+ * recorded so a later apply that no longer defines the key restores the shell's
+ * value (or deletes a key the shell never had), so an approved project's env
+ * cannot leak into a later session or project that does not define it. The keys a
+ * repository must not control are dropped from the project scope before any of
+ * this (see sanitizeProjectEnv).
  *
  * Docs: https://code.claude.com/docs/en/settings.md
  */
@@ -57,35 +59,31 @@ export function envFromSettings(settings: unknown): Record<string, string> {
   return out
 }
 
-/** Merge the three env scopes with Claude's per-key precedence managed > user >
- * project: lower scopes are laid down first and higher ones overlay, so each key
- * takes its highest-precedence value and no scope wipes another's keys. */
+/** Merge the three env scopes with Claude's per-key settings precedence managed >
+ * project > user: lower scopes are laid down first and higher ones overlay, so each
+ * key takes its highest-precedence value and no scope wipes another's keys. */
 export function mergeEnvScopes(managed: Record<string, string>, user: Record<string, string>, project: Record<string, string>): Record<string, string> {
-  return { ...project, ...user, ...managed }
+  return { ...user, ...project, ...managed }
 }
 
-/** Assign the merged env into `env`, recording each key set into `owned`. A key already
- * present that this module did not set (a shell export) is left untouched for user and
- * project keys; a `managedKeys` entry overwrites it (an org policy outranks the shell).
- * A key this module set before is updated. A previously-owned key that the current
- * `merged` no longer defines is unset (deleted from `env` and `owned`), so an approved
- * project's env cannot leak into a later apply that does not define it. */
-export function applyEnvSettings(merged: Record<string, string>, env: NodeJS.ProcessEnv, owned: Set<string>, managedKeys: ReadonlySet<string> = new Set()): void {
-  // Unset any key an earlier apply set that the current merge dropped. Iterate a copy
-  // since `owned` is mutated. A shell export this module never owned is left in place.
-  for (const key of Array.from(owned)) {
-    if (!(key in merged)) {
-      delete env[key]
-      owned.delete(key)
-    }
+/** Assign the merged env into `env`. Every settings value applies, replacing a
+ * shell-inherited value, as Claude documents; an empty string is the documented
+ * override for an export that cannot be unset. `owned` records each key's original
+ * value at first ownership, so a later apply that drops the key restores the
+ * shell's value (or deletes a key the shell never had) rather than leaking a stale
+ * setting into the rest of the process. */
+export function applyEnvSettings(merged: Record<string, string>, env: NodeJS.ProcessEnv, owned: Map<string, string | undefined>): void {
+  // Restore any key an earlier apply set that the current merge dropped. Iterate a
+  // copy since `owned` is mutated.
+  for (const [key, original] of Array.from(owned.entries())) {
+    if (key in merged) continue
+    if (original === undefined) delete env[key]
+    else env[key] = original
+    owned.delete(key)
   }
   for (const [key, value] of Object.entries(merged)) {
-    // A shell export outranks user/project (skip), but a managed key outranks even the
-    // shell. Once owned, updates always apply. A managed overwrite is owned like any
-    // set key: its shell value is gone and cannot be restored, so on unset it is deleted.
-    if (key in env && !owned.has(key) && !managedKeys.has(key)) continue
+    if (!owned.has(key)) owned.set(key, env[key])
     env[key] = value
-    owned.add(key)
   }
 }
 
@@ -148,11 +146,10 @@ function projectEnv(cwd: string): Record<string, string> {
 }
 
 export default function envSettingsExtension(pi: ExtensionAPI) {
-  const owned = new Set<string>()
+  const owned = new Map<string, string | undefined>()
 
   const apply = (home: string, project: Record<string, string>): void => {
-    const managed = envFromSettings(readManagedSettings())
-    applyEnvSettings(mergeEnvScopes(managed, userEnv(home), project), process.env, owned, new Set(Object.keys(managed)))
+    applyEnvSettings(mergeEnvScopes(envFromSettings(readManagedSettings()), userEnv(home), project), process.env, owned)
   }
 
   // Factory time: managed + user only. Approval needs the session ctx, so the project

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.21",
+  "version": "1.0.23",
   "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",