pi-code 1.0.60 → 1.0.61

package/extensions/claude-rules.ts

@@ -111,14 +111,15 @@ export function parseFrontmatter(content: string): Frontmatter {
 }
 
 /**
- * Whether a file path matches at least one of a rule's `paths:` globs. `*` stays in
- * a segment, `**` crosses directories, a slashless pattern (`*.ts`) matches the
- * basename at any depth (gitignore-style), and a trailing slash (`docs/`) scopes to
- * that directory's contents. `./` and a leading `/` are stripped so a project-root
- * anchored glob resolves the same as a bare one. A bare directory name without a
- * trailing slash or `**` matches a file of that name, not the directory's contents;
- * write `dir/**` to scope to a directory. `relPath` is the touched file relative to
- * the rule set's root.
+ * Whether a file path matches at least one of a rule's `paths:` globs. `*` stays in a
+ * segment and `**` crosses directories. A slashless pattern (`*.ts`, `README.md`) is
+ * the project root, per Claude's table; a leading globstar segment is how a rule says
+ * any depth. A trailing slash (`docs/`) scopes to that directory's contents. `./` and
+ * a leading `/` are stripped so a project-root anchored glob resolves the same as a
+ * bare one. A bare directory name without a trailing slash or a globstar matches a
+ * file of that name, not the directory's contents; write `dir` followed by a globstar
+ * to scope to a directory. `relPath` is the touched file relative to the rule set's
+ * root.
  */
 export function pathMatchesGlobs(relPath: string, globs: string[]): boolean {
   return matchesCompiledGlobs(relPath, compileGlobs(globs))

package/extensions/internal/path-rules.ts

@@ -188,7 +188,6 @@ function resolveRule(rule: string, anchors: PathAnchors): string {
  * root-relative path. */
 export interface CompiledGlob {
   regex: RegExp
-  matchesBasename: boolean
 }
 
 let globsCompiled = 0
@@ -219,7 +218,7 @@ export function compileGlobs(globs: string[]): CompiledGlob[] {
     // would compile to `^docs/$` and match nothing.
     if (glob.endsWith('/')) glob += '**'
     globsCompiled += 1
-    compiled.push({ regex: new RegExp(`^${globToRegExpSource(glob)}$`), matchesBasename: !glob.includes('/') })
+    compiled.push({ regex: new RegExp(`^${globToRegExpSource(glob)}$`) })
   }
   return compiled
 }
@@ -229,8 +228,7 @@ export function compileGlobs(globs: string[]): CompiledGlob[] {
 export function matchesCompiledGlobs(relPath: string, globs: CompiledGlob[]): boolean {
   globsEvaluated += 1
   const posix = relPath.split(path.sep).join('/')
-  const base = posix.split('/').pop() ?? posix
-  return globs.some((glob) => glob.regex.test(glob.matchesBasename ? base : posix))
+  return globs.some((glob) => glob.regex.test(posix))
 }
 
 /** Whether the accessed file matches at least one rule. No rules means no match:

package/extensions/internal/project-approval.ts

@@ -18,6 +18,7 @@
  */
 
 import * as fs from 'node:fs'
+import * as os from 'node:os'
 import * as path from 'node:path'
 import { getAgentDir, hasTrustRequiringProjectResources, ProjectTrustStore } from '@earendil-works/pi-coding-agent'
 
@@ -46,11 +47,15 @@ const CLAUDE_SHAPED = [
  * The walk matters: agent discovery already searches upward, so starting pi in a
  * subdirectory of a repository whose `.claude/agents` sits at the root found those
  * agents while a cwd-only check reported nothing to gate, and the short-circuit
- * approved the project without ever asking. The bound is the repository root, so a
- * directory outside any repository never inherits a parent's config. */
-export function hasClaudeShapedConfig(cwd: string): boolean {
+ * approved the project without ever asking. The bound is the repository root and the home
+ * directory, because `~/.claude` is the user's own configuration: a directory under
+ * home that is in no repository would otherwise walk up into it and report the user's
+ * own settings as a project waiting to be approved. */
+export function hasClaudeShapedConfig(cwd: string, home: string = os.homedir()): boolean {
   let currentDir = cwd
   while (true) {
+    // The home check comes first: at home itself the .claude found is the user's own.
+    if (currentDir === home) return false
     if (CLAUDE_SHAPED.some((entry) => fs.existsSync(path.join(currentDir, entry)))) return true
     if (ROOT_MARKERS.some((marker) => fs.existsSync(path.join(currentDir, marker)))) return false
     const parentDir = path.dirname(currentDir)

package/extensions/internal/project-root.ts

@@ -13,18 +13,21 @@
 import * as fs from 'node:fs'
 import * as path from 'node:path'
 
-/** Project root markers ending the walk. `.git` is a file in worktrees and submodules. */
-export const ROOT_MARKERS = ['.git', 'package.json']
+/** The project root marker. `.git` is a file in worktrees and submodules, a directory
+ * in an ordinary clone.
+ *
+ * `package.json` used to count too, which made every package of a monorepo its own
+ * project: its own memory directory, its own settings.local.json, its own
+ * CLAUDE_PROJECT_DIR, its own trust decision. Claude's project is the repository, and
+ * a repository can add a package.json wherever it likes, so a marker it controls was
+ * also a marker it could move. */
+export const ROOT_MARKERS = ['.git']
 
-/** Project root at or above `from`, or undefined when no marker is found. */
+/** Project root at or above `from`, or undefined outside a repository. */
 export 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
-  }
+  const root = gitRoot(from)
+  if (root === undefined) return undefined
+  return mainCheckout(root)
 }
 
 /** The git checkout at or above `from`, or undefined outside one.
@@ -45,6 +48,38 @@ export function gitRoot(from: string): string | undefined {
   }
 }
 
+/** The main checkout for a git directory.
+ *
+ * A worktree carries a `.git` FILE holding `gitdir: <main>/.git/worktrees/<name>`, so
+ * resolving it gives the checkout the repository's state actually belongs to. Claude
+ * reads settings.local.json from "the file at the main checkout's root" and shares one
+ * auto memory directory across "all worktrees and subdirectories within the same repo",
+ * so a worktree is not its own project. An unreadable or unexpected `.git` file leaves
+ * the directory as its own root, which is the safe direction. */
+function mainCheckout(root: string): string {
+  const dotGit = path.join(root, '.git')
+  let pointer: string
+  try {
+    if (!fs.statSync(dotGit).isFile()) return root
+    pointer = fs.readFileSync(dotGit, 'utf-8')
+  } catch {
+    return root
+  }
+  // Parsed rather than matched: the file is one `gitdir: <path>` line, and a regex
+  // over an arbitrary-length path is a backtracking cost for nothing.
+  const [firstLine = ''] = pointer.split('\n')
+  const prefix = 'gitdir:'
+  if (!firstLine.startsWith(prefix)) return root
+  const target = firstLine.slice(prefix.length).trim()
+  if (!target) return root
+  // <main>/.git/worktrees/<name> -> <main>
+  const worktreeDir = path.resolve(root, target)
+  const marker = `${path.sep}.git${path.sep}worktrees${path.sep}`
+  const cut = worktreeDir.lastIndexOf(marker)
+  if (cut === -1) return root
+  return worktreeDir.slice(0, cut)
+}
+
 function statOf(target: string): fs.Stats | null {
   try {
     return fs.statSync(target)

package/extensions/internal/settings-chain.ts

@@ -13,19 +13,46 @@ import { claudeConfigDir } from './config-dir.js'
 import { repoRoot } from './project-root.js'
 import { isRecord } from './values.js'
 
+/** Whether every path given exists and belongs to the user running this process.
+ * A path that is absent is not someone else's, so it does not disqualify the root. */
+function ownedByUser(paths: string[]): boolean {
+  const uid = process.getuid?.()
+  if (uid === undefined) return true
+  return paths.every((target) => {
+    try {
+      return fs.statSync(target).uid === uid
+    } catch {
+      return true
+    }
+  })
+}
+
+/** Where `settings.local.json` lives, per Claude's four exceptions: it sits at the
+ * repository root, except outside a repository, when that root is the home directory,
+ * on Windows, or when the root or its `.git` or `.claude` entry belongs to someone
+ * else. In each of those it stays beside `.claude/settings.json` in the working
+ * directory instead. In a worktree the root is the main checkout, which repoRoot
+ * resolves. */
+function localSettingsDir(cwd: string, home: string, platform: NodeJS.Platform, owned: (paths: string[]) => boolean): string {
+  const root = repoRoot(cwd)
+  if (root === undefined || root === home) return cwd
+  if (platform === 'win32') return cwd
+  if (!owned([root, path.join(root, '.git'), path.join(root, '.claude')])) return cwd
+  return root
+}
+
 /** The user settings.json, then (only when `includeProject`) the project files by
  * Claude's placement rules: the shared `.claude/settings.json` is read from the
  * session's primary working directory (never an ancestor; "to use a file committed
  * at the repository root, start Claude Code there"), while `settings.local.json`
- * lives at the repository root, falling back to the primary directory outside a
- * repository or when the root is the home directory. A legacy local file at the
- * primary directory is still read, with the root's values winning. Later files win. */
-export function claudeSettingsChain(cwd: string, home: string, includeProject: boolean): string[] {
+ * lives at the repository root, subject to the exceptions in localSettingsDir. A
+ * legacy local file at the primary directory is still read, with the root's values
+ * winning. Later files win. */
+export function claudeSettingsChain(cwd: string, home: string, includeProject: boolean, platform: NodeJS.Platform = process.platform, owned: (paths: string[]) => boolean = ownedByUser): string[] {
   const files = [path.join(claudeConfigDir(home), 'settings.json')]
   if (!includeProject) return files
   files.push(path.join(cwd, '.claude', 'settings.json'))
-  const root = repoRoot(cwd)
-  const localDir = root !== undefined && root !== home ? root : cwd
+  const localDir = localSettingsDir(cwd, home, platform, owned)
   if (localDir !== cwd) files.push(path.join(cwd, '.claude', 'settings.local.json'))
   files.push(path.join(localDir, '.claude', 'settings.local.json'))
   return files

package/extensions/status-line.ts

@@ -36,7 +36,7 @@ import { claudeEffortLevel } from './internal/effort.js'
 import { readManagedSettings } from './internal/managed-settings.js'
 import { isPlanModeState, PLAN_MODE_CHANNEL } from './internal/plan-mode-state.js'
 import { isProjectApprovedSilently } from './internal/project-approval.js'
-import { repoRoot } from './internal/project-root.js'
+import { gitRoot, repoRoot } from './internal/project-root.js'
 import { readSettingsChain } from './internal/settings-chain.js'
 import { watchSettingsFiles } from './internal/settings-watch.js'
 import { readActiveStyleName, settingsFiles } from './output-styles.js'
@@ -47,7 +47,9 @@ const DEBOUNCE_MS = 300
 /** Whether cwd sits in a git worktree: `.git` is a file pointing at the main
  * checkout there, and a directory in an ordinary clone. */
 function isGitWorktree(cwd: string): boolean {
-  const root = repoRoot(cwd)
+  // gitRoot, not repoRoot: repoRoot resolves a worktree to its main checkout, which is
+  // exactly the thing this needs to see before it is resolved away.
+  const root = gitRoot(cwd)
   if (root === undefined) return false
   try {
     return fs.statSync(path.join(root, '.git')).isFile()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.0.60",
+  "version": "1.0.61",
   "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, subagents, and goals",
   "keywords": [
     "pi",