pi-code 1.0.67 → 1.0.69

package/extensions/git-checkpoint.ts

@@ -168,6 +168,8 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
   // assistant turns it drives. before_agent_start starts a run; the first turn_start
   // then snapshots and clears this, so turns 2..n skip the wasted git work.
   let runNeedsSnapshot = true
+  /** Whether the run about to start came from a prompt (see before_agent_start below). */
+  let promptedRun = false
   let shadowDir: string | undefined
   let workTree: string | undefined
   // Absolute paths this session's edit tools targeted: the whole of what a checkpoint
@@ -219,6 +221,17 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
     await mirrorLocalExcludes(ctx)
   }
 
+  /** /fork writes a new session file and copies the branch's checkpoint entries into it,
+   * while the shadow repository is keyed to the session file: the refs those entries name
+   * live in the parent's shadow, and a restore from the fork's own answered "invalid
+   * reference". A local bare-to-bare fetch brings them across. Best effort: a parent
+   * shadow already pruned leaves those checkpoints unrestorable, as they were. */
+  async function inheritCheckpointRefs(previousSessionFile: string): Promise<void> {
+    const parentShadow = path.join(getAgentDir(), 'checkpoints', sessionSlug(previousSessionFile))
+    if (parentShadow === shadowDir || !fs.existsSync(parentShadow)) return
+    await gitShadow(['fetch', '--quiet', parentShadow, `+${CHECKPOINT_REF_PREFIX}/*:${CHECKPOINT_REF_PREFIX}/*`])
+  }
+
   /** git reads ignore rules from the tree's .gitignore files, the user's global excludes,
    * and $GIT_DIR/info/exclude. The shadow is the GIT_DIR here, so the repo's own
    * .git/info/exclude (where secrets and scratch that must never be committed live)
@@ -308,12 +321,29 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
   /** Fold a file's pre-edit content into the run's checkpoint. A file first edited part
    * way through a run is absent from that run's pre-run snapshot, so without this its
    * checkpoint holds no baseline and /rewind cannot undo that first edit. */
+  /** `file` named by the real directory it sits in, when a symlink inside the work tree
+   * leads there. git refuses a pathspec that passes through a symlink ("beyond a symbolic
+   * link"), so the file has to be tracked where it really is. The real directory is mapped
+   * back under the work tree as the session spells it: a cwd that is itself a symlinked
+   * path (macOS /var) must not push every file outside the tree. */
+  function throughSymlinks(file: string): string {
+    if (!workTree) return file
+    try {
+      const realTree = fs.realpathSync(workTree)
+      const realDir = fs.realpathSync(path.dirname(file))
+      const inside = path.relative(realTree, realDir)
+      if (inside.startsWith('..') || path.isAbsolute(inside)) return file
+      return path.join(workTree, inside, path.basename(file))
+    } catch {
+      return file
+    }
+  }
+
   async function captureBaseline(file: string): Promise<void> {
     const rel = workTreePath(file)
     if (!runRef || rel === undefined || !fs.existsSync(file)) return
     if ((await withoutIgnored([rel])).length === 0) return
-    const add = await gitShadow(['add', '--', rel])
-    if (add.code !== 0) return
+    if (!(await addPaths([rel]))) return
     // A commit, never an amend: the run's checkpoint can be a commit an earlier
     // checkpoint also points at, and rewriting it would strand that one.
     const commit = await commitShadow([])
@@ -329,13 +359,50 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
     return files.code === 0 && files.stdout.trim() === ''
   }
 
