pi-code 1.0.42 → 1.0.43

package/extensions/claude-rules.ts

@@ -121,6 +121,10 @@ function findMarkdownFiles(dir: string, basePath = '', visited = new Set<string>
   } catch {
     return results // a missing or unreadable directory must not take down session start
   }
+  // Raw readdir order is filesystem-dependent (hash order on ext4, sorted on
+  // APFS), so unsorted iteration injects rules into the prompt in a different
+  // order per machine. Pinned-locale sort makes the prompt reproducible.
+  entries.sort((a, b) => a.name.localeCompare(b.name, 'en'))
   for (const entry of entries) {
     const relativePath = basePath ? `${basePath}/${entry.name}` : entry.name
     const fullPath = path.join(dir, entry.name)

package/extensions/context-imports.ts

@@ -299,7 +299,9 @@ export function additionalDirContextFiles(dir: string, includeLocal: boolean): A
     const names = fs
       .readdirSync(rulesDir)
       .filter((name) => name.endsWith('.md'))
-      .sort((a, b) => a.localeCompare(b))
+      // Pinned locale: the default collator follows the host locale, which
+      // reorders names like ch/ci/h and makes prompt content machine-dependent.
+      .sort((a, b) => a.localeCompare(b, 'en'))
     candidates.push(...names.map((name) => path.join(rulesDir, name)))
   } catch {
     // no rules directory in this additional dir

package/extensions/git-checkpoint.ts

@@ -262,11 +262,15 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
     runNeedsSnapshot = true
     await ensureShadow(ctx)
     checkpoints.clear()
+    const stored: Checkpoint[] = []
     for (const entry of ctx.sessionManager.getEntries()) {
       if (entry.type !== 'custom' || entry.customType !== CUSTOM_TYPE) continue
       const checkpoint = entry.data as Checkpoint | undefined
-      if (checkpoint?.entryId) checkpoints.set(checkpoint.entryId, checkpoint)
+      if (checkpoint?.entryId) stored.push(checkpoint)
     }
+    // The same cap the append path enforces: a resumed long session must not
+    // rebuild a rewind list beyond the per-session limit.
+    for (const checkpoint of capCheckpoints(stored)) checkpoints.set(checkpoint.entryId, checkpoint)
   })
 
   // A new agent loop starts a run: the next turn_start snapshots the pre-run tree.

package/extensions/internal/command-file.ts

@@ -531,13 +531,6 @@ function fenceBlocks(body: string): FenceBlock[] {
   return blocks
 }
 
-/** Spans of a body inside a protective fenced code block. */
-function fencedRanges(body: string): Array<[number, number]> {
-  return fenceBlocks(body)
-    .filter((block) => !block.exec)
-    .map((block) => [block.start, block.end])
-}
-
 /** Exit 1 is a normal result for Claude's documented search and comparison commands
  * (no matches, files differ); exit 2 and up fails even for these. The PowerShell
  * shell uses a different set, which "includes grep and git diff but not find or

package/extensions/internal/plugins.ts

@@ -12,6 +12,7 @@
  * ~/.claude/plugins/data/<id>, id being the qualified name folded to dashes.
  */
 
+import * as crypto from 'node:crypto'
 import * as fs from 'node:fs'
 import * as path from 'node:path'
 
@@ -49,9 +50,33 @@ function listDirs(dir: string): string[] {
   }
 }
 
-/** Version directories sort numerically segment-wise, so 1.10.0 beats 1.9.0. */
+/** One version string split for comparison: optional v prefix dropped, numeric
+ * base segments, and whatever follows a dash as the prerelease tag. */
+function parseVersion(version: string): { base: number[]; pre: string | undefined } {
+  const stripped = version.replace(/^v/i, '')
+  const dash = stripped.indexOf('-')
+  const base = (dash === -1 ? stripped : stripped.slice(0, dash)).split('.').map((segment) => Number.parseInt(segment, 10) || 0)
+  return { base, pre: dash === -1 ? undefined : stripped.slice(dash + 1) }
+}
+
+/** Semver ordering to the depth plugin cache dirs need: 1.10.0 beats 1.9.0,
+ * 10.0.0 beats v2.0.0, and a release outranks its own prerelease (a plain
+ * string sort got both of the latter wrong). */
+function compareVersions(a: string, b: string): number {
+  const left = parseVersion(a)
+  const right = parseVersion(b)
+  for (let i = 0; i < Math.max(left.base.length, right.base.length); i++) {
+    const diff = (left.base[i] ?? 0) - (right.base[i] ?? 0)
+    if (diff !== 0) return diff
+  }
+  if (left.pre === right.pre) return 0
+  if (left.pre === undefined) return 1
+  if (right.pre === undefined) return -1
+  return left.pre.localeCompare(right.pre, 'en', { numeric: true })
+}
+
 function newestVersion(versions: string[]): string | undefined {
-  return [...versions].sort((a, b) => a.localeCompare(b, 'en', { numeric: true })).at(-1)
+  return [...versions].sort(compareVersions).at(-1)
 }
 
 /** The enablement map, later files winning per key, as settings scopes merge. */
@@ -101,7 +126,8 @@ export function resetInstalledPluginsCache(): void {
   pluginCache.clear()
 }
 
-/** mtime plus size, so a same-instant rewrite with different content still differs. */
+/** mtime plus size; cheap, but blind to a same-size rewrite within one
+ * timestamp tick, so only directory-tree entries use it. */
 function statToken(target: string): string {
   try {
     const stat = fs.statSync(target)
@@ -111,15 +137,25 @@ function statToken(target: string): string {
   }
 }
 
+/** Content hash for the small settings files: a same-size rewrite within one
+ * mtime tick (the settings-watch flake class) must still invalidate the cache. */
+function contentToken(target: string): string {
+  try {
+    return crypto.createHash('sha256').update(fs.readFileSync(target)).digest('hex')
+  } catch {
+    return 'missing'
+  }
+}
+
 /**
- * A cheap change signature for one home's plugin config: the settings files' stat
- * tokens plus the cache tree's directory names and mtimes down through each plugin's
+ * A cheap change signature for one home's plugin config: the settings files'
+ * content hashes plus the cache tree's directory names and mtimes down through each plugin's
  * version directories, and the stat token of the resolved (newest) version's manifest
  * so an in-place edit of it invalidates the cache. Costs a few stats where the full
  * walk reads and parses the settings and every manifest.
  */
 function pluginFingerprint(cacheDir: string, settingsFiles: string[]): string {
-  const parts = settingsFiles.map(statToken)
+  const parts = settingsFiles.map(contentToken)
   for (const marketplace of listDirs(cacheDir)) {
     const marketplaceDir = path.join(cacheDir, marketplace)
     parts.push(`${marketplace}:${statToken(marketplaceDir)}`)

package/extensions/subagent/index.ts

@@ -105,7 +105,9 @@ async function writePromptToTempFile(agentName: string, prompt: string): Promise
   return { dir: tmpDir, filePath }
 }
 
-function getPiInvocation(args: string[]): { command: string; args: string[] } {
+/** Exported as a test seam: the fallbacks only fire in packaged distributions
+ * (bun single-file, compiled binary), which no CI run reaches naturally. */
+export function getPiInvocation(args: string[]): { command: string; args: string[] } {
   const currentScript = process.argv[1]
   const isBunVirtualScript = currentScript?.startsWith('/$bunfs/root/')
   if (currentScript && !isBunVirtualScript && fs.existsSync(currentScript)) {

package/package.json

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