pi-code 1.0.77 → 1.2.0

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/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/extensions/question.ts

@@ -4,8 +4,11 @@
  * only), or space-toggled checkboxes when `multiSelect` is set. An optional `header`
  * labels the question. Escape in the editor returns to options; Escape in options cancels.
  * Multiple questions per call are not batched; ask sequentially.
+ * On the TUI each question is also offered to a remote responder over pi.events
+ * (REMOTE_QUESTION_CHANNEL); the first answer, local or remote, wins.
  */
 
+import { randomUUID } from 'node:crypto'
 import * as os from 'node:os'
 import * as path from 'node:path'
 import type { ExtensionAPI, ExtensionContext, Theme } from '@earendil-works/pi-coding-agent'
@@ -64,6 +67,26 @@ export interface QuestionSpec {
   multiSelect?: boolean
 }
 
+/** In-process, question-owned offer; arbitrary custom TUI components are not sent. */
+export const REMOTE_QUESTION_CHANNEL = 'pi-code:question:v1'
+export type RemoteQuestionOutcome = { action: 'answer'; indices: number[] } | { action: 'text'; text: string } | { action: 'cancel' } | { action: 'pass' }
+
+export interface RemoteQuestionOffer {
+  version: 1
+  requestId: string
+  sessionId: string
+  question: string
+  header?: string
+  options: OptionWithDesc[]
+  multiSelect: boolean
+  allowFreeText: boolean
+  signal: AbortSignal
+  /** Must be called during event emission; only one listener receives a settle handle. */
+  claim: () => ((outcome: RemoteQuestionOutcome) => boolean) | undefined
+  /** The claimed responder reports input activity to reset a configured idle timer. */
+  touch: () => boolean
+}
+
 /** Normalize either accepted shape into the list of questions to ask. */
 function questionList(params: Partial<QuestionSpec> & { questions?: QuestionSpec[] }): QuestionSpec[] {
   if (params.questions && params.questions.length > 0) return params.questions
@@ -194,19 +217,19 @@ export default function question(pi: ExtensionAPI) {
     // parallel leave the first unanswerable and the run unable to finish.
     executionMode: 'sequential',
 
-    async execute(_toolCallId, rawParams, _signal, _onUpdate, ctx) {
+    async execute(_toolCallId, rawParams, signal, _onUpdate, ctx) {
       const specs = questionList(rawParams as Partial<QuestionSpec> & { questions?: QuestionSpec[] })
       if (specs.length === 0) {
         return { content: [{ type: 'text', text: 'Error: No question provided' }], details: { question: '', options: [], answer: null } as QuestionDetails }
       }
-      if (specs.length === 1) return await askOne(specs[0], ctx)
+      if (specs.length === 1) return await askOne(specs[0], ctx, pi.events, signal)
 
       // Several questions are asked in sequence; a cancel ends the run, since the
       // remaining answers would be guesses about a flow the user just declined.
       const texts: string[] = []
       const collected: QuestionDetails[] = []
       for (const spec of specs) {
-        const result = await askOne(spec, ctx)
+        const result = await askOne(spec, ctx, pi.events, signal)
         const detail = result.details as QuestionDetails
         collected.push(detail)
         texts.push(`${spec.question}\n${result.content[0].text}`)
@@ -258,7 +281,135 @@ export default function question(pi: ExtensionAPI) {
   })
 }
 
-async function askOne(params: QuestionSpec, ctx: ExtensionContext): Promise<{ content: Array<{ type: 'text'; text: string }>; details: QuestionDetails }> {
+type QuestionAnswer = Awaited<ReturnType<typeof askViaOverlay>>
+
+/** A claimed offer raced against the open overlay: whichever answers first wins. */
+interface RemoteQuestion {
+  /** Routes remote answers into the overlay and remote activity into its idle timer. */
+  attach: (answer: (value: QuestionAnswer) => void, touch: () => void) => void
+  /** Ends the offer; the responder's settle handle and touch are rejected from then on. */
+  close: () => void
+}
+type RemoteOffer = { kind: 'settled'; value: QuestionAnswer } | { kind: 'claimed'; remote: RemoteQuestion }
+
+function validIndices(indices: unknown, count: number, multiSelect: boolean): indices is number[] {
+  if (!Array.isArray(indices) || (!multiSelect && indices.length !== 1)) return false
+  return new Set(indices).size === indices.length && indices.every((index) => Number.isInteger(index) && index >= 1 && index <= count)
+}
+
+/** A remote outcome as the answer it stands for: null is a cancel, undefined is a
+ * pass or anything this question cannot accept, which must never become an answer. */
+function remoteAnswer(outcome: RemoteQuestionOutcome, options: DisplayOption[], multiSelect: boolean): QuestionAnswer | undefined {
+  if (outcome === null || typeof outcome !== 'object') return undefined
+  if (outcome.action === 'cancel') return null
+  if (outcome.action === 'text') {
+    const text = typeof outcome.text === 'string' ? outcome.text.trim() : ''
+    return !multiSelect && text ? { answer: text, wasCustom: true } : undefined
+  }
+  if (outcome.action !== 'answer') return undefined
+  // Read once and copied, so a getter or Proxy cannot answer with other indices
+  // than the ones that passed validation.
+  const raw: unknown = outcome.indices
+  const indices: unknown = Array.isArray(raw) ? [...raw] : undefined
+  if (!validIndices(indices, options.length, multiSelect)) return undefined
+  const checked = options.map((_, index) => indices.includes(index + 1))
+  return { answer: selectedLabels(options, checked), wasCustom: false, ...(multiSelect ? {} : { index: indices[0] }) }
+}
+
+/** Undefined when nobody claims synchronously, so the overlay opens with no async gap. */
+function offerRemoteQuestion(params: QuestionSpec, allOptions: DisplayOption[], ctx: ExtensionContext, events: ExtensionAPI['events'] | undefined, signal: AbortSignal | undefined): RemoteOffer | undefined {
+  if (!events) return undefined
+  if (signal?.aborted) return { kind: 'settled', value: null }
+
+  const multiSelect = params.multiSelect === true
+  const controller = new AbortController()
+  let claimed = false
+  let early: { value: QuestionAnswer } | undefined
+  let deliver: ((value: QuestionAnswer) => void) | undefined
+  let touchOverlay: (() => void) | undefined
+  const close = (): void => {
+    controller.abort()
+    signal?.removeEventListener('abort', abort)
+  }
+  const settle = (value: QuestionAnswer): void => {
+    close()
+    if (deliver) deliver(value)
+    else early = { value }
+  }
+  // Pi aborts the turn before a session replacement invalidates ctx, so this is
+  // also the session-replacement path; ctx is never read after emission.
+  const abort = (): void => settle(null)
+  signal?.addEventListener('abort', abort, { once: true })
+
+  const offer: RemoteQuestionOffer = {
+    version: 1,
+    requestId: randomUUID(),
+    sessionId: ctx.sessionManager.getSessionId(),
+    question: params.question,
+    header: shortHeader(params.header),
+    options: params.options.map(({ label, description }) => ({ label, ...(description === undefined ? {} : { description }) })),
+    multiSelect,
+    allowFreeText: allOptions.some((option) => option.isOther === true),
+    signal: controller.signal,
+    claim: () => {
+      if (claimed || controller.signal.aborted) return undefined
+      claimed = true
+      return (outcome) => {
+        if (controller.signal.aborted) return false
+        const value = remoteAnswer(outcome, params.options, multiSelect)
+        if (value !== undefined) {
+          settle(value)
+          return true
+        }
+        // A pass or invalid reply only withdraws the remote side; the overlay stays
+        // open, and a turn abort must still cancel it.
+        controller.abort()
+        return outcome?.action === 'pass'
+      }
+    },
+    touch: () => {
+      if (!claimed || controller.signal.aborted) return false
+      touchOverlay?.()
+      return true
+    },
+  }
+
+  events.emit(REMOTE_QUESTION_CHANNEL, offer)
+  if (early) return { kind: 'settled', value: early.value }
+  if (!claimed || controller.signal.aborted) {
+    close()
+    return undefined
+  }
+  return {
+    kind: 'claimed',
+    remote: {
+      attach: (answer, touch) => {
+        deliver = answer
+        touchOverlay = touch
+      },
+      close,
+    },
+  }
+}
+
+/** ui.custom() is terminal-only: with a UI but no terminal (RPC mode) it resolves
+ * undefined immediately, which would read as a cancel without ever asking. Ask
+ * through the dialog primitives there instead. askUserQuestionTimeout is a TUI
+ * concept (a countdown, a keypress resetting it): the dialog-primitive fallback
+ * has no keyboard or visible countdown to drive it, so it is not applied there. */
+async function collectAnswer(params: QuestionSpec, ctx: ExtensionContext, allOptions: DisplayOption[], multiSelect: boolean, events?: ExtensionAPI['events'], signal?: AbortSignal): Promise<QuestionAnswer> {
+  if (ctx.mode !== 'tui') return askViaDialogs(params, ctx, allOptions, multiSelect)
+  const offer = offerRemoteQuestion(params, allOptions, ctx, events, signal)
+  if (offer?.kind === 'settled') return offer.value
+  const remote = offer?.remote
+  try {
+    return await askViaOverlay(params, ctx, allOptions, multiSelect, askUserQuestionTimeoutMs(), remote)
+  } finally {
+    remote?.close()
+  }
+}
+
+async function askOne(params: QuestionSpec, ctx: ExtensionContext, events?: ExtensionAPI['events'], signal?: AbortSignal): Promise<{ content: Array<{ type: 'text'; text: string }>; details: QuestionDetails }> {
   if (!ctx.hasUI) {
     return {
       content: [{ type: 'text', text: 'Error: UI not available (running in non-interactive mode)' }],
@@ -281,12 +432,7 @@ async function askOne(params: QuestionSpec, ctx: ExtensionContext): Promise<{ co
   // The free-text option does not compose with checkbox selection, so it is single-select only.
   const allOptions: DisplayOption[] = multiSelect ? [...params.options] : [...params.options, { label: 'Type something.', isOther: true }]
 
-  // ui.custom() is terminal-only: with a UI but no terminal (RPC mode) it resolves
-  // undefined immediately, which would read as a cancel without ever asking. Ask
-  // through the dialog primitives there instead. askUserQuestionTimeout is a TUI
-  // concept (a countdown, a keypress resetting it): the dialog-primitive fallback
-  // has no keyboard or visible countdown to drive it, so it is not applied there.
-  const result = ctx.mode === 'tui' ? await askViaOverlay(params, ctx, allOptions, multiSelect, askUserQuestionTimeoutMs()) : await askViaDialogs(params, ctx, allOptions, multiSelect)
+  const result = await collectAnswer(params, ctx, allOptions, multiSelect, events, signal)
 
   // Build simple options list for details; header/multiSelect appear only when set,
   // so single-select details are unchanged.
@@ -345,7 +491,7 @@ const IDLE_TICK_MS = 250
  * mechanics are testable directly, independent of where timeoutMs itself is read
  * from (askUserQuestionTimeoutMs, tested separately).
  */
-export function askViaOverlay(params: QuestionSpec, ctx: ExtensionContext, allOptions: DisplayOption[], multiSelect: boolean, timeoutMs?: number): Promise<{ answer: string; wasCustom: boolean; index?: number; timedOut?: boolean } | null> {
+export function askViaOverlay(params: QuestionSpec, ctx: ExtensionContext, allOptions: DisplayOption[], multiSelect: boolean, timeoutMs?: number, remote?: RemoteQuestion): Promise<{ answer: string; wasCustom: boolean; index?: number; timedOut?: boolean } | null> {
   return ctx.ui.custom<{ answer: string; wasCustom: boolean; index?: number; timedOut?: boolean } | null>((tui: Parameters<Parameters<ExtensionContext['ui']['custom']>[0]>[0], theme: Theme, _kb: unknown, done: (value: { answer: string; wasCustom: boolean; index?: number; timedOut?: boolean } | null) => void) => {
     let optionIndex = 0
     let editMode = false
@@ -368,6 +514,8 @@ export function askViaOverlay(params: QuestionSpec, ctx: ExtensionContext, allOp
      * here, so the interval can never outlive the overlay it belongs to. */
     function finish(value: { answer: string; wasCustom: boolean; index?: number; timedOut?: boolean } | null): void {
       stopIdleTimer()
+      // Closed before done, so a remote reply racing a local answer is rejected.
+      remote?.close()
       done(value)
     }
 
@@ -376,6 +524,8 @@ export function askViaOverlay(params: QuestionSpec, ctx: ExtensionContext, allOp
       deadline = Date.now() + timeoutMs
     }
 
+    remote?.attach(finish, resetIdleTimer)
+
     function fireTimeout(): void {
       // Claude: "submits any options you'd already selected". Single-select has
       // nothing pre-committed (a selection only exists once Enter confirms it), so

package/package.json

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