pi-code 1.0.33 → 1.0.35

package/extensions/context-imports.ts

@@ -81,6 +81,21 @@ import { fenceMarker, stripBlockComments } from './internal/strip-comments.js'
 
 /** Claude documents "a maximum depth of four hops" for recursive imports. */
 const MAX_IMPORT_DEPTH = 4
+
+/** Claude loads a context file (CLAUDE.md and friends) of up to 4 MiB in full and
+ * skips a larger one. */
+const CONTEXT_FILE_MAX_BYTES = 4 * 1024 * 1024
+
+/** One context file's content, or undefined when it is absent, unreadable, or over
+ * the 4 MiB limit Claude documents. */
+function readContextFile(filePath: string): string | undefined {
+  try {
+    if (fs.statSync(filePath).size > CONTEXT_FILE_MAX_BYTES) return undefined
+    return fs.readFileSync(filePath, 'utf-8')
+  } catch {
+    return undefined
+  }
+}
 export const MAX_IMPORT_FILES = 50
 export const MAX_IMPORT_BYTES = 256 * 1024
 
@@ -292,11 +307,8 @@ export function additionalDirContextFiles(dir: string, includeLocal: boolean): A
   if (includeLocal) candidates.push(path.join(dir, 'CLAUDE.local.md'))
   const files: Array<{ path: string; content: string }> = []
   for (const candidate of candidates) {
-    try {
-      files.push({ path: candidate, content: fs.readFileSync(candidate, 'utf-8') })
-    } catch {
-      // absent or unreadable: treat as not there
-    }
+    const content = readContextFile(candidate)
+    if (content !== undefined) files.push({ path: candidate, content })
   }
   return files
 }
