pi-code 1.0.34 → 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/hooks/runners.ts

@@ -99,8 +99,14 @@ export const runHookCommand: HookCommandRunner = (command, payload, timeoutMs, p
     // the descendants too. CLAUDE_PROJECT_DIR is Claude's documented way for a hook to
     // reference project files regardless of the shell's cwd. CLAUDECODE=1 marks every
     // subprocess Claude spawns, so it is set on the child unconditionally.
-    const env: NodeJS.ProcessEnv = { ...process.env, CLAUDECODE: '1' }
+    // CLAUDE_CODE_CHILD_SESSION marks per-call children (hook and status line
+    // commands), never long-lived stdio MCP servers, as Claude documents; COLUMNS
+    // and LINES carry the terminal dimensions since the script's own width
+    // detection cannot see the captured terminal.
+    const env: NodeJS.ProcessEnv = { ...process.env, CLAUDECODE: '1', CLAUDE_CODE_CHILD_SESSION: '1' }
     if (projectDir) env.CLAUDE_PROJECT_DIR = projectDir
+    if (process.stdout.columns) env.COLUMNS = String(process.stdout.columns)
+    if (process.stdout.rows) env.LINES = String(process.stdout.rows)
     // An exec-form hook (an `args` array) spawns the executable directly with those args
     // and no shell, so shell metacharacters in the args arrive literally; $ARGUMENTS in
     // each arg is replaced with the event JSON by a replacer function (so $$/$& in the

package/extensions/internal/managed-settings.ts

@@ -10,6 +10,7 @@
  */
 
 import * as fs from 'node:fs'
+import * as path from 'node:path'
 
 /** The OS managed-settings.json path Claude Code documents per platform. */
 export function managedSettingsPath(platform: NodeJS.Platform = process.platform): string {
@@ -31,8 +32,7 @@ export function managedSettingsFile(): string {
   return managedSettingsFileOverride ?? managedSettingsPath()
 }
 
-/** The parsed managed settings object, or {} when absent or malformed. */
-export function readManagedSettings(file: string = managedSettingsFileOverride ?? managedSettingsPath()): Record<string, unknown> {
+function readOneSettingsFile(file: string): Record<string, unknown> {
   try {
     const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'))
     if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed as Record<string, unknown>
@@ -41,3 +41,38 @@ export function readManagedSettings(file: string = managedSettingsFileOverride ?
   }
   return {}
 }
+
+function isRecordValue(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+/** Claude's managed-settings.d merge rules: a later single value replaces, lists
+ * combine with duplicates removed, and nested blocks merge key by key with each
+ * key following these same rules. */
+function mergeManagedKey(base: unknown, next: unknown): unknown {
+  if (Array.isArray(base) && Array.isArray(next)) return [...new Set([...base, ...next])]
+  if (isRecordValue(base) && isRecordValue(next)) {
+    const merged: Record<string, unknown> = { ...base }
+    for (const [key, value] of Object.entries(next)) merged[key] = key in merged ? mergeManagedKey(merged[key], value) : value
+    return merged
+  }
+  return next
+}
+
+/** The parsed managed settings object, or {} when absent or malformed. Claude also
+ * merges an optional managed-settings.d/ directory next to the file: every *.json
+ * in alphabetical order after the base file, hidden files and non-json ignored. */
+export function readManagedSettings(file: string = managedSettingsFileOverride ?? managedSettingsPath()): Record<string, unknown> {
+  let merged = readOneSettingsFile(file)
+  const dropInDir = path.join(path.dirname(file), 'managed-settings.d')
+  let entries: string[]
+  try {
+    entries = fs.readdirSync(dropInDir)
+  } catch {
+    return merged
+  }
+  for (const entry of entries.filter((name) => name.endsWith('.json') && !name.startsWith('.')).sort((a, b) => a.localeCompare(b, 'en'))) {
+    merged = mergeManagedKey(merged, readOneSettingsFile(path.join(dropInDir, entry))) as Record<string, unknown>
+  }
+  return merged
+}

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/mcp/transport.ts

@@ -184,7 +184,9 @@ function helperEnv(name: string, config: HttpServerConfig): NodeJS.ProcessEnv {
  * env block, and Claude's path variables (CLAUDE_PROJECT_DIR, and CLAUDE_PLUGIN_ROOT
  * for a plugin's server). */
 function stdioEnv(config: StdioServerConfig, fill: (value: string) => string, session?: SessionDirs): Record<string, string> {
-  const env: Record<string, string> = { ...getDefaultEnvironment() }
+  // CLAUDECODE marks every subprocess; the long-lived server deliberately gets no
+  // CLAUDE_CODE_CHILD_SESSION, which Claude reserves for per-call children.
+  const env: Record<string, string> = { ...getDefaultEnvironment(), CLAUDECODE: '1' }
   for (const [key, value] of Object.entries(config.env ?? {})) env[key] = fill(value)
   if (session) env.CLAUDE_PROJECT_DIR = session.projectDir
   if (config.pluginRoot !== undefined) env.CLAUDE_PLUGIN_ROOT = config.pluginRoot

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
@@ -66,7 +72,8 @@ function formatCost(cost: number): string {
 
 interface RateLimitWindow {
   used_percentage: number
-  resets_at?: string
+  /** Unix epoch seconds when the window resets, per Claude's documented field. */
+  resets_at?: number
 }
 interface RateLimitSnapshot {
   five_hour?: RateLimitWindow
@@ -109,10 +116,26 @@ function readRateLimitWindow(headers: Record<string, string>, prefix: string): R
   // the computed value negative); clamp so the payload never carries a nonsense percentage.
   const window: RateLimitWindow = { used_percentage: Math.max(0, Math.min(100, usedPercentage)) }
   const resetsAt = headers[`${base}-reset`] ?? headers[`${base}-resets-at`]
-  if (resetsAt) window.resets_at = resetsAt
+  if (resetsAt) {
+    // Claude documents resets_at as Unix epoch seconds; the header carries an ISO
+    // timestamp (or, from some providers, a bare epoch number already).
+    const epoch = /^\d+$/.test(resetsAt.trim()) ? Number(resetsAt.trim()) : Math.floor(Date.parse(resetsAt) / 1000)
+    if (Number.isFinite(epoch)) window.resets_at = epoch
+  }
   return window
 }
 
+/** The snapshot with expired windows dropped, so a window whose reset time has
+ * passed never lingers in the payload; undefined when nothing remains. */
+function liveRateLimits(snapshot: RateLimitSnapshot): RateLimitSnapshot | undefined {
+  const nowSeconds = Date.now() / 1000
+  const keep = (window?: RateLimitWindow): RateLimitWindow | undefined => (window && (window.resets_at === undefined || window.resets_at > nowSeconds) ? window : undefined)
+  const fiveHour = keep(snapshot.five_hour)
+  const sevenDay = keep(snapshot.seven_day)
+  if (!fiveHour && !sevenDay) return undefined
+  return { ...(fiveHour ? { five_hour: fiveHour } : {}), ...(sevenDay ? { seven_day: sevenDay } : {}) }
+}
+
 /** The five-hour and seven-day utilization windows Claude's statusline reports,
  * from the unified rate-limit response headers. Undefined when neither is present
  * so a response without them never clobbers an earlier snapshot. */
@@ -132,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
     }
@@ -188,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
 
@@ -216,7 +255,9 @@ export default function statusLine(pi: ExtensionAPI) {
       session_id: ctx.sessionManager.getSessionId(),
       cwd: ctx.cwd,
       version: PACKAGE_VERSION,
-      workspace: { current_dir: ctx.cwd, project_dir: ctx.cwd },
+      // 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: [] },
       // 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 ?? '' },
@@ -255,19 +296,28 @@ export default function statusLine(pi: ExtensionAPI) {
     const sessionName = ctx.sessionManager.getSessionName?.()
     if (sessionName) payload.session_name = sessionName
     if (ctx.thinkingLevel) {
-      payload.effort = { level: ctx.thinkingLevel }
+      // pi's off/minimal are outside Claude's effort vocabulary: minimal maps to
+      // low, and off omits effort entirely (thinking disabled says the rest).
       payload.thinking = { enabled: ctx.thinkingLevel !== 'off' }
+      if (ctx.thinkingLevel !== 'off') payload.effort = { level: ctx.thinkingLevel === 'minimal' ? 'low' : ctx.thinkingLevel }
     }
     if (styleName) payload.output_style = { name: styleName }
     // The current utilization of the account's rate-limit windows, when the
-    // provider reported them; omitted entirely until a response has carried them.
-    if (rateLimits) payload.rate_limits = rateLimits
+    // provider reported them; omitted until a response has carried them, and an
+    // expired window is dropped rather than left stale.
+    if (rateLimits) {
+      const live = liveRateLimits(rateLimits)
+      if (live) payload.rate_limits = live
+    }
     return payload
   }
 
   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
     }
@@ -276,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
@@ -285,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
@@ -293,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
@@ -336,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']
@@ -355,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) => {
@@ -390,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.34",
+  "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",