pi-code 1.1.0 → 1.2.1

package/README.md

@@ -62,7 +62,7 @@ pi has no general permission system, so most of what Claude routes through a per
 
 Trust is the other place pi-code is deliberately stricter. Claude states that "a `claude -p` run never shows the trust dialog" and loads the project's hooks, MCP servers, agents, commands, skills and rules anyway. pi-code refuses instead: with no stored decision and no UI to ask, a headless run in a project you have not already trusted loads none of them. A repository would otherwise get to run its own hooks and MCP servers in any CI job that checks it out, with nobody present to decline.
 
-`CLAUDE.md` itself needs no extension: pi loads `CLAUDE.md` / `AGENTS.md` context files natively (global + walking cwd to root). `context-imports.ts` only adds the `@import` resolution pi's loader lacks, appending the imported files without re-injecting the base. Setting `CLAUDE_CONFIG_DIR` relocates the entire home config scope (settings, commands, agents, skills, plugins, output styles, memory, and the user `CLAUDE.md`); a project's own `.claude/` is a separate scope and is unaffected.
+`CLAUDE.md` itself needs no extension: pi loads `CLAUDE.md` / `AGENTS.md` context files natively (global + walking cwd to root). `context-imports.ts` adds what pi's loader lacks, the `@import` resolution and Claude's other memory locations, without re-injecting the base (see [docs/claude-md.md](docs/claude-md.md)). Setting `CLAUDE_CONFIG_DIR` relocates the entire home config scope (settings, commands, agents, skills, plugins, output styles, memory, and the user `CLAUDE.md`); a project's own `.claude/` is a separate scope and is unaffected.
 
 [`extensions/internal/`](extensions/internal) holds the shared modules pi's loader must not treat as extensions (each file's header says what it owns); only `internal/` keeps them out of pi's extension scan.
 

package/extensions/claude-rules.ts

@@ -5,7 +5,9 @@
  * - Unscoped rules are inlined in full into the system prompt, global
  *   (~/.claude/rules/*.md) and approved-project (.claude/rules/*.md) alike:
  *   Claude loads rules without `paths:` frontmatter at launch with the same
- *   priority as .claude/CLAUDE.md.
+ *   priority as .claude/CLAUDE.md. Where the runtime builds the prompt from its
+ *   options they go in as context files, one per rule file, so a provider that
+ *   rebuilds the prompt keeps them.
  * - Path-scoped rules auto-attach: a rule file may declare `paths:` frontmatter
  *   (a glob or list of globs). Its scope is surfaced upfront as a pointer, and
  *   when a read/edit/write touches a file the globs cover, the rule body is
@@ -177,18 +179,39 @@ function findMarkdownFiles(dir: string, basePath = '', visited = new Set<string>
   return results
 }
 
+interface InlineRule {
+  /** The rule file's absolute path. */
+  file: string
+  body: string
+}
+
 interface ScopedRule {
   rel: string
+  /** The rule file's absolute path. */
+  file: string
   paths: string[]
   /** The rule text, attached when a matching file is touched. */
   body: string
 }
 
 interface RuleSet {
-  inline: string[]
+  inline: InlineRule[]
   scoped: ScopedRule[]
 }
 
