pi-code 1.0.59 → 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,6 +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 { 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'
@@ -43,6 +44,20 @@ import { readActiveStyleName, settingsFiles } from './output-styles.js'
 const COMMAND_TIMEOUT_MS = 5_000
 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 {
+  // 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()
+  } catch {
+    return false
+  }
+}
+
 /** Claude sends its CLI version; pi-code's own version is the honest analogue. */
 const PACKAGE_VERSION = (() => {
   try {
@@ -235,6 +250,16 @@ export default function statusLine(pi: ExtensionAPI) {
     ctx.ui.setStatus('pi-code-status', commandLine ?? builtIn)
   }
 
+  /** The --add-dir directories, the flag pi-code registers for Claude's additional
+   * working directories. Empty when none were given, which is the documented shape. */
+  function addedDirs(): string[] {
+    const raw = String(pi.getFlag?.('add-dir') ?? '')
+    return raw
+      .split(',')
+      .map((dir) => dir.trim())
+      .filter(Boolean)
+  }
+
   /** 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 }
@@ -249,9 +274,16 @@ export default function statusLine(pi: ExtensionAPI) {
       session_id: ctx.sessionManager.getSessionId(),
       cwd: ctx.cwd,
       version: PACKAGE_VERSION,
-      // added_dirs is always empty: pi has no /add-dir; the field stays present
-      // because Claude documents "Empty array if none have been added".
-      workspace: { current_dir: ctx.cwd, project_dir: ctx.cwd, added_dirs: [] },
+      // project_dir is the repository, not the directory the session started in: a
+      // script labelling the project showed whichever subdirectory it was launched
+      // from. git_worktree reports the .git file a worktree carries in place of a
+      // directory. added_dirs comes from the --add-dir flag pi-code registers.
+      workspace: {
+        current_dir: ctx.cwd,
+        project_dir: repoRoot(ctx.cwd) ?? ctx.cwd,
+        git_worktree: isGitWorktree(ctx.cwd),
+        added_dirs: addedDirs(),
+      },
       // 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 ?? '' },
@@ -269,17 +301,17 @@ export default function statusLine(pi: ExtensionAPI) {
         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
+        // Present before the first response too, as Claude sends them: a script
+        // reading current_usage gets null rather than undefined.
+        total_output_tokens: lastUsage?.output ?? 0,
+        current_usage: 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,
-              },
+              input_tokens: lastUsage.input,
+              output_tokens: lastUsage.output,
+              cache_read_input_tokens: lastUsage.cacheRead,
+              cache_creation_input_tokens: lastUsage.cacheWrite,
             }
-          : {}),
+          : null,
       },
       // 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,
@@ -323,9 +355,17 @@ export default function statusLine(pi: ExtensionAPI) {
       const result = await runHookCommand(config.command, buildPayload(ctx), COMMAND_TIMEOUT_MS, undefined, undefined, (kill) => {
         killInflight = kill
       })
-      const first = result.stdout.split('\n')[0].trimEnd()
+      // Claude: "Your script can output multiple lines to create a richer display."
+      // pi has one row for every extension status and replaces newlines with spaces
+      // before rendering it (footer.js sanitizeStatusText), so the rows are joined
+      // here rather than dropped; taking only the first silently lost the rest.
+      const rows = result.stdout
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .join(' ')
       const pad = ' '.repeat(config.padding)
-      commandLine = first ? `${pad}${first}${pad}` : undefined
+      commandLine = rows ? `${pad}${rows}${pad}` : undefined
       show(ctx, segmentText(ctx, ctx.ui.theme.fg('dim', '○')))
     } catch {
       // A replaced or reloaded session invalidates ctx while the command is in
@@ -463,9 +503,13 @@ export default function statusLine(pi: ExtensionAPI) {
     // command change re-resolves and re-runs.
     disposeSettingsWatch()
     disposeSettingsWatch = watchSettingsFiles(files, () => {
+      const previousCommand = config?.command
       config = readDisableAllHooks(files) ? undefined : readStatusLineConfig(files)
       armRefresh()
-      scheduleRefresh()
+      // The debounce batches rapid triggers, but a command the user just edited has
+      // nothing to batch with: run it now so the result of the edit is immediate.
+      if (config?.command !== previousCommand) void runCommand(ctx)
+      else scheduleRefresh()
     })
     show(ctx, segmentText(ctx, ctx.ui.theme.fg('dim', '○')))
     scheduleRefresh()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.0.59",
+  "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",