@@ -717,12 +729,9 @@ export default function contextImportsExtension(pi: ExtensionAPI) {
 
     // ~/.claude/CLAUDE.md, Claude's user-scope memory. The user's own file, so no
     // project approval is required; a missing file simply leaves it unset.
-    try {
-      const userClaudeMd = path.join(claudeConfigDir(os.homedir()), 'CLAUDE.md')
-      userContext = { path: userClaudeMd, content: fs.readFileSync(userClaudeMd, 'utf-8') }
-    } catch {
-      // no user CLAUDE.md
-    }
+    const userClaudeMd = path.join(claudeConfigDir(os.homedir()), 'CLAUDE.md')
+    const userContent = readContextFile(userClaudeMd)
+    if (userContent !== undefined) userContext = { path: userClaudeMd, content: userContent }
 
     // CLAUDE.local.md is Claude Code's personal sidecar of CLAUDE.md; pi's own loader
     // skips it. A cloned repo can ship one, so it is gated like other project config.
@@ -735,18 +744,12 @@ export default function contextImportsExtension(pi: ExtensionAPI) {
     const dotClaudeMd = findNearestFile(ctx.cwd, path.join('.claude', 'CLAUDE.md'))
     if ((candidates.length > 0 || dotClaudeMd !== null) && (await isProjectApproved(ctx))) {
       for (const candidate of candidates) {
-        try {
-          localContexts.push({ path: candidate, content: fs.readFileSync(candidate, 'utf-8') })
-        } catch {
-          // unreadable: treat as absent
-        }
+        const content = readContextFile(candidate)
+        if (content !== undefined) localContexts.push({ path: candidate, content })
       }
       if (dotClaudeMd !== null) {
-        try {
-          projectDotClaude = { path: dotClaudeMd, content: fs.readFileSync(dotClaudeMd, 'utf-8') }
-        } catch {
-          // unreadable: treat as absent
-        }
+        const content = readContextFile(dotClaudeMd)
+        if (content !== undefined) projectDotClaude = { path: dotClaudeMd, content }
       }
     }
     // Read after the local-context flow so an approval it just recorded is honored.

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/builtin-styles/concise.md

@@ -0,0 +1,13 @@
+---
+name: Concise
+description: Leads with the result and keeps responses short by default, without cutting the engineering work
+keep-coding-instructions: true
+---
+
+Lead with the result. Skip preamble, narration, and restating the request; answer first, support after.
+
+Keep responses short by default while doing the engineering work as thoroughly as ever: brevity applies to the writing, never to the analysis, testing, or care taken.
+
+When the user asks for an explanation or more detail, answer in full.
+
+Always keep the complete content of error reports, security warnings, and confirmations for destructive actions; never shorten those.

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/path-rules.ts

@@ -198,9 +198,14 @@ export function globCompileStats(): { compiled: number; evaluated: number } {
 /** Rule `paths:` globs compiled once for repeated matching, with claude-rules'
  * pathMatchesGlobs semantics: `./` and leading `/` anchors are stripped, a trailing
  * slash scopes to the directory's contents, and blank entries drop out. */
+/** Claude's shared list budget: rule patterns past ~1000 compiled entries are
+ * ignored rather than compiled without bound. */
+const LIST_PATTERN_BUDGET = 1000
+
 export function compileGlobs(globs: string[]): CompiledGlob[] {
   const compiled: CompiledGlob[] = []
   for (const raw of globs) {
+    if (compiled.length >= LIST_PATTERN_BUDGET) break
     let glob = raw.trim()
     if (!glob) continue
     if (glob.startsWith('./')) glob = glob.slice(2)

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/memory.ts

@@ -15,6 +15,7 @@ import { StringEnum } from '@earendil-works/pi-ai'
 import { type ExtensionAPI, withFileMutationQueue } from '@earendil-works/pi-coding-agent'
 import { Type } from 'typebox'
 import { claudeConfigDir } from './internal/config-dir.js'
+import { readManagedSettings } from './internal/managed-settings.js'
 import { capForContext } from './internal/output-guard.js'
 import { isProjectApprovedSilently } from './internal/project-approval.js'
 import { repoRoot } from './internal/project-root.js'
@@ -141,6 +142,18 @@ export function indexWouldOverflow(index: string, name: string, description: str
   return next.split('\n').length > INDEX_MAX_LINES || Buffer.byteLength(next, 'utf-8') > INDEX_MAX_BYTES
 }
 
+/** Where the index stands against the read limits, measured on the loaded content
+ * (frontmatter and comments stripped): 'over' past either bound, 'near' within
+ * 10% of one, else 'ok'. Claude reminds near a limit and errors over it. */
+export function indexReadState(index: string): 'ok' | 'near' | 'over' {
+  const loaded = stripNonLoaded(index)
+  const lines = loaded.split('\n').length
+  const bytes = Buffer.byteLength(loaded, 'utf-8')
+  if (lines > INDEX_MAX_LINES || bytes > INDEX_MAX_BYTES) return 'over'
+  if (lines > INDEX_MAX_LINES * 0.9 || bytes > INDEX_MAX_BYTES * 0.9) return 'near'
+  return 'ok'
+}
+
 type MemoryToolResult = { content: Array<{ type: 'text'; text: string }>; details: Record<string, never> }
 
 /** Write a memory and its index line, or say why it cannot be written. The whole
@@ -156,18 +169,29 @@ async function saveMemory(dir: string, indexPath: string, name: string | undefin
   }
   return withFileMutationQueue(indexPath, async (): Promise<MemoryToolResult> => {
     const index = readIndex(dir)
-    // Claude reports an explicit error rather than writing a memory the next session
-    // would never load, and says what to do about it.
-    if (indexWouldOverflow(index, name, description)) {
+    fs.mkdirSync(dir, { recursive: true })
+    // A memory with frontmatter records its write time; one without is left as-is.
+    fs.writeFileSync(path.join(dir, `${name}.md`), stampModified(content, now))
+    const nextIndex = upsertIndexLine(index, name, description)
+    writeIndex(indexPath, nextIndex)
+    // Claude measures the index after the write: over a read limit the write still
+    // succeeds, but an error tells Claude to rewrite the index (everything past
+    // the limit is dropped on the next load); near a limit, a reminder to shorten.
+    const state = indexReadState(nextIndex)
+    if (state === 'over') {
       return {
-        content: [{ type: 'text', text: `Memory index is full (${INDEX_MAX_LINES} entries or ${INDEX_MAX_BYTES} bytes). Delete or consolidate memories before saving ${name}.` }],
+        content: [
+          {
+            type: 'text',
+            text: `Saved memory ${name}, but the memory index is over its read limit (${INDEX_MAX_LINES} lines / ${INDEX_MAX_BYTES} bytes): rewrite MEMORY.md now. Keep one line per entry, move detail into topic files, and merge or drop stale entries; everything past the limit is dropped on the next load.`,
+          },
+        ],
         details: {},
       }
     }
-    fs.mkdirSync(dir, { recursive: true })
-    // A memory with frontmatter records its write time; one without is left as-is.
-    fs.writeFileSync(path.join(dir, `${name}.md`), stampModified(content, now))
-    writeIndex(indexPath, upsertIndexLine(index, name, description))
+    if (state === 'near') {
+      return { content: [{ type: 'text', text: `Saved memory ${name}. The memory index is near its read limit; shorten it: keep one line per entry, move detail into topic files, and merge or drop stale entries.` }], details: {} }
+    }
     return { content: [{ type: 'text', text: `Saved memory ${name}.` }], details: {} }
   })
 }
@@ -294,8 +318,9 @@ export function memorySettingsFiles(cwd: string, home: string, approved: boolean
   return claudeSettingsChain(cwd, home, approved)
 }
 
-/** Merge the two memory settings across the chain, later files winning per key. */
-export function readMemorySettings(files: string[]): { autoMemoryEnabled?: unknown; autoMemoryDirectory?: unknown } {
+/** Merge the two memory settings across the chain, later files winning per key;
+ * managed policy settings win over every file, per Claude's settings precedence. */
+export function readMemorySettings(files: string[], managed: Record<string, unknown> = readManagedSettings()): { autoMemoryEnabled?: unknown; autoMemoryDirectory?: unknown } {
   const merged: { autoMemoryEnabled?: unknown; autoMemoryDirectory?: unknown } = {}
   for (const file of files) {
     try {
@@ -307,6 +332,8 @@ export function readMemorySettings(files: string[]): { autoMemoryEnabled?: unkno
       // missing or invalid settings file: skip
     }
   }
+  if ('autoMemoryEnabled' in managed) merged.autoMemoryEnabled = managed.autoMemoryEnabled
+  if ('autoMemoryDirectory' in managed) merged.autoMemoryDirectory = managed.autoMemoryDirectory
   return merged
 }
 
@@ -405,7 +432,8 @@ export default function memoryExtension(pi: ExtensionAPI) {
   pi.registerTool({
     name: 'memory',
     label: 'Memory',
-    description: 'Persistent memory across sessions. Save durable facts, user preferences, corrections, and project decisions that are not derivable from the code. Actions: save (name + description + content), read (name), delete (name), list.',
+    description:
+      'Persistent memory across sessions. Save durable facts, user preferences, corrections, and project decisions that are not derivable from the code. Give each saved memory `type` frontmatter from the documented vocabulary: user (who the user is), feedback (guidance on how to work), project (ongoing work and constraints), or reference (pointers to external resources). Actions: save (name + description + content), read (name), delete (name), list.',
     parameters: MemoryParams,
     async execute(_id, params) {
       if (inSubagent()) {
@@ -492,6 +520,10 @@ export default function memoryExtension(pi: ExtensionAPI) {
         `  Index:       ${path.join(store, INDEX_FILE)}`,
         `  User memory (CLAUDE.md):    ${path.join(home, '.claude', 'CLAUDE.md')}`,
         `  Project memory (CLAUDE.md): ${path.join(ctx.cwd, 'CLAUDE.md')}`,
+        // Claude's /memory lists every documented location, including files that
+        // do not exist yet.
+        `  Project memory (CLAUDE.local.md): ${path.join(ctx.cwd, 'CLAUDE.local.md')}`,
+        `  Project memory (alternate):       ${path.join(ctx.cwd, '.claude', 'CLAUDE.md')}`,
         'Toggle with /memory on or /memory off.',
       ]
       ctx.ui.notify(lines.join('\n'), 'info')

package/extensions/output-styles.ts

@@ -25,6 +25,7 @@ import * as path from 'node:path'
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
 import { claudeConfigDir } from './internal/config-dir.js'
+import { readManagedSettings } from './internal/managed-settings.js'
 import { installedPlugins } from './internal/plugins.js'
 import { isProjectApproved } from './internal/project-approval.js'
 import { ancestorDirs, findNearestDir, findNearestFile } from './internal/project-root.js'
@@ -35,6 +36,8 @@ export interface OutputStyle {
   description: string
   body: string
   keepCodingInstructions: boolean
+  /** Claude's `force-for-plugin`: a plugin style applying automatically. */
+  forceForPlugin: boolean
 }
 
 function field(frontmatter: string, key: string): string {
@@ -47,7 +50,20 @@ export function parseStyle(content: string, fallbackName: string): OutputStyle {
   const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content)
   const frontmatter = match ? match[1] : ''
   const body = match ? content.slice(match[0].length) : content
-  return { name: field(frontmatter, 'name') || fallbackName, description: field(frontmatter, 'description'), body: body.trim(), keepCodingInstructions: field(frontmatter, 'keep-coding-instructions') === 'true' }
+  return {
+    name: field(frontmatter, 'name') || fallbackName,
+    description: field(frontmatter, 'description'),
+    body: body.trim(),
+    keepCodingInstructions: field(frontmatter, 'keep-coding-instructions') === 'true',
+    forceForPlugin: field(frontmatter, 'force-for-plugin') === 'true',
+  }
+}
+
+/** Claude's `force-for-plugin` (plugin output styles only): the first loaded style
+ * carrying it applies automatically, overriding the outputStyle setting. The
+ * caller passes only plugin-loaded styles. */
+export function forcedPluginStyle(styles: OutputStyle[]): OutputStyle | undefined {
+  return styles.find((style) => style.forceForPlugin)
 }
 
 /** Equivalents of Claude's built-in styles, shipped with pi-code as the
@@ -137,8 +153,10 @@ export function settingsFiles(cwd: string, home: string, trusted: boolean): stri
   return claudeSettingsChain(cwd, home, trusted)
 }
 
-/** The `outputStyle` recorded in settings, last file winning. */
-export function readActiveStyleName(files: string[]): string | undefined {
+/** The `outputStyle` recorded in settings, last file winning; a managed policy
+ * value wins over every file, per Claude's settings precedence. */
+export function readActiveStyleName(files: string[], managed: Record<string, unknown> = readManagedSettings()): string | undefined {
+  if (typeof managed.outputStyle === 'string') return managed.outputStyle
   let name: string | undefined
   for (const file of files) {
     try {
@@ -186,7 +204,10 @@ export default function outputStylesExtension(pi: ExtensionAPI) {
     const nearestLocal = findNearestFile(ctx.cwd, path.join('.claude', 'settings.local.json'))
     const claudeDir = findNearestDir(ctx.cwd, '.claude') ?? path.join(ctx.cwd, '.claude')
     localSettingsPath = nearestLocal ?? path.join(claudeDir, 'settings.local.json')
-    activeName = readActiveStyleName(settingsFiles(ctx.cwd, home, trusted))
+    // Claude's force-for-plugin: the first loaded forced plugin style applies
+    // automatically, overriding the outputStyle setting.
+    const forced = forcedPluginStyle(loadStyles(pluginStyleDirs(home)))
+    activeName = forced?.name ?? readActiveStyleName(settingsFiles(ctx.cwd, home, trusted))
     const active = styleForName(styles, activeName)
     if (active) ctx.ui.notify(`Output style: ${active.name}`, 'info')
   })

package/extensions/status-line.ts

@@ -66,7 +66,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 +110,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. */
@@ -216,7 +233,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,13 +274,19 @@ 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
   }
 

package/package.json

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