+interface ContextFile {
+  path: string
+  content: string
+}
+
+/** The prompt options this extension edits. pi sets `forceSystemPrompt` from 0.86, where
+ * a handler that returned a prompt forced it for the run. */
+interface PromptOptions {
+  contextFiles?: ContextFile[]
+  appendSystemPrompt?: string
+  forceSystemPrompt?: string
+}
+
 const EMPTY_RULES: RuleSet = { inline: [], scoped: [] }
 
 /** The canonical form of a path. A target that does not exist yet (a write
@@ -211,19 +234,19 @@ function realpathOr(target: string): string {
  * (excluding another team's `.claude/rules/**`) relies on; the check runs on the
  * realpath so a symlink cannot dodge an exclusion. */
 function readRules(rulesDir: string, isExcluded?: (realPath: string) => boolean): RuleSet {
-  const inline: string[] = []
+  const inline: InlineRule[] = []
   const scoped: ScopedRule[] = []
   for (const file of findMarkdownFiles(rulesDir)) {
+    const lexical = path.join(rulesDir, file)
     if (isExcluded) {
       // Both spellings count: a glob written against the lexical path and one
       // written against the resolved real path each exclude, which can only
       // widen an exclusion, never dodge one.
-      const lexical = path.join(rulesDir, file)
       if (isExcluded(lexical) || isExcluded(realpathOr(lexical))) continue
     }
     let parsed: Frontmatter
     try {
-      parsed = parseFrontmatter(fs.readFileSync(path.join(rulesDir, file), 'utf-8'))
+      parsed = parseFrontmatter(fs.readFileSync(lexical, 'utf-8'))
     } catch {
       continue // one unreadable rule must not take down session start
     }
@@ -234,26 +257,72 @@ function readRules(rulesDir: string, isExcluded?: (realPath: string) => boolean)
     // an empty text block to a tool result is rejected by the API when the
     // result's content is a block array (image-bearing results).
     if (body.length === 0) continue
-    if (parsed.paths.length > 0) scoped.push({ rel: file, paths: parsed.paths, body })
-    else inline.push(body)
+    if (parsed.paths.length > 0) scoped.push({ rel: file, file: lexical, paths: parsed.paths, body })
+    else inline.push({ file: lexical, body })
   }
   return { inline, scoped }
 }
 
+/** The user's rules directory as a pointer names it, so the model's read resolves: against
+ * `~` under home, and by its full path where CLAUDE_CONFIG_DIR moved it elsewhere. */
+function userRulesBase(rulesDir: string, home: string): string {
+  const relative = path.relative(home, rulesDir)
+  const outsideHome = relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)
+  return outsideHome ? rulesDir : `~/${relative.split(path.sep).join('/')}`
+}
+
+/** The pointer list for a rule set's path-scoped rules. */
+function scopedPointers(rules: RuleSet, base: string): string {
+  const scopedList = rules.scoped.map((rule) => formatRulePointer(rule.rel, rule.paths, base)).join('\n')
+  return `Path-scoped rules, available in ${base}/:\n\n${scopedList}\n\nRead the relevant rule file with the read tool before working on the files it covers.`
+}
+
 /** The system-prompt section for one rule set: inlined bodies, then scoped pointers. */
 function rulesSection(title: string, rules: RuleSet, base: string): string {
   if (rules.inline.length === 0 && rules.scoped.length === 0) return ''
   let section = `\n\n## ${title}`
   if (rules.inline.length > 0) {
-    section += `\n\nThese rules always apply:\n\n${rules.inline.join('\n\n')}`
-  }
-  if (rules.scoped.length > 0) {
-    const scopedList = rules.scoped.map((rule) => formatRulePointer(rule.rel, rule.paths, base)).join('\n')
-    section += `\n\nPath-scoped rules, available in ${base}/:\n\n${scopedList}\n\nRead the relevant rule file with the read tool before working on the files it covers.`
+    section += `\n\nThese rules always apply:\n\n${rules.inline.map((rule) => rule.body).join('\n\n')}`
   }
+  if (rules.scoped.length > 0) section += `\n\n${scopedPointers(rules, base)}`
   return section
 }
 
