pi-code 1.0.35 → 1.0.36

package/extensions/hooks/index.ts

@@ -101,6 +101,7 @@ import { isPlanModeState, PLAN_MODE_CHANNEL } from '../internal/plan-mode-state.
 import { installedPlugins } from '../internal/plugins.js'
 import { isProjectApproved } from '../internal/project-approval.js'
 import { repoRoot } from '../internal/project-root.js'
+import { watchSettingsFiles } from '../internal/settings-watch.js'
 import { isSkillHooksEvent, SKILL_HOOKS_CHANNEL } from '../internal/skill-hooks.js'
 import { isSubagentPhaseEvent, SUBAGENT_CHANNEL } from '../internal/subagent-events.js'
 import { setSubagentStartHookRunner } from '../internal/subagent-hooks.js'
@@ -207,6 +208,12 @@ export default function hooksExtension(pi: ExtensionAPI) {
   /** Set inside a subagent child that carries agent-frontmatter hooks: the child's
    * own agent end fires their SubagentStop, per Claude's Stop conversion. */
   let agentIdentity: { agent: string; id?: string } | undefined
+  /** Claude's allowManagedHooksOnly: only the managed hook set runs. */
+  let managedHooksOnly = false
+  /** Skill hooks registered this session, re-applied when a settings edit reloads. */
+  const registeredSkillHooks: Array<{ skillName: string; hooks: Record<string, unknown> }> = []
+  /** Stops the settings watcher of the previous session. */
+  let disposeSettingsWatch: () => void = () => {}
   /** Claude's disableAllHooks escape hatch was set somewhere in the honored chain. */
   let hooksDisabled = false
   /** Which settings file each resolved entry came from, for the /hooks viewer. */
@@ -300,7 +307,10 @@ export default function hooksExtension(pi: ExtensionAPI) {
   // Claude documents; a session restart reloads config and drops them.
   pi.events.on(SKILL_HOOKS_CHANNEL, (data) => {
     if (!isSkillHooksEvent(data)) return
-    if (hooksDisabled) return
+    // Blocked under the escape hatch and under allowManagedHooksOnly, which
+    // covers every non-managed hook source.
+    if (hooksDisabled || managedHooksOnly) return
+    registeredSkillHooks.push({ skillName: data.skillName, hooks: data.hooks })
     mergeSkillHooks(config, data.skillName, data.hooks, hookSources)
   })
 
@@ -376,20 +386,11 @@ export default function hooksExtension(pi: ExtensionAPI) {
     return results.map((result) => promptContext(result.stdout)).filter(Boolean)
   })
 
-  pi.on('session_start', async (event, ctx) => {
-    sessionCtx = ctx
-    // One extension instance serves every session. A mid-turn /new fires session_start on
-    // the same instance while a Stop-hook continuation streak is in flight; it must not
-    // carry into the next session, so reset before any early return (disableAllHooks below).
-    stopHookActive = false
-    stopHookBlockCount = 0
-    pendingToolContext.clear()
-    const trusted = await isProjectApproved(ctx)
-    // Claude's CLAUDE_PROJECT_DIR is the project root, not the session cwd; a hook
-    // referencing $CLAUDE_PROJECT_DIR/.claude/hooks/helper.sh must resolve from a
-    // subdirectory session too.
-    projectDir = repoRoot(ctx.cwd) ?? ctx.cwd
-    const files = hookFiles(ctx.cwd, os.homedir(), trusted)
+  /** Resolve the whole hook configuration from disk. Runs at session start and
+   * again when the settings watcher sees an edit, so mid-session changes to
+   * hooks, disableAllHooks, or allowedHttpHookUrls apply without a restart. */
+  function resolveConfig(cwd: string, trusted: boolean): void {
+    const files = hookFiles(cwd, os.homedir(), trusted)
     hookSources.clear()
     allowedHttpHookUrls = readAllowedHttpHookUrls(files)
     // The disableAllHooks escape hatch, checked before any config loads. The tiers
@@ -400,15 +401,14 @@ export default function hooksExtension(pi: ExtensionAPI) {
     hooksDisabled = readDisableAllHooks(files, managedSettings)
     if (managedSettings.disableAllHooks === true) {
       config = {}
-      pendingSessionContext = []
       return
     }
     config = loadManagedHooks(hookSources, managedSettings)
-    if (readSettingsDisableAllHooks(files)) {
-      pendingSessionContext = []
-      return
-    }
-    for (const [event, matchers] of Object.entries(loadHooks(files, hookSources))) config[event] = [...(config[event] ?? []), ...matchers]
+    // Claude's allowManagedHooksOnly: user, project, local, plugin, and skill
+    // hooks are blocked; only the managed set runs.
+    managedHooksOnly = managedSettings.allowManagedHooksOnly === true
+    if (managedHooksOnly || readSettingsDisableAllHooks(files)) return
+    for (const [eventName, matchers] of Object.entries(loadHooks(files, hookSources))) config[eventName] = [...(config[eventName] ?? []), ...matchers]
     // Plugins are user-installed and enabled by user settings (see installedPlugins),
     // so a checked-out repo cannot toggle which code-bearing plugin hooks run.
     loadPluginHooks(config, installedPlugins(os.homedir()), hookSources)
@@ -416,6 +416,31 @@ export default function hooksExtension(pi: ExtensionAPI) {
     // env (Stop already converted to SubagentStop, per Claude); they run only for
     // this child process.
     agentIdentity = mergeAgentEnvHooks(config, hookSources)
+    // A reload must not drop the skill hooks the session already registered.
+    for (const skill of registeredSkillHooks) mergeSkillHooks(config, skill.skillName, skill.hooks, hookSources)
+  }
+
+  pi.on('session_start', async (event, ctx) => {
+    sessionCtx = ctx
+    // One extension instance serves every session. A mid-turn /new fires session_start on
+    // the same instance while a Stop-hook continuation streak is in flight; it must not
+    // carry into the next session, so reset before any early return (disableAllHooks below).
+    stopHookActive = false
+    stopHookBlockCount = 0
+    pendingToolContext.clear()
+    registeredSkillHooks.length = 0
+    const trusted = await isProjectApproved(ctx)
+    // Claude's CLAUDE_PROJECT_DIR is the project root, not the session cwd; a hook
+    // referencing $CLAUDE_PROJECT_DIR/.claude/hooks/helper.sh must resolve from a
+    // subdirectory session too.
+    projectDir = repoRoot(ctx.cwd) ?? ctx.cwd
+    resolveConfig(ctx.cwd, trusted)
+    // Claude picks up direct settings edits mid-session via a file watcher.
+    disposeSettingsWatch()
+    disposeSettingsWatch = watchSettingsFiles(hookFiles(ctx.cwd, os.homedir(), trusted), () => resolveConfig(ctx.cwd, trusted))
+    // A disabled or managed-only resolution leaves config empty (or managed-only),
+    // so the SessionStart run below fires exactly what remains active.
+    pendingSessionContext = []
     // "reload" re-fires in-process with the same conversation and would double-run hooks;
     // a fork is a genuine session begin, which Claude reports as source "fork".
     if (event.reason === 'reload') return

package/extensions/internal/settings-chain.ts

@@ -9,16 +9,22 @@
 
 import * as path from 'node:path'
 import { claudeConfigDir } from './config-dir.js'
-import { findNearestFile } from './project-root.js'
+import { repoRoot } from './project-root.js'
 
-/** The user settings.json, then (only when `includeProject`) the nearest project
- * settings.json and settings.local.json at or above cwd, with cwd's own `.claude/` as
- * the fallback for each. Later files win. */
+/** 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[] {
   const files = [path.join(claudeConfigDir(home), 'settings.json')]
   if (!includeProject) return files
-  for (const name of ['settings.json', 'settings.local.json']) {
-    files.push(findNearestFile(cwd, path.join('.claude', name)) ?? path.join(cwd, '.claude', name))
-  }
+  files.push(path.join(cwd, '.claude', 'settings.json'))
+  const root = repoRoot(cwd)
+  const localDir = root !== undefined && root !== home ? root : cwd
+  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/internal/settings-watch.ts

@@ -0,0 +1,26 @@
+/**
+ * Mid-session settings watching, Claude's "picked up automatically by the file
+ * watcher". Polling stat watchers rather than fs.watch: editors replace files via
+ * rename, which event watchers miss on some platforms, and a missing file that
+ * appears later must start reporting too, which stat polling handles uniformly.
+ */
+
+import * as fs from 'node:fs'
+
+/** Watch the given settings files, calling `reload` when any of them changes.
+ * Returns a dispose function. The poll interval is env-tunable for tests. */
+export function watchSettingsFiles(files: string[], reload: () => void): () => void {
+  const interval = Number(process.env.PI_CODE_SETTINGS_WATCH_INTERVAL_MS) || 2000
+  const listeners: Array<[string, (curr: fs.Stats, prev: fs.Stats) => void]> = []
+  for (const file of files) {
+    const listener = (curr: fs.Stats, prev: fs.Stats): void => {
+      if (curr.mtimeMs !== prev.mtimeMs || curr.size !== prev.size) reload()
+    }
+    // persistent: false, so a watcher alone never keeps a one-shot run alive.
+    fs.watchFile(file, { interval, persistent: false }, listener)
+    listeners.push([file, listener])
+  }
+  return () => {
+    for (const [file, listener] of listeners) fs.unwatchFile(file, listener)
+  }
+}

package/extensions/status-line.ts

@@ -5,10 +5,14 @@
  * with the session JSON on stdin (model, workspace, cost, context_window, effort,
  * output_style, session ids) and its first stdout line becomes the footer segment,
  * padded per `padding`. It re-runs, debounced 300ms as Claude does, at session
- * start, after turns, after compaction, on plan-mode changes (the permission-mode
- * analogue, off the shared bus), and on the optional `refreshInterval` timer
- * (minimum 1s). A project-defined command is arbitrary shell, so project settings
- * count only once the project is already approved, read without prompting.
+ * start, after turns and each assistant message, after compaction, on plan-mode
+ * changes (the permission-mode analogue, off the shared bus), when a rate-limit
+ * window in the last payload reaches its resets_at time, when the statusLine
+ * settings change mid-session (file watcher), and on the optional
+ * `refreshInterval` timer (minimum 1s). A new trigger while the script is still
+ * running cancels the in-flight run, as Claude does. A project-defined command is
+ * arbitrary shell, so project settings count only once the project is already
+ * approved, read without prompting.
  * Claude's `disableAllHooks` setting turns the configured command off too, and
  * the built-in segment stands in.
  *
@@ -29,8 +33,10 @@ import * as path from 'node:path'
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
 
 import { hookFiles, readDisableAllHooks, runHookCommand } from './hooks/index.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 { watchSettingsFiles } from './internal/settings-watch.js'
 import { readActiveStyleName, settingsFiles } from './output-styles.js'
 
 const COMMAND_TIMEOUT_MS = 5_000
@@ -149,22 +155,33 @@ export interface StatusLineConfig {
   refreshInterval: number | undefined
 }
 
-/** The `statusLine` recorded in settings, last file winning. Claude's shape is
- * `{type: "command", command, padding?, refreshInterval?}`; entries without a
- * command string are ignored, and refreshInterval has a documented minimum of 1. */
-export function readStatusLineConfig(files: string[]): StatusLineConfig | undefined {
+/** One settings `statusLine` entry parsed into a config, or undefined when it is
+ * not Claude's `{type: "command", command, padding?, refreshInterval?}` shape;
+ * refreshInterval has a documented minimum of 1. */
+function parseStatusLineEntry(entry: unknown): StatusLineConfig | undefined {
+  if (entry === null || typeof entry !== 'object') return undefined
+  const record = entry as { type?: unknown; command?: unknown; padding?: unknown; refreshInterval?: unknown }
+  if (typeof record.command !== 'string') return undefined
+  if (record.type !== undefined && record.type !== 'command') return undefined
+  return {
+    command: record.command,
+    padding: typeof record.padding === 'number' && record.padding > 0 ? record.padding : 0,
+    refreshInterval: typeof record.refreshInterval === 'number' && record.refreshInterval >= 1 ? record.refreshInterval : undefined,
+  }
+}
+
+/** The `statusLine` recorded in settings, last file winning; a managed policy
+ * entry wins over every file, and allowManagedHooksOnly narrows the setting to
+ * managed settings entirely, as Claude documents. */
+export function readStatusLineConfig(files: string[], managed: Record<string, unknown> = readManagedSettings()): StatusLineConfig | undefined {
+  const managedConfig = parseStatusLineEntry(managed.statusLine)
+  if (managedConfig) return managedConfig
+  if (managed.allowManagedHooksOnly === true) return undefined
   let found: StatusLineConfig | undefined
   for (const file of files) {
     try {
       const settings = JSON.parse(fs.readFileSync(file, 'utf-8'))
-      const entry = settings.statusLine
-      if (!entry || typeof entry.command !== 'string') continue
-      if (entry.type !== undefined && entry.type !== 'command') continue
-      found = {
-        command: entry.command,
-        padding: typeof entry.padding === 'number' && entry.padding > 0 ? entry.padding : 0,
-        refreshInterval: typeof entry.refreshInterval === 'number' && entry.refreshInterval >= 1 ? entry.refreshInterval : undefined,
-      }
+      found = parseStatusLineEntry(settings.statusLine) ?? found
     } catch {
       // missing or invalid file: skip
     }
@@ -205,6 +222,11 @@ export default function statusLine(pi: ExtensionAPI) {
   let rateLimitWarned = false
   let refreshTimer: ReturnType<typeof setInterval> | undefined
   let debounceTimer: ReturnType<typeof setTimeout> | undefined
+  let expiryTimer: ReturnType<typeof setTimeout> | undefined
+  /** Kills the script currently in flight; Claude cancels it on a new trigger. */
+  let killInflight: (() => void) | undefined
+  /** Stops the settings watcher of the previous session. */
+  let disposeSettingsWatch: () => void = () => {}
   let running = false
   let rerunQueued = false
 
@@ -293,6 +315,9 @@ export default function statusLine(pi: ExtensionAPI) {
   async function runCommand(ctx: ExtensionContext): Promise<void> {
     if (!config) return
     if (running) {
+      // Claude cancels the in-flight script when a new update triggers; the
+      // rerun below then runs the fresh one.
+      killInflight?.()
       rerunQueued = true
       return
     }
@@ -301,7 +326,9 @@ export default function statusLine(pi: ExtensionAPI) {
       // Everything below can touch ctx after an await, and every ctx getter throws
       // once the session is disposed. This promise is started from a timer with no
       // awaiter, so an escaping rejection becomes an uncaughtException and exits pi.
-      const result = await runHookCommand(config.command, buildPayload(ctx), COMMAND_TIMEOUT_MS)
+      const result = await runHookCommand(config.command, buildPayload(ctx), COMMAND_TIMEOUT_MS, undefined, undefined, (kill) => {
+        killInflight = kill
+      })
       const first = result.stdout.split('\n')[0].trimEnd()
       const pad = ' '.repeat(config.padding)
       commandLine = first ? `${pad}${first}${pad}` : undefined
@@ -310,6 +337,7 @@ export default function statusLine(pi: ExtensionAPI) {
       // A replaced or reloaded session invalidates ctx while the command is in
       // flight; there is nothing left to update, and the next session starts fresh.
     } finally {
+      killInflight = undefined
       running = false
       if (rerunQueued) {
         rerunQueued = false
@@ -318,6 +346,18 @@ export default function statusLine(pi: ExtensionAPI) {
     }
   }
 
+  /** Claude re-runs the script when a rate-limit window in the last data reaches
+   * its resets_at time, so an expired segment clears without another event. */
+  function scheduleExpiryRefresh(snapshot: RateLimitSnapshot): void {
+    clearTimeout(expiryTimer)
+    const resets = [snapshot.five_hour?.resets_at, snapshot.seven_day?.resets_at].filter((value): value is number => typeof value === 'number')
+    if (resets.length === 0) return
+    const delayMs = Math.min(...resets) * 1000 - Date.now()
+    if (delayMs <= 0) return
+    expiryTimer = setTimeout(() => scheduleRefresh(), delayMs)
+    expiryTimer.unref?.()
+  }
+
   /** Claude debounces statusline updates at 300ms so rapid triggers batch. */
   function scheduleRefresh(): void {
     if (!config || !sessionCtx) return
@@ -361,7 +401,10 @@ export default function statusLine(pi: ExtensionAPI) {
     // names and presence vary, so parse only what is there and never throw.
     const headers = normalizeHeaders(event.headers)
     const snapshot = parseRateLimits(headers)
-    if (snapshot) rateLimits = snapshot
+    if (snapshot) {
+      rateLimits = snapshot
+      scheduleExpiryRefresh(snapshot)
+    }
     if (event.status === 429 && !rateLimitWarned) {
       rateLimitWarned = true
       const retryAfter = headers['retry-after']
@@ -380,6 +423,8 @@ export default function statusLine(pi: ExtensionAPI) {
     if (!usage) return
     lastUsage = usage
     costTotal += usage.cost?.total ?? 0
+    // Claude re-runs the status line after each assistant message.
+    scheduleRefresh()
   })
 
   pi.on('session_start', async (_event, ctx) => {
@@ -415,6 +460,13 @@ export default function statusLine(pi: ExtensionAPI) {
     if (config?.refreshInterval) {
       refreshTimer = setInterval(() => scheduleRefresh(), config.refreshInterval * 1000)
     }
+    // Claude re-runs the script when the statusLine settings change mid-session; a
+    // command change re-resolves and re-runs.
+    disposeSettingsWatch()
+    disposeSettingsWatch = watchSettingsFiles(files, () => {
+      config = readDisableAllHooks(files) ? undefined : readStatusLineConfig(files)
+      scheduleRefresh()
+    })
     show(ctx, segmentText(ctx, ctx.ui.theme.fg('dim', '○')))
     scheduleRefresh()
   })

package/package.json

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