+  /** Stage what `git add` silently skipped. For a path under another repository (a
+   * workspace of clones, a submodule, $HOME) it exits 0 and stages nothing, so the edit
+   * was never snapshotted while /rewind still reported success. Such a file is written to
+   * the index directly, which `checkout` restores like any other entry. A deletion needs
+   * nothing here: `git add` does stage the removal of an entry the index already holds. */
+  async function stageSkippedPaths(paths: string[]): Promise<void> {
+    if (!workTree) return
+    const listed = await gitShadow(['ls-files', '-z', '--', ...paths])
+    if (listed.code !== 0) return
+    const indexed = new Set(listed.stdout.split('\0').filter(Boolean))
+    for (const rel of paths) {
+      if (!indexed.has(rel) && fs.existsSync(path.join(workTree, rel))) await indexDirectly(rel)
+    }
+  }
+
+  async function indexDirectly(rel: string): Promise<void> {
+    if (!workTree) return
+    const blob = await gitShadow(['hash-object', '-w', '--', rel])
+    if (blob.code !== 0) return
+    const executable = (fs.statSync(path.join(workTree, rel)).mode & 0o111) !== 0
+    await gitShadow(['update-index', '--add', '--cacheinfo', `${executable ? '100755' : '100644'},${blob.stdout.trim()},${rel}`])
+  }
+
+  /** Stage the tracked paths. git fails the whole add when one pathspec is refused, which
+   * used to end checkpointing for the session over a single path. On a failure each path
+   * is added alone and one git still refuses is dropped from the edit set, so it costs
+   * its own checkpoint and nobody else's. False only when nothing could be staged. */
+  async function addPaths(paths: string[]): Promise<boolean> {
+    if ((await gitShadow(['add', '--', ...paths])).code === 0) {
+      await stageSkippedPaths(paths)
+      return true
+    }
+    let staged = 0
+    for (const rel of paths) {
+      if ((await gitShadow(['add', '--', rel])).code === 0) staged++
+      else if (workTree) touched.delete(path.resolve(workTree, rel))
+    }
+    return staged > 0
+  }
+
   async function snapshot(): Promise<{ ref: string; createdAt: string } | undefined> {
     const createdAt = new Date().toISOString()
     const paths = await addablePaths()
-    if (paths.length > 0) {
-      const add = await gitShadow(['add', '--', ...paths])
-      if (add.code !== 0) return undefined
-    }
+    if (paths.length > 0 && !(await addPaths(paths))) return undefined
     // Decide "nothing changed" from the index, not from the commit exit code: a commit can
     // also fail on the user's global signing or hooks config, and reusing HEAD then would
     // record a ref that predates the current tree, so /rewind restores the wrong state.
@@ -386,7 +453,7 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
     ctx.ui.notify('Rewind complete', 'info')
   }
 