+/** What a session's rules add to the prompt. Built once at session start, the only place
+ * the rule files are read. */
+interface PromptRules {
+  /** The unscoped rules as context files, each under its own file, the way Claude loads it. */
+  files: ContextFile[]
+  /** The scoped pointers. Not a file, so they travel as appended instructions. */
+  pointers: string
+  /** Both as text, for a prompt that does not re-render from its options. */
+  text: string
+}
+
+const NO_PROMPT_RULES: PromptRules = { files: [], pointers: '', text: '' }
+
+function promptRules(sets: Array<{ title: string; rules: RuleSet; base: string }>): PromptRules {
+  const scoped = sets.filter(({ rules }) => rules.scoped.length > 0)
+  return {
+    files: sets.flatMap(({ rules }) => rules.inline.map((rule) => ({ path: rule.file, content: rule.body }))),
+    pointers: scoped.map(({ rules, base }) => scopedPointers(rules, base)).join('\n\n'),
+    text: sets.map(({ title, rules, base }) => rulesSection(title, rules, base)).join(''),
+  }
+}
+
+/** Add the rules to the options a run's prompt is built from, returning how to take them
+ * out again. */
+function addToOptions(options: PromptOptions, contextFiles: ContextFile[], rules: PromptRules): () => void {
+  const append = options.appendSystemPrompt
+  // Copies: the options belong to one run and these entries serve every turn.
+  contextFiles.push(...rules.files.map((entry) => ({ ...entry })))
+  if (rules.pointers.length > 0) options.appendSystemPrompt = append ? `${append}\n\n${rules.pointers}` : rules.pointers
+  return () => {
+    contextFiles.splice(contextFiles.length - rules.files.length, rules.files.length)
+    if (rules.pointers.length > 0) options.appendSystemPrompt = append
+  }
+}
+
 /** A scoped rule resolved to the root its globs match against, ready to attach. */
 interface AttachTarget {
   /** The rule's `paths:` globs as written, reported on the instruction-events bus. */
@@ -269,6 +338,13 @@ interface AttachTarget {
   memoryType: 'User' | 'Project'
 }
 
+/** CLAUDE_CODE_DISABLE_CLAUDE_MDS keeps every rule out of context, as it does in Claude
+ * Code. Read where a rule would be delivered rather than once at session start: a
+ * project's settings.json env reaches process.env after this extension's session_start. */
+function rulesDisabled(): boolean {
+  return process.env.CLAUDE_CODE_DISABLE_CLAUDE_MDS === '1'
+}
+
 // Module level because the working list lives in each extension instance's closure.
 let pendingScopedRules = 0
 
@@ -280,12 +356,8 @@ export function pendingScopedRuleCount(): number {
 
 export default function claudeRulesExtension(pi: ExtensionAPI) {
   const globalRulesDir = path.join(claudeConfigDir(os.homedir()), 'rules')
-  let globalRules: RuleSet = EMPTY_RULES
-  let projectRules: RuleSet = EMPTY_RULES
-  // The base a scoped-rule pointer is written against, so the model's read resolves.
-  // The project rules dir may sit at an ancestor of cwd, where a cwd-relative
-  // '.claude/rules' would point the read at a path that does not exist.
-  let projectRulesBase = '.claude/rules'
+  const globalRulesBase = userRulesBase(globalRulesDir, os.homedir())
+  let rules: PromptRules = NO_PROMPT_RULES
   // Scoped rules still awaiting a matching touch. An attached rule leaves the
   // list, so each attaches at most once and the per-tool-result scan shrinks.
   let attachTargets: AttachTarget[] = []
@@ -303,14 +375,14 @@ export default function claudeRulesExtension(pi: ExtensionAPI) {
     // context loader honors gates rule files here.
     const excludeGlobs = readClaudeMdExcludes(claudeMdExcludeFiles(ctx.cwd, os.homedir(), approved), readManagedSettings())
     const isExcluded = (realPath: string): boolean => isExcludedPath(realPath, excludeGlobs, os.homedir())
-    globalRules = readRules(globalRulesDir, isExcluded)
+    const globalRules = readRules(globalRulesDir, isExcluded)
     // Nearest at-or-above cwd, so a subdirectory session still reads the rules the
     // approval walk gated on.
     // Not the user's own rules dir: from $HOME (or under a dotfiles repo rooted there)
     // the nearest one is ~/.claude/rules, which the global load above already read.
     const nearestRulesDir = approved ? findNearestDir(ctx.cwd, path.join('.claude', 'rules')) : null
     const projectRulesDir = nearestRulesDir !== null && sameLocation(nearestRulesDir, globalRulesDir) ? null : nearestRulesDir
-    projectRules = projectRulesDir ? readRules(projectRulesDir, isExcluded) : EMPTY_RULES
+    const projectRules = projectRulesDir ? readRules(projectRulesDir, isExcluded) : EMPTY_RULES
 
     // Global globs are relative to cwd; project globs to the project root (the dir
     // holding .claude), so `db/**` in a repo rule matches repo-relative paths even
@@ -318,30 +390,47 @@ export default function claudeRulesExtension(pi: ExtensionAPI) {
     // than on every tool result; rebuilt per session so a re-run re-attaches.
     const projectRoot = projectRulesDir ? path.dirname(path.dirname(projectRulesDir)) : ctx.cwd
     attachTargets = [
-      ...globalRules.scoped.map((rule) => ({ globs: rule.paths, compiled: compileGlobs(rule.paths), body: rule.body, root: realpathOr(ctx.cwd), file: path.join(globalRulesDir, rule.rel), memoryType: 'User' as const })),
-      ...projectRules.scoped.map((rule) => ({ globs: rule.paths, compiled: compileGlobs(rule.paths), body: rule.body, root: realpathOr(projectRoot), file: path.join(projectRulesDir ?? path.join(ctx.cwd, '.claude', 'rules'), rule.rel), memoryType: 'Project' as const })),
+      ...globalRules.scoped.map((rule) => ({ globs: rule.paths, compiled: compileGlobs(rule.paths), body: rule.body, root: realpathOr(ctx.cwd), file: rule.file, memoryType: 'User' as const })),
+      ...projectRules.scoped.map((rule) => ({ globs: rule.paths, compiled: compileGlobs(rule.paths), body: rule.body, root: realpathOr(projectRoot), file: rule.file, memoryType: 'Project' as const })),
     ]
     scopedTargets = attachTargets
     pendingScopedRules = attachTargets.length
     // Relative to cwd, which the read tool resolves: an ancestor dir yields a
     // `../…/.claude/rules` the model can follow, where a bare '.claude/rules'
     // would point at a nonexistent path under the subdirectory.
-    projectRulesBase = projectRulesDir === null ? '.claude/rules' : path.relative(ctx.cwd, projectRulesDir) || '.claude/rules'
+    const projectRulesBase = projectRulesDir === null ? '.claude/rules' : path.relative(ctx.cwd, projectRulesDir) || '.claude/rules'
+    // Global first: Claude loads user-level rules before project rules.
+    rules = promptRules([
+      { title: 'Global Rules', rules: globalRules, base: globalRulesBase },
+      { title: 'Project Rules', rules: projectRules, base: projectRulesBase },
+    ])
 
     const hasGlobal = globalRules.inline.length > 0 || globalRules.scoped.length > 0
     const projectCount = projectRules.inline.length + projectRules.scoped.length
-    if (hasGlobal || projectCount > 0) {
+    if ((hasGlobal || projectCount > 0) && !rulesDisabled()) {
       ctx.ui.notify(`Rules loaded: global ${hasGlobal ? 'yes' : 'no'}, project ${projectCount}`, 'info')
     }
   })
 
   pi.on('before_agent_start', async (event) => {
-    // Global first: Claude loads user-level rules before project rules, so project
-    // rules read later and take priority.
-    const addition = rulesSection('Global Rules', globalRules, '~/.claude/rules') + rulesSection('Project Rules', projectRules, projectRulesBase)
-    if (addition.length === 0) return
+    if (rules.text.length === 0 || rulesDisabled()) return
 
-    return { systemPrompt: event.systemPrompt + addition }
+    // Rules join the options the prompt is built from. A provider that rebuilds the prompt
+    // from them keeps the rules there, where text appended to the rendered prompt is
+    // dropped: claude-bridge hands Claude Code the context files and appended instructions.
+    const options: PromptOptions | undefined = event.systemPromptOptions
+    const contextFiles = options?.contextFiles
+    const before = event.systemPrompt
+    if (options !== undefined && contextFiles !== undefined) {
+      const undo = addToOptions(options, contextFiles, rules)
+      // pi >= 0.86 re-renders event.systemPrompt from the options, and the rules are in.
+      if (event.systemPrompt !== before) return
+      // A prompt an earlier handler forced stays fixed, but the options are that run's own
+      // copy and still what a rebuilding provider reads, so they keep the rules. An older pi
+      // reuses the options object next turn, so there the edit is undone.
+      if (options.forceSystemPrompt === undefined) undo()
+    }
+    return { systemPrompt: before + rules.text }
   })
 
   // A rule's body sits in the tool result that attached it. Compaction folds that result into
@@ -359,7 +448,7 @@ export default function claudeRulesExtension(pi: ExtensionAPI) {
   // This mirrors Claude Code, which attaches a scoped rule when a matching file is
   // read or edited rather than inlining it upfront.
   pi.on('tool_result', async (event, ctx) => {
-    if (attachTargets.length === 0) return
+    if (attachTargets.length === 0 || rulesDisabled()) return
     const rel = fileToolTarget(event)
     if (rel === undefined) return
     // Realpath both sides (roots canonicalise at session_start): a tool reporting

package/extensions/context-imports.ts

@@ -28,6 +28,13 @@
  * are removed along with their imports, and block-level HTML comments are stripped
  * from every surviving body (see internal/strip-comments).
  *
+ * Where the runtime builds the prompt from its options (pi 0.86 and later), the same
+ * memory is handed over as the options' context files instead, in Claude's order
+ * and with each import after its importer, and nothing is returned: the prompt is
+ * not forced, and a provider that rebuilds it from the options receives what a
+ * rewrite of the rendered text cannot give it. The text rewrite above remains for
+ * an older pi and for a prompt an earlier handler forced.
+ *
  * Security: context files can come from an untrusted project, so imports are
  * confined (after resolving symlinks) to the working directory plus its
  * repository root, and for user-config importers the user's own ~/.claude and
@@ -410,6 +417,10 @@ export function instructionsBlock(filePath: string, content: string): string {
 /** pi's <project_context> opener, the anchor the managed block is inserted after. */
 const CONTEXT_OPENER = '<project_context>\n\nProject-specific instructions and guidelines:\n\n'
 
+/** The opener as pi 0.86 and later renders it, which is the layout a forced prompt has
+ * there: one newline after the tag. */
+const SECTION_OPENER = '<project_context>\nProject-specific instructions and guidelines:\n\n'
+
 /** Remove a context block, preferring the shape pi assembles (trailing blank line). */
 function removeBlock(prompt: string, wrapper: string): string | null {
   for (const needle of [`${wrapper}\n\n`, wrapper]) {
@@ -433,7 +444,7 @@ function replaceBlock(prompt: string, wrapper: string, replacement: string): str
  * key) and the user CLAUDE.md. Each call prepends, so the last block inserted ends
  * up highest, which is how the managed/user/native order is built (see caller). */
 function withTopBlock(prompt: string, block: string): string {
-  for (const anchor of [CONTEXT_OPENER, '<project_context>\n\n']) {
+  for (const anchor of [CONTEXT_OPENER, SECTION_OPENER, '<project_context>\n\n']) {
     const at = prompt.indexOf(anchor)
     if (at === -1) continue
     const insert = at + anchor.length
@@ -784,13 +795,18 @@ function refusedImportsAddition(refused: Set<string>): string {
   return `\n\n## Imports not loaded (@)\n\nThese files resolve outside what the file importing them may read, so their contents are not in context:\n\n${list}`
 }
 
+/** What the import budget could not pay for, or nothing when it paid for everything. */
+function budgetNotice(budget: ImportBudget): string {
+  return budget.dropped === 0 ? '' : `${budget.dropped} further @imports were skipped: the import budget (${MAX_IMPORT_FILES} files, ${MAX_IMPORT_BYTES} bytes) is spent.`
+}
+
 /** The `## Imported context (@)` section for every resolved @import, with the
  * budget-exhaustion notice, announcing each as an `include`. Empty when nothing
  * was imported. */
 function importedAddition(imported: ImportedFile[], budget: ImportBudget, home: string, projectRoot: string, announce: (event: InstructionLoadEvent) => void): string {
   if (imported.length === 0) return ''
   const section = imported.map((entry) => `### ${entry.path}\n\n${stripBlockComments(entry.body)}`).join('\n\n')
-  const notice = budget.dropped === 0 ? '' : `\n\n${budget.dropped} further @imports were skipped: the import budget (${MAX_IMPORT_FILES} files, ${MAX_IMPORT_BYTES} bytes) is spent.`
+  const notice = budget.dropped === 0 ? '' : `\n\n${budgetNotice(budget)}`
   for (const entry of imported) {
     announce({ file_path: entry.path, memory_type: memoryTypeForPath(entry.path, home, projectRoot), load_reason: 'include', ...(entry.parent === undefined ? {} : { parent_file_path: entry.parent }) })
   }
@@ -826,6 +842,132 @@ function prependMemoryBlocks(prompt: string, changed: boolean, keptUser: { path:
   return { prompt, changed, managedFile }
 }
 
+interface ContextFile {
+  path: string
+  content: string
+}
+
+/** The prompt options this extension edits. pi sets `forceSystemPrompt` from 0.86, where
+ * a handler that returned a prompt forced it for the run. */
+interface PromptOptions {
+  contextFiles?: ContextFile[]
+  appendSystemPrompt?: string
+  forceSystemPrompt?: string
+}
+
+/** A file's rank among its directory's context files, in the order Claude loads them. */
+const RANK = { memory: 0, sibling: 1, alternate: 2, rule: 3, local: 4 } as const
+
+/** A context file with its place in Claude's load order: the user's own files, then each
+ * directory from the filesystem root down to cwd. */
+interface Placed {
+  file: ContextFile
+  /** How deep the file's directory sits on the way to cwd; 0 for the user's own files. */
+  depth: number
+  rank: number
+}
+
+function place(file: ContextFile, directory: string, rank: number, where: { config: string; cwd: string }): Placed {
+  const onTheWayToCwd = where.cwd === directory || where.cwd.startsWith(directory + path.sep)
+  // The user's rules only: a checkout under the config directory is still a project.
+  const own = isUnder(file.path, [path.join(where.config, 'rules')]) || !onTheWayToCwd
+  return { file, depth: own ? 0 : directory.length, rank }
+}
+
+/** A file pi or another extension handed over, placed by the shape of its path. */
+function placeByPath(file: ContextFile, where: { config: string; cwd: string }): Placed {
+  const rules = file.path.lastIndexOf(`${path.sep}.claude${path.sep}rules${path.sep}`)
+  if (rules !== -1) return place(file, file.path.slice(0, rules), RANK.rule, where)
+  const directory = path.dirname(file.path)
+  if (path.basename(file.path) === 'CLAUDE.local.md') return place(file, directory, RANK.local, where)
+  if (path.basename(directory) === '.claude') return place(file, path.dirname(directory), RANK.alternate, where)
+  return place(file, directory, RANK.memory, where)
+}
+
+function inClaudeOrder(placed: Placed[]): ContextFile[] {
+  return placed
+    .map((entry, index) => ({ entry, index }))
+    .sort((a, b) => a.entry.depth - b.entry.depth || a.entry.rank - b.entry.rank || a.index - b.index)
+    .map(({ entry }) => entry.file)
+}
+
+/** Each file followed by what it imports, an import's own imports right after it: Claude
+ * loads an import "alongside the CLAUDE.md that references" it. */
+function withImports(files: ContextFile[], imported: ImportedFile[]): ContextFile[] {
+  const result: ContextFile[] = []
+  const add = (file: ContextFile): void => {
+    result.push(file)
+    for (const entry of imported) {
+      if (entry.parent === file.path) add({ path: entry.path, content: stripBlockComments(entry.body) })
+    }
+  }
+  for (const file of files) add(file)
+  return result
+}
+
+/** A body the prompt has room for: trimmed, and absent when nothing is left. */
+function entryFor(file: ContextFile | undefined): ContextFile[] {
+  const content = file?.content.trim() ?? ''
+  return file === undefined || content.length === 0 ? [] : [{ path: file.path, content }]
+}
+
+/** What one turn loaded, by source. */
+interface LoadedMemory {
+  managedFile: string
+  /** The managed-settings `claudeMd` value, as found there. */
+  managedKey: unknown
+  user: ContextFile | undefined
+  native: ContextFile[]
+  siblings: ContextFile[]
+  alternate: ContextFile | undefined
+  locals: ContextFile[]
+  extras: ContextFile[]
+  imported: ImportedFile[]
+}
+
+/** The memory as context files in Claude's order, for a runtime that builds the prompt
+ * from its options. */
+function memoryEntries(memory: LoadedMemory, where: { config: string; cwd: string }): ContextFile[] {
+  const managedKey = typeof memory.managedKey === 'string' ? stripBlockComments(memory.managedKey) : ''
+  const ordered = inClaudeOrder([
+    ...memory.native.map((file) => placeByPath(file, where)),
+    ...memory.siblings.flatMap(entryFor).map((file) => place(file, path.dirname(file.path), RANK.sibling, where)),
+    ...entryFor(memory.alternate).map((file) => place(file, path.dirname(path.dirname(file.path)), RANK.alternate, where)),
+    ...memory.locals.flatMap(entryFor).map((file) => place(file, path.dirname(file.path), RANK.local, where)),
+  ])
+  const extras = memory.extras.map((extra) => ({ path: extra.path, content: extra.content }))
+  return [...entryFor({ path: managedClaudeMdPath(), content: memory.managedFile }), ...entryFor({ path: MANAGED_CLAUDE_MD_PATH, content: managedKey }), ...withImports([...entryFor(memory.user), ...ordered, ...extras], memory.imported)]
+}
+
+/** What is said about the imports that did not load. Not a file, so it travels as
+ * appended instructions, not as one of pi's custom prompt sections: a provider that
+ * rebuilds the prompt forwards the appended instructions and drops those sections. */
+function memoryNotices(budget: ImportBudget, refusedNotice: string): string {
+  return [budgetNotice(budget), refusedNotice.trim()].filter((notice) => notice.length > 0).join('\n\n')
+}
+
+/** Hand the memory over as the context files the prompt is built from, and say whether
+ * that reached the prompt. pi >= 0.86 re-renders the prompt from the options, so there
+ * the memory is in, in Claude's order, and a provider that rebuilds the prompt from the
+ * options receives it too. A prompt an earlier handler forced stays fixed, but the options
+ * are that run's own copy, so they keep the memory. An older pi reuses the options object
+ * next turn, so there they are left as found. */
+function deliverThroughOptions(event: { systemPrompt: string; systemPromptOptions?: PromptOptions }, entries: ContextFile[], notices: string): boolean {
+  const options = event.systemPromptOptions
+  const contextFiles = options?.contextFiles
+  if (options === undefined || contextFiles === undefined) return false
+  const before = event.systemPrompt
+  const found = [...contextFiles]
+  const append = options.appendSystemPrompt
+  contextFiles.splice(0, contextFiles.length, ...entries)
+  if (notices.length > 0) options.appendSystemPrompt = append ? `${append}\n\n${notices}` : notices
+  if (event.systemPrompt !== before) return true
+  if (options.forceSystemPrompt !== undefined) return false
+  contextFiles.splice(0, contextFiles.length, ...found)
+  if (notices.length > 0) options.appendSystemPrompt = append
+  return false
+}
+
 /** Everything the import expansion depends on, hashed to a memo key: a turn whose inputs
  * match a prior key and whose recorded mtimes are unchanged reuses the previous expansion
  * outright. The native/local paths, the user/project-.claude additions, and the managed file
@@ -1146,7 +1288,11 @@ export default function contextImportsExtension(pi: ExtensionAPI) {
     addition += localContextAddition(keptLocals, announce)
     addition += additionalDirsAddition(extras, announce)
     addition += importedAddition(imported, budget, home, projectRoot, announce)
-    addition += refusedImportsAddition(budget.refused)
+    const refusedNotice = refusedImportsAddition(budget.refused)
+    addition += refusedNotice
+
+    const entries = memoryEntries({ managedFile, managedKey: managed.claudeMd, user: keptUser, native: rewrite.kept, siblings: keptSiblings, alternate: keptProjectDotClaude, locals: keptLocals, extras, imported }, { config: claudeConfigDir(home), cwd })
+    if (deliverThroughOptions(event, entries, memoryNotices(budget, refusedNotice))) return
     if (!changed && addition.length === 0) return
 
     return { systemPrompt: prompt + addition }

package/extensions/git-checkpoint.ts

@@ -524,7 +524,7 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
    * 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.
+    // supported pi 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

package/extensions/internal/instruction-events.ts

@@ -10,6 +10,8 @@
 
 import * as path from 'node:path'
 
+import { claudeConfigDir } from './config-dir.js'
+
 export const INSTRUCTIONS_CHANNEL = 'pi-code:instructions'
 
 /** Claude's memory_type vocabulary for InstructionsLoaded payloads. */
@@ -43,11 +45,17 @@ export function isInstructionLoadEvent(data: unknown): data is InstructionLoadEv
 }
 
 /** Claude's memory_type from a file's location: CLAUDE.local.md is Local wherever it
- * sits; a file under home but outside the project is User; everything else, the
- * project itself included (which commonly lives under home), is Project. */
+ * sits; the user's own CLAUDE.md and rules, and a file under home but outside the
+ * project, are User; everything else, the project itself included (which commonly
+ * lives under home), is Project. */
 export function memoryTypeForPath(filePath: string, home: string, projectRoot: string): InstructionMemoryType {
   if (path.basename(filePath) === 'CLAUDE.local.md') return 'Local'
   const isUnder = (root: string): boolean => root.length > 0 && (filePath === root || filePath.startsWith(root + path.sep))
+  // Ahead of the project check: CLAUDE_CONFIG_DIR may sit outside home, and a session
+  // rooted at home has the config directory inside its project root. Only the user's
+  // memory there, since a checkout under the config directory is still a project.
+  const config = claudeConfigDir(home)
+  if (filePath === path.join(config, 'CLAUDE.md') || isUnder(path.join(config, 'rules'))) return 'User'
   if (isUnder(projectRoot)) return 'Project'
   // Nested repositories: repoRoot stops at the nearest .git, so a session inside a
   // nested checkout reports it as the project root while the outer repository's

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "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",
@@ -53,13 +53,13 @@
     "provenance": true
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0",
-    "typebox": "^1.3.6"
+    "@modelcontextprotocol/sdk": "^1.30.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.80.4",
-    "@earendil-works/pi-coding-agent": ">=0.80.4",
-    "@earendil-works/pi-tui": ">=0.80.4"
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.4",
@@ -71,6 +71,7 @@
     "@vitest/coverage-v8": "^5.0.0",
     "fast-check": "^4.9.0",
     "knip": "^6.34.0",
+    "typebox": "^1.3.6",
     "typescript": "^7.0.2",
     "vitest": "^5.0.0"
   }