pi-code 1.0.35 → 1.0.37

package/extensions/commands.ts

@@ -5,8 +5,8 @@
  * handing `.claude/commands` to pi's prompt-template loader. Owning registration
  * is what makes the rest of Claude's command contract reachable: `$ARGUMENTS` and
  * positional substitution, `` !`cmd` `` bash output, `@file` inlining, subdirectory
- * commands (registered as `/frontend:build`; current Claude docs name a command by
- * file name alone, so the qualified form is a pi-code divergence), and the
+ * commands (named by file name alone, as Claude documents; subdirectories only
+ * organize the files), and the
  * `allowed-tools`, `argument-hint` and `model` frontmatter (`model` switches the
  * session model for the command's run via `pi.setModel`, restored on agent_end).
  * `shell: powershell` runs a command's injected spans through PowerShell when a
@@ -47,7 +47,7 @@ import { Type } from 'typebox'
 import { matchesBashRules } from './internal/bash-rules.js'
 import { type CommandExec, type DiscoveredCommand, discoverCommandFiles, expandDynamicContent, type ParsedCommand, parseCommandFile, resolvePowershellBinary, spanExec, substituteArgsDetailed, substituteVars } from './internal/command-file.js'
 import { claudeConfigDir } from './internal/config-dir.js'
-import { readManagedSettings } from './internal/managed-settings.js'
+import { managedSettingsFile, readManagedSettings } from './internal/managed-settings.js'
 import { capForContext } from './internal/output-guard.js'
 import { matchesPathRules } from './internal/path-rules.js'
 import { type InstalledPlugin, installedPlugins } from './internal/plugins.js'
@@ -115,15 +115,17 @@ function isDirectory(target: string): boolean {
   }
 }
 
-/** Existing `.claude/commands` directories, user first then project. The project
- * directory is the nearest at or above cwd (bounded at the repository root, matching
- * the approval walk) and is included only for approved projects. */
+/** Existing `.claude/commands` directories in Claude's precedence order (later
+ * directories win in collectCommands): project first, then personal, then the
+ * enterprise directory beside the managed settings file, per "enterprise
+ * overrides personal, and personal overrides project". The project directories
+ * are included only for approved projects. */
 export function commandDirs(cwd: string, home: string, trusted: boolean): string[] {
-  const candidates = [path.join(claudeConfigDir(home), 'commands')]
+  const candidates: string[] = []
   // 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.
+  // nearest winning an intra-project name clash: root-first with the nearest last.
   if (trusted) candidates.push(...ancestorDirs(cwd, path.join('.claude', 'commands')).reverse())
+  candidates.push(path.join(claudeConfigDir(home), 'commands'), path.join(path.dirname(managedSettingsFile()), '.claude', 'commands'))
   const dirs: string[] = []
   for (const dir of candidates) {
     if (!dirs.includes(dir) && isDirectory(dir)) dirs.push(dir)
@@ -270,23 +272,22 @@ export function slashCommandBudget(contextWindow: number | undefined, env: Recor
 /** The slash_command tool description: usage framing plus the budgeted command
  * list, each entry `/name - description (argument-hint)`. */
 export function slashCommandToolDescription(commands: SlashCommandEntry[], budget: number): string {
-  const lines: string[] = []
-  let used = 0
-  let omitted = 0
-  for (const command of commands) {
+  // Claude: "The listing always contains every skill name"; the budget shortens
+  // descriptions (later entries lose theirs first), never drops a name, so an
+  // omitted-but-invocable command can no longer contradict the listing.
+  const lines = commands.map((command) => `/${command.name}`)
+  let used = lines.reduce((total, line) => total + line.length + 1, 0)
+  for (const [index, command] of commands.entries()) {
     const hintSuffix = command.argumentHint ? ` (${command.argumentHint})` : ''
     // when_to_use is model-facing trigger text, appended after the description and before
     // the argument hint; it shares the per-entry cap and never reaches the user surface.
     const whenSuffix = command.whenToUse ? ` ${command.whenToUse}` : ''
     const entry = `/${command.name} - ${command.description}${whenSuffix}${hintSuffix}`.slice(0, ENTRY_CHAR_CAP)
-    if (used + entry.length + 1 > budget) {
-      omitted++
-      continue // a shorter later entry may still fit the remaining budget
-    }
-    used += entry.length + 1
-    lines.push(entry)
+    const growth = entry.length - lines[index].length
+    if (used + growth > budget) continue
+    used += growth
+    lines[index] = entry
   }
-  if (omitted > 0) lines.push(`(${omitted} more ${omitted === 1 ? 'command was' : 'commands were'} omitted: raise SLASH_COMMAND_TOOL_CHAR_BUDGET to list them)`)
   return ["Execute a custom slash command on the user's behalf. The command expands to instructions for you to follow in this conversation.", '', 'Available commands:', ...lines].join('\n')
 }
 

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/command-file.ts

@@ -394,9 +394,11 @@ export function substituteVars(text: string, vars: Record<string, string | undef
   return text.replaceAll(/\$\{(CLAUDE_[A-Z0-9_]+)\}/g, (token, name: string) => vars[name] ?? token)
 }
 
-/** `a/b/c.md` becomes Claude's `a:b:c`. */
+/** Claude: "You invoke a command file by its file name"; subdirectories organize
+ * files without namespacing, so `a/b/c.md` is `/c`. A same-name file in another
+ * subdirectory takes the name over (scan order decides), as with Claude. */
 export function commandNameFor(relativePath: string): string {
-  return relativePath.replace(/\.md$/, '').split(path.sep).join(':')
+  return path.basename(relativePath, '.md')
 }
 
 /** Every `*.md` under a commands directory, including nested ones. */

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,44 @@
+/**
+ * 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'
+
+// Captured at module load: the poll must run on real time even under a test's
+// fake timers (the stat watcher it replaced lived in libuv and was immune too);
+// otherwise fake-timer advances spin the poll and freeze real detection.
+const realSetInterval = globalThis.setInterval
+const realClearInterval = globalThis.clearInterval
+
+/** One file's content, or undefined when absent or unreadable. */
+function snapshot(file: string): string | undefined {
+  try {
+    return fs.readFileSync(file, 'utf-8')
+  } catch {
+    return undefined
+  }
+}
+
+/** Watch the given settings files, calling `reload` when any of them changes.
+ * Returns a dispose function. The poll compares content, not stats: a same-size
+ * rewrite within one timestamp tick is invisible to an mtime comparison on a
+ * coarse-granularity filesystem, which made detection flaky. Settings files are
+ * small, so re-reading them on the poll is negligible. The 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
+  let last = files.map(snapshot)
+  const timer = realSetInterval(() => {
+    const next = files.map(snapshot)
+    if (next.some((content, index) => content !== last[index])) {
+      last = next
+      reload()
+    }
+  }, interval)
+  // A watcher alone must never keep a one-shot run alive.
+  timer.unref?.()
+  return () => realClearInterval(timer)
+}

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.37",
   "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",