-  pi.on('session_start', async (_event, ctx) => {
+  pi.on('session_start', async (event, ctx) => {
     // One extension instance serves every session. A mid-turn /new fires session_start on
     // the same instance after turn_start took the pre-run snapshot but before turn_end saved
     // it; that pending ref belongs to the previous session and must not attach to the next
@@ -394,8 +461,11 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
     // own tree even though the prior run left it false.
     pending = undefined
     runNeedsSnapshot = true
+    promptedRun = false
     runRef = undefined
     await ensureShadow(ctx)
+    const forkedFrom = event.reason === 'fork' ? event.previousSessionFile : undefined
+    if (forkedFrom) await inheritCheckpointRefs(forkedFrom)
     touched.clear()
     for (const rel of await committedPaths()) touched.add(path.resolve(ctx.cwd, rel))
     checkpoints.clear()
@@ -425,13 +495,39 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
   // the checkpoint is only keyed and saved at turn_end. The snapshot is awaited here so
   // `git add -A` captures the tree before the model's first edit; turn_end reads the
   // resolved value.
-  pi.on('turn_start', async () => {
+  // Only a prompt fires before_agent_start. A provider retry, an overflow recovery and a
+  // queued follow-up all re-enter through agent.continue(), with agent_start alone.
+  pi.on('before_agent_start', async () => {
+    promptedRun = true
+  })
+
+  /** The checkpoint a continued run is still working under: it re-entered with no new user
+   * message, so its prompt already has one. A snapshot taken there stages every tracked
+   * file at its MID-run content into the index the recorded checkpoint is later extended
+   * from (a baseline captured afterwards moved the checkpoint onto that content), and a
+   * file first edited in that turn had its baseline folded into the discarded ref. */
+  function continuedCheckpoint(ctx: ExtensionContext): Checkpoint | undefined {
+    // A queued follow-up is a new user message and needs its own snapshot. Optional: the
+    // peer range reaches runtimes that may not have the method.
+    if (ctx.hasPendingMessages?.()) return undefined
+    const target = findLastUserMessage(ctx)
+    return target ? checkpoints.get(target.entryId) : undefined
+  }
+
+  pi.on('turn_start', async (_event, ctx) => {
     if (!runNeedsSnapshot) return
     runNeedsSnapshot = false
+    const prompted = promptedRun
+    promptedRun = false
     // Claude: "Set to 1 to disable file checkpointing. The /rewind command will not be
     // able to restore code changes." No snapshot means turn_end's `if (!snap) return`
     // always fires, so no checkpoint is ever recorded.
     if (process.env.CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING === '1') return
+    const continued = prompted ? undefined : continuedCheckpoint(ctx)
+    if (continued) {
+      runRef = continued.ref
+      return
+    }
     pending = await snapshot()
   })
 
@@ -442,7 +538,7 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
     if (!EDIT_TOOLS.has(event.toolName)) return
     const target = fileToolTarget(event)
     if (target === undefined) return
-    const file = path.resolve(ctx.cwd, target)
+    const file = throughSymlinks(path.resolve(ctx.cwd, target))
     if (touched.has(file)) return
     touched.add(file)
     await captureBaseline(file)

package/extensions/internal/tool-target.ts

@@ -7,16 +7,41 @@
  * context-imports and the command path-scope guard all go through it).
  */
 
+import * as os from 'node:os'
+import * as path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
 /** The tools that name a file pi-code acts on. */
 const FILE_TOOLS: ReadonlySet<string> = new Set(['read', 'edit', 'write'])
 
+/** The spaces pi folds to a plain one before resolving (pi dist/utils/paths). */
+const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g
+
+/** `target` as pi's file tools read it before resolving against cwd: a leading @ (which
+ * some models add) stripped, ~ expanded, a file:// URL decoded, unicode spaces folded.
+ * pi does this in resolveToCwd (dist/core/tools/path-utils), which the package does not
+ * export. A reader that skips it judges a different file than the one pi opens: a
+ * command scoped to `Read(*.md)` allowed `~/secret/notes.md`, read as <cwd>/~/secret. */
+function asPiReadsIt(target: string): string {
+  const folded = target.replace(UNICODE_SPACES, ' ')
+  const bare = folded.startsWith('@') ? folded.slice(1) : folded
+  if (bare === '~') return os.homedir()
+  if (bare.startsWith('~/') || (process.platform === 'win32' && bare.startsWith('~\\'))) return path.join(os.homedir(), bare.slice(2))
+  if (!bare.startsWith('file://')) return bare
+  try {
+    return fileURLToPath(bare)
+  } catch {
+    return bare
+  }
+}
+
 /** The path a file tool call named, or undefined for any other tool, an errored call,
- * or a call that named none. The path is as the tool gave it: callers resolve it
- * against their own cwd. */
+ * or a call that named none. Normalised as pi normalises it, and still relative when
+ * the model gave a relative path: callers resolve it against their own cwd. */
 export function fileToolTarget(event: { toolName: string; input?: unknown; isError?: boolean }): string | undefined {
   if (event.isError === true) return undefined
   if (!FILE_TOOLS.has(event.toolName)) return undefined
   const input = event.input as { path?: unknown; file_path?: unknown } | undefined
   const target = typeof input?.path === 'string' ? input.path : input?.file_path
-  return typeof target === 'string' && target.length > 0 ? target : undefined
+  return typeof target === 'string' && target.length > 0 ? asPiReadsIt(target) : undefined
 }

package/extensions/skills.ts

@@ -167,11 +167,37 @@ function refusedByOverride(name: string, ctx: ExtensionContext, trusted: boolean
   return { action: 'handled' }
 }
 
+/** Forked skills still running in the background, by name. */
+const runningForks = new Set<string>()
+
+/** Whether a context: fork skill holds the invoking turn for its result. Claude: "The
+ * forked subagent runs in the background: you keep working while it runs, and its result
+ * arrives in your conversation when it completes. Set background: false in the frontmatter
+ * to instead wait for the result in the turn that invoked the skill." It also waits in
+ * non-interactive mode, when CLAUDE_CODE_DISABLE_BACKGROUND_TASKS is 1, and "when you
+ * invoke a forked skill while an earlier invocation of the same skill is still running". */
+function forkWaits(name: string, frontmatter: Record<string, unknown>, ctx: ExtensionContext): boolean {
+  if (String(frontmatter.background).trim().toLowerCase() === 'false') return true
+  return !ctx.hasUI || process.env.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS === '1' || runningForks.has(name)
+}
+
+/** Start a forked skill in the background and hand its result to the conversation when it
+ * completes. The promise has no awaiter, and sendMessage on a pi whose session was
+ * replaced meanwhile throws: the catch keeps that from exiting pi, at the cost of the
+ * delivery, as a background subagent run's completion notice is lost the same way. */
+function startForkedSkill(pi: ExtensionAPI, ctx: ExtensionContext, fork: { name: string; filePath: string; expanded: string; agentName: string | undefined }): { action: 'handled' } {
+  runningForks.add(fork.name)
+  ctx.ui.notify(`Skill ${fork.name} is running in a forked subagent in the background; its result arrives here when it completes.`, 'info')
+  void runForkedSkill(fork.name, fork.filePath, fork.expanded, fork.agentName)
+    .then((result) => pi.sendMessage({ customType: 'skill-fork', content: result.text, display: true }, { triggerTurn: true }))
+    .catch(() => {})
+    .finally(() => runningForks.delete(fork.name))
+  return { action: 'handled' }
+}
+
 /** Claude's context: fork run: the expanded skill content becomes the prompt that
- * drives a subagent, without the conversation history. Divergence: Claude
- * backgrounds the fork by default; pi-code waits for the result in the invoking
- * turn (Claude's background: false behavior, which is also what Claude itself
- * does in -p and SDK runs). */
+ * drives a subagent, without the conversation history. Never rejects: a failed run
+ * is reported in the returned block. */
 async function runForkedSkill(name: string, filePath: string, expanded: string, agentName: string | undefined): Promise<{ action: 'transform'; text: string }> {
   try {
     const output = await runAgent({ prompt: expanded, fullTools: true, ...(agentName ? { agent: agentName } : {}) })
@@ -218,7 +244,9 @@ async function expandSkillInvocation(pi: ExtensionAPI, rawText: string, ctx: Ext
   }
   const expanded = await expandCommand(pi, parsed, args, { cwd: ctx.cwd }, found.filePath, undefined, { allowShell: !shellExecutionDisabled(ctx.cwd, os.homedir(), trusted) })
   if (typeof frontmatter.context === 'string' && frontmatter.context.trim().toLowerCase() === 'fork') {
-    return runForkedSkill(name, found.filePath, expanded, typeof frontmatter.agent === 'string' ? frontmatter.agent.trim() : undefined)
+    const agentName = typeof frontmatter.agent === 'string' ? frontmatter.agent.trim() : undefined
+    if (forkWaits(name, frontmatter, ctx)) return runForkedSkill(name, found.filePath, expanded, agentName)
+    return startForkedSkill(pi, ctx, { name, filePath: found.filePath, expanded, agentName })
   }
   return { action: 'transform', text: `<skill name="${name}" location="${found.filePath}">\nReferences are relative to ${found.baseDir}.\n\n${expanded}\n</skill>` }
 }

package/extensions/status-line.ts

@@ -114,12 +114,15 @@ function toNumber(value: string | undefined): number | undefined {
 }
 
 /** One rate-limit window from the `anthropic-ratelimit-<prefix>-*` header family,
- * taking a direct `-utilization` percentage when present, else computing it from
- * `-limit` and `-remaining`. resets_at comes from `-reset` when the header is set.
- * Header names vary, so only what is present is read and a bare number is enough. */
+ * taking `-utilization` when present, else computing the percentage from `-limit` and
+ * `-remaining`. `-utilization` is a 0 to 1 fraction, while Claude documents
+ * used_percentage as "from 0 to 100": it is scaled and rounded to one decimal, as
+ * Claude Code does (Math.round(utilization * 1000) / 10). resets_at comes from `-reset`
+ * when the header is set. Header names vary, so only what is present is read. */
 function readRateLimitWindow(headers: Record<string, string>, prefix: string): RateLimitWindow | undefined {
   const base = `anthropic-ratelimit-${prefix}`
-  let usedPercentage = toNumber(headers[`${base}-utilization`])
+  const utilization = toNumber(headers[`${base}-utilization`])
+  let usedPercentage = utilization === undefined ? undefined : Math.round(utilization * 1000) / 10
   if (usedPercentage === undefined) {
     const limit = toNumber(headers[`${base}-limit`])
     const remaining = toNumber(headers[`${base}-remaining`])

package/extensions/subagent/background.ts

@@ -11,6 +11,7 @@ import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
 import { killProcessTree } from '../internal/process-tree.js'
+import { sharedSlot } from '../internal/shared-slot.js'
 import { errorMessage } from '../internal/values.js'
 import { spawnChild } from './run.js'
 
@@ -57,7 +58,14 @@ export interface BackgroundSpawn {
   maxTurns?: number
 }
 
-const runs = new Map<string, BackgroundRun>()
+/** The registry, held on globalThis rather than in module state. /reload and a /resume into
+ * another directory clear pi's extension cache and evaluate this module again; a registry
+ * that died with the old instance left live children unlisted, uncancellable, and running
+ * on past pi's exit, since the quit path signals only what the registry holds. */
+const registry = sharedSlot<{ runs: Map<string, BackgroundRun>; finishSequence: number }>('background-runs')
+const state = registry.get() ?? { runs: new Map<string, BackgroundRun>(), finishSequence: 0 }
+registry.set(state)
+const runs = state.runs
 
 /** Cap on simultaneously running background children. */
 export const MAX_BACKGROUND_RUNS = 8
@@ -76,16 +84,15 @@ export function activeBackgroundRuns(): number {
   return [...runs.values()].filter((run) => run.live || run.state === 'running').length
 }
 
-/** Stamps BackgroundRun.finishedAt; a counter rather than a clock so two runs
- * completing in the same millisecond still evict in their true finish order. */
-let finishSequence = 0
+// state.finishSequence stamps BackgroundRun.finishedAt: a counter rather than a clock, so
+// two runs completing in the same millisecond still evict in their true finish order.
 
 /** Test seam: the registry is module state, so tests reset it between cases to
  * stay order-independent. */
 export function resetBackgroundRuns(): void {
   for (const run of runs.values()) removeRebuiltPrompt(run)
   runs.clear()
-  finishSequence = 0
+  state.finishSequence = 0
 }
 
 function evictFinishedRuns(): void {
@@ -287,7 +294,7 @@ function driveRun(run: BackgroundRun, invocation: BackgroundSpawn, onComplete: (
   const complete = (): void => {
     if (completed) return
     completed = true
-    run.finishedAt = ++finishSequence
+    run.finishedAt = ++state.finishSequence
     evictFinishedRuns()
     // A run outlives the session that started it, and pi's loader wires assertActive()
     // into every runtime call, so notifying a disposed session throws. This fires from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.0.67",
+  "version": "1.0.69",
   "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, subagents, and goals",
   "keywords": [
     "pi",