pi-code 1.0.36 → 1.0.38

package/extensions/commands.ts

@@ -5,8 +5,8 @@
  * handing `.claude/commands` to pi's prompt-template loader. Owning registration
  * is what makes the rest of Claude's command contract reachable: `$ARGUMENTS` and
  * positional substitution, `` !`cmd` `` bash output, `@file` inlining, subdirectory
- * commands (registered as `/frontend:build`; current Claude docs name a command by
- * file name alone, so the qualified form is a pi-code divergence), and the
+ * commands (named by file name alone, as Claude documents; subdirectories only
+ * organize the files), and the
  * `allowed-tools`, `argument-hint` and `model` frontmatter (`model` switches the
  * session model for the command's run via `pi.setModel`, restored on agent_end).
  * `shell: powershell` runs a command's injected spans through PowerShell when a
@@ -47,7 +47,7 @@ import { Type } from 'typebox'
 import { matchesBashRules } from './internal/bash-rules.js'
 import { type CommandExec, type DiscoveredCommand, discoverCommandFiles, expandDynamicContent, type ParsedCommand, parseCommandFile, resolvePowershellBinary, spanExec, substituteArgsDetailed, substituteVars } from './internal/command-file.js'
 import { claudeConfigDir } from './internal/config-dir.js'
-import { readManagedSettings } from './internal/managed-settings.js'
+import { managedSettingsFile, readManagedSettings } from './internal/managed-settings.js'
 import { capForContext } from './internal/output-guard.js'
 import { matchesPathRules } from './internal/path-rules.js'
 import { type InstalledPlugin, installedPlugins } from './internal/plugins.js'
@@ -115,15 +115,17 @@ function isDirectory(target: string): boolean {
   }
 }
 
-/** Existing `.claude/commands` directories, user first then project. The project
- * directory is the nearest at or above cwd (bounded at the repository root, matching
- * the approval walk) and is included only for approved projects. */
+/** Existing `.claude/commands` directories in Claude's precedence order (later
+ * directories win in collectCommands): project first, then personal, then the
+ * enterprise directory beside the managed settings file, per "enterprise
+ * overrides personal, and personal overrides project". The project directories
+ * are included only for approved projects. */
 export function commandDirs(cwd: string, home: string, trusted: boolean): string[] {
-  const candidates = [path.join(claudeConfigDir(home), 'commands')]
+  const candidates: string[] = []
   // Claude scans every .claude/commands between cwd and the repository root, the
-  // nearest winning a name clash: collectCommands lets later directories win, so
-  // the project list goes root-first with the nearest last.
+  // nearest winning an intra-project name clash: root-first with the nearest last.
   if (trusted) candidates.push(...ancestorDirs(cwd, path.join('.claude', 'commands')).reverse())
+  candidates.push(path.join(claudeConfigDir(home), 'commands'), path.join(path.dirname(managedSettingsFile()), '.claude', 'commands'))
   const dirs: string[] = []
   for (const dir of candidates) {
     if (!dirs.includes(dir) && isDirectory(dir)) dirs.push(dir)
@@ -234,7 +236,7 @@ export async function expandCommand(runner: SpanRunner, parsed: ParsedCommand, a
           return { stdout, stderr: result.stderr, code: result.code }
         }
       : async () => ({ stdout: SHELL_DISABLED_PLACEHOLDER, stderr: '', code: 0 })
-  let expanded = await expandDynamicContent(withVars, ctx.cwd, exec)
+  let expanded = await expandDynamicContent(withVars, ctx.cwd, exec, parsed.shell === 'powershell' ? 'powershell' : 'bash')
 
   // Claude appends the raw arguments when the command never read them, so what
   // the user typed still reaches the model.
@@ -270,23 +272,22 @@ export function slashCommandBudget(contextWindow: number | undefined, env: Recor
 /** The slash_command tool description: usage framing plus the budgeted command
  * list, each entry `/name - description (argument-hint)`. */
 export function slashCommandToolDescription(commands: SlashCommandEntry[], budget: number): string {
-  const lines: string[] = []
-  let used = 0
-  let omitted = 0
-  for (const command of commands) {
+  // Claude: "The listing always contains every skill name"; the budget shortens
+  // descriptions (later entries lose theirs first), never drops a name, so an
+  // omitted-but-invocable command can no longer contradict the listing.
+  const lines = commands.map((command) => `/${command.name}`)
+  let used = lines.reduce((total, line) => total + line.length + 1, 0)
+  for (const [index, command] of commands.entries()) {
     const hintSuffix = command.argumentHint ? ` (${command.argumentHint})` : ''
     // when_to_use is model-facing trigger text, appended after the description and before
     // the argument hint; it shares the per-entry cap and never reaches the user surface.
     const whenSuffix = command.whenToUse ? ` ${command.whenToUse}` : ''
     const entry = `/${command.name} - ${command.description}${whenSuffix}${hintSuffix}`.slice(0, ENTRY_CHAR_CAP)
-    if (used + entry.length + 1 > budget) {
-      omitted++
-      continue // a shorter later entry may still fit the remaining budget
-    }
-    used += entry.length + 1
-    lines.push(entry)
+    const growth = entry.length - lines[index].length
+    if (used + growth > budget) continue
+    used += growth
+    lines[index] = entry
   }
-  if (omitted > 0) lines.push(`(${omitted} more ${omitted === 1 ? 'command was' : 'commands were'} omitted: raise SLASH_COMMAND_TOOL_CHAR_BUDGET to list them)`)
   return ["Execute a custom slash command on the user's behalf. The command expands to instructions for you to follow in this conversation.", '', 'Available commands:', ...lines].join('\n')
 }
 

package/extensions/internal/agent-run.ts

@@ -16,6 +16,12 @@ export interface AgentRunRequest {
   model?: string
   /** Optional extra system prompt (Claude's experimental `systemPrompt` field). */
   systemPrompt?: string
+  /** A discovered agent to run as (Claude's `agent` field on context: fork
+   * skills); unknown names fall back per fullTools. */
+  agent?: string
+  /** Run with the full toolset instead of the read-only hook shape, for
+   * context: fork skills. */
+  fullTools?: boolean
   /** Aborts the run at the hook's deadline. */
   signal?: AbortSignal
 }

package/extensions/internal/command-file.ts

@@ -49,7 +49,7 @@ export interface ParsedCommand {
 }
 
 export interface DiscoveredCommand {
-  /** Claude's namespaced name: a nested file is `dir:name`, a plugin's is `plugin:name`. */
+  /** Claude names a command by its file name alone; a plugin's is `plugin:name`. */
   name: string
   filePath: string
   /** Set for plugin commands, carrying the ${CLAUDE_PLUGIN_*} and ${user_config.*} substitution sources. */
@@ -394,9 +394,11 @@ export function substituteVars(text: string, vars: Record<string, string | undef
   return text.replaceAll(/\$\{(CLAUDE_[A-Z0-9_]+)\}/g, (token, name: string) => vars[name] ?? token)
 }
 
-/** `a/b/c.md` becomes Claude's `a:b:c`. */
+/** Claude: "You invoke a command file by its file name"; subdirectories organize
+ * files without namespacing, so `a/b/c.md` is `/c`. A same-name file in another
+ * subdirectory takes the name over (scan order decides), as with Claude. */
 export function commandNameFor(relativePath: string): string {
-  return relativePath.replace(/\.md$/, '').split(path.sep).join(':')
+  return path.basename(relativePath, '.md')
 }
 
 /** Every `*.md` under a commands directory, including nested ones. */
@@ -537,16 +539,21 @@ function fencedRanges(body: string): Array<[number, number]> {
 }
 
 /** Exit 1 is a normal result for Claude's documented search and comparison commands
- * (no matches, files differ); exit 2 and up fails even for these. */
+ * (no matches, files differ); exit 2 and up fails even for these. The PowerShell
+ * shell uses a different set, which "includes grep and git diff but not find or
+ * diff" (test/[ are bash builtins and do not apply there either). */
 const EXIT_ONE_OK = new Set(['grep', 'rg', 'egrep', 'fgrep', 'find', 'diff', 'test', '['])
+const EXIT_ONE_OK_POWERSHELL = new Set(['grep', 'rg', 'egrep', 'fgrep'])
 
-const isCarveoutSegment = (segment: string): boolean => {
+export type SpanShell = 'bash' | 'powershell'
+
+const isCarveoutSegment = (segment: string, shell: SpanShell): boolean => {
   const words = segment.trim().split(/\s+/)
   if (words[0] === 'git') return words[1] === 'diff' || words[1] === 'grep'
-  return EXIT_ONE_OK.has(words[0])
+  return (shell === 'powershell' ? EXIT_ONE_OK_POWERSHELL : EXIT_ONE_OK).has(words[0])
 }
 
-function benignExitOne(command: string): boolean {
+export function benignExitOne(command: string, shell: SpanShell = 'bash'): boolean {
   const segments = splitSegments(command)
   if (segments.length === 0) return false
   // A `&&`/`||` chain can short-circuit, so an earlier segment's exit 1 becomes the
@@ -555,15 +562,15 @@ function benignExitOne(command: string): boolean {
   // the exit benign whichever ran last. Without short-circuit operators the exit is
   // the last segment's (a `|` pipeline exits with its final command, `;`/newline with
   // the last statement), so the last segment decides.
-  if (/&&|\|\|/.test(command)) return segments.every(isCarveoutSegment)
-  return isCarveoutSegment(segments.at(-1) ?? '')
+  if (/&&|\|\|/.test(command)) return segments.every((segment) => isCarveoutSegment(segment, shell))
+  return isCarveoutSegment(segments.at(-1) ?? '', shell)
 }
 
 /** Run one injected span. A failure aborts the whole invocation, as Claude
  * documents: the model never sees a half-expanded body. */
-async function runSpan(exec: CommandExec, command: string, pattern: string): Promise<string> {
+async function runSpan(exec: CommandExec, command: string, pattern: string, shell: SpanShell): Promise<string> {
   const result = await exec(command)
-  if (result.code !== 0 && !(result.code === 1 && benignExitOne(command))) {
+  if (result.code !== 0 && !(result.code === 1 && benignExitOne(command, shell))) {
     throw new Error(`Shell command failed for pattern "${pattern}"\n[stderr]\n${(result.stderr || result.stdout).trim()}`)
   }
   return result.stdout.trimEnd()
@@ -606,7 +613,7 @@ interface DynamicSpan {
  * never re-scanned for further placeholders. Re-scanning was both a parity break
  * (Claude expands once) and a command-injection path: output of a `` ```! `` block
  * such as a commit message could smuggle its own `` !`cmd` `` for a later pass. */
-export async function expandDynamicContent(body: string, cwd: string, exec: CommandExec): Promise<string> {
+export async function expandDynamicContent(body: string, cwd: string, exec: CommandExec, shell: SpanShell = 'bash'): Promise<string> {
   const blocks = fenceBlocks(body)
   const protectedRanges = blocks.filter((block) => !block.exec).map((block): [number, number] => [block.start, block.end])
   const execRanges = blocks.filter((block) => block.exec).map((block): [number, number] => [block.start, block.end])
@@ -616,14 +623,14 @@ export async function expandDynamicContent(body: string, cwd: string, exec: Comm
 
   const spans: DynamicSpan[] = []
   for (const block of blocks) {
-    if (block.exec) spans.push({ start: block.start, end: block.end, run: () => runSpan(exec, block.content, '```!') })
+    if (block.exec) spans.push({ start: block.start, end: block.end, run: () => runSpan(exec, block.content, '```!', shell) })
   }
   // `!` counts only at the start of a line or after whitespace; `KEY=!`cmd`` is literal.
   const bashPattern = /(^|\s)!`([^`]+)`/g
   for (let m = bashPattern.exec(body); m !== null; m = bashPattern.exec(body)) {
     if (literal(m.index)) continue
     const [span, lead, command] = m
-    spans.push({ start: m.index, end: m.index + span.length, run: async () => lead + (await runSpan(exec, command, `!\`${command}\``)) })
+    spans.push({ start: m.index, end: m.index + span.length, run: async () => lead + (await runSpan(exec, command, `!\`${command}\``, shell)) })
   }
   const atPattern = /(^|\s)@(\S+)/g
   for (let m = atPattern.exec(body); m !== null; m = atPattern.exec(body)) {

package/extensions/internal/settings-watch.ts

@@ -7,20 +7,38 @@
 
 import * as fs from 'node:fs'
 
+// Captured at module load: the poll must run on real time even under a test's
+// fake timers (the stat watcher it replaced lived in libuv and was immune too);
+// otherwise fake-timer advances spin the poll and freeze real detection.
+const realSetInterval = globalThis.setInterval
+const realClearInterval = globalThis.clearInterval
+
+/** One file's content, or undefined when absent or unreadable. */
+function snapshot(file: string): string | undefined {
+  try {
+    return fs.readFileSync(file, 'utf-8')
+  } catch {
+    return undefined
+  }
+}
+
 /** Watch the given settings files, calling `reload` when any of them changes.
- * Returns a dispose function. The poll interval is env-tunable for tests. */
+ * Returns a dispose function. The poll compares content, not stats: a same-size
+ * rewrite within one timestamp tick is invisible to an mtime comparison on a
+ * coarse-granularity filesystem, which made detection flaky. Settings files are
+ * small, so re-reading them on the poll is negligible. The interval is
+ * env-tunable for tests. */
 export function watchSettingsFiles(files: string[], reload: () => void): () => void {
   const interval = Number(process.env.PI_CODE_SETTINGS_WATCH_INTERVAL_MS) || 2000
-  const listeners: Array<[string, (curr: fs.Stats, prev: fs.Stats) => void]> = []
-  for (const file of files) {
-    const listener = (curr: fs.Stats, prev: fs.Stats): void => {
-      if (curr.mtimeMs !== prev.mtimeMs || curr.size !== prev.size) reload()
+  let last = files.map(snapshot)
+  const timer = realSetInterval(() => {
+    const next = files.map(snapshot)
+    if (next.some((content, index) => content !== last[index])) {
+      last = next
+      reload()
     }
-    // persistent: false, so a watcher alone never keeps a one-shot run alive.
-    fs.watchFile(file, { interval, persistent: false }, listener)
-    listeners.push([file, listener])
-  }
-  return () => {
-    for (const [file, listener] of listeners) fs.unwatchFile(file, listener)
-  }
+  }, interval)
+  // A watcher alone must never keep a one-shot run alive.
+  timer.unref?.()
+  return () => realClearInterval(timer)
 }

package/extensions/skills.ts

@@ -25,11 +25,14 @@ import * as path from 'node:path'
 import { type ExtensionAPI, type ExtensionContext, parseFrontmatter } from '@earendil-works/pi-coding-agent'
 
 import { expandCommand, shellExecutionDisabled } from './commands.js'
+import { runAgent } from './internal/agent-run.js'
 import { parseCommandFile } from './internal/command-file.js'
 import { claudeConfigDir } from './internal/config-dir.js'
+import { managedSettingsFile } from './internal/managed-settings.js'
 import { installedPlugins } from './internal/plugins.js'
 import { isProjectApprovedSilently } from './internal/project-approval.js'
 import { ancestorDirs } from './internal/project-root.js'
+import { claudeSettingsChain } from './internal/settings-chain.js'
 import { SKILL_HOOKS_CHANNEL } from './internal/skill-hooks.js'
 
 function isDirectory(target: string): boolean {
@@ -45,7 +48,10 @@ function isDirectory(target: string): boolean {
  * name and description to the model, so an untrusted repository would otherwise get
  * text into the prompt without the user ever agreeing to load its config. */
 export function skillDirs(cwd: string, home: string, trusted: boolean): string[] {
-  const candidates = [path.join(claudeConfigDir(home), 'skills')]
+  // Claude's precedence: enterprise (the skills directory beside the managed
+  // settings file) overrides personal, and personal overrides project; discovery
+  // here is first-match, so higher precedence goes first.
+  const candidates = [path.join(path.dirname(managedSettingsFile()), '.claude', 'skills'), path.join(claudeConfigDir(home), 'skills')]
   // Enabled plugins contribute their skills directories. pi's loader names a
   // skill by its directory, so a plugin skill registers without Claude's
   // /plugin: prefix; a rename-free approximation, disclosed in the README.
@@ -125,11 +131,49 @@ export default function skillsExtension(pi: ExtensionAPI) {
   })
 }
 
+/** Claude's `skillOverrides` value for one skill from the settings chain, later
+ * files winning: "off" hides the skill entirely, "name-only" trims its listing
+ * (a pi-loader surface, noted in docs). */
+function skillOverrideFor(name: string, cwd: string, trusted: boolean): string | undefined {
+  let value: string | undefined
+  for (const file of claudeSettingsChain(cwd, os.homedir(), trusted)) {
+    try {
+      const overrides = JSON.parse(fs.readFileSync(file, 'utf-8')).skillOverrides
+      if (overrides !== null && typeof overrides === 'object' && typeof overrides[name] === 'string') value = overrides[name]
+    } catch {
+      // missing or invalid file: skip
+    }
+  }
+  return value
+}
+
+/** Claude's skillOverrides "off": the skill is hidden and does not run; the
+ * invocation is swallowed with a notice. Undefined lets the invocation proceed. */
+function refusedByOverride(name: string, ctx: ExtensionContext, trusted: boolean): { action: 'handled' } | undefined {
+  if (skillOverrideFor(name, ctx.cwd, trusted) !== 'off') return undefined
+  if (ctx.hasUI) ctx.ui.notify(`Skill "${name}" is turned off by skillOverrides in settings.`, 'info')
+  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). */
+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 } : {}) })
+    return { action: 'transform', text: `<skill name="${name}" location="${filePath}">\nThe skill ran in a forked subagent (no conversation history shared). Its result:\n\n${output}\n</skill>` }
+  } catch (error) {
+    return { action: 'transform', text: `<skill name="${name}">\nThe forked subagent run failed: ${error instanceof Error ? error.message : String(error)}\n</skill>` }
+  }
+}
+
 /** A `/skill:name args` invocation into its expanded skill block, or undefined to
  * pass the input through to pi untouched. The expanded body is wrapped in pi's
  * skill-block format so downstream behavior (the baseDir note for relative
  * references) matches an untouched invocation. */
-async function expandSkillInvocation(pi: ExtensionAPI, rawText: string, ctx: ExtensionContext): Promise<{ action: 'transform'; text: string } | undefined> {
+async function expandSkillInvocation(pi: ExtensionAPI, rawText: string, ctx: ExtensionContext): Promise<{ action: 'transform'; text: string } | { action: 'handled' } | undefined> {
   const text = rawText.trimStart()
   if (!text.startsWith('/skill:')) return
   const space = text.indexOf(' ')
@@ -139,6 +183,8 @@ async function expandSkillInvocation(pi: ExtensionAPI, rawText: string, ctx: Ext
   const trusted = isProjectApprovedSilently(ctx)
   const found = findClaudeSkill(name, skillDirs(ctx.cwd, os.homedir(), trusted))
   if (!found) return
+  const refused = refusedByOverride(name, ctx, trusted)
+  if (refused) return refused
   let parsed: ReturnType<typeof parseCommandFile>
   let content: string
   try {
@@ -153,10 +199,14 @@ async function expandSkillInvocation(pi: ExtensionAPI, rawText: string, ctx: Ext
   // Claude registers hooks a skill's frontmatter declares when the skill is
   // invoked, for the rest of the session; the hooks extension owns running them,
   // so the declaration is announced over the shared bus.
-  const declaredHooks = parseFrontmatter<Record<string, unknown>>(content).frontmatter.hooks
+  const frontmatter = parseFrontmatter<Record<string, unknown>>(content).frontmatter
+  const declaredHooks = frontmatter.hooks
   if (declaredHooks !== null && typeof declaredHooks === 'object' && !Array.isArray(declaredHooks)) {
     pi.events?.emit(SKILL_HOOKS_CHANNEL, { skillName: name, hooks: declaredHooks })
   }
   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)
+  }
   return { action: 'transform', text: `<skill name="${name}" location="${found.filePath}">\nReferences are relative to ${found.baseDir}.\n\n${expanded}\n</skill>` }
 }

package/extensions/subagent/index.ts

@@ -650,6 +650,20 @@ export const AGENT_HOOK_SYSTEM = [
 
 /** A throwaway agent config for one agent-hook run: read-only inspection tools, the
  * hook's model (a fast default when unset), and the decision-returning system prompt. */
+/** The agent a context: fork skill runs as when it names none: full toolset, no
+ * extra system prompt (the child keeps pi's default), the skill content as the
+ * task. */
+function forkAgent(request: Pick<AgentRunRequest, 'model' | 'systemPrompt'>): AgentConfig {
+  return {
+    name: 'fork',
+    description: 'forked skill run',
+    systemPrompt: request.systemPrompt ?? '',
+    ...(request.model ? { model: request.model } : {}),
+    source: 'builtin',
+    filePath: '',
+  }
+}
+
 export function buildHookAgent(request: Pick<AgentRunRequest, 'model' | 'systemPrompt'>): AgentConfig {
   return {
     name: 'agent-hook',
@@ -1467,7 +1481,10 @@ export default function subagentExtension(pi: ExtensionAPI) {
       // A subagent session must not spawn further agents; agent hooks inside one are
       // skipped (the seam rejection is non-blocking in runAgentHook).
       if (process.env.PI_CODE_SUBAGENT) throw new Error('agent hooks do not run inside a subagent')
-      const agent = buildHookAgent(request)
+      // A context: fork skill names its agent, or runs with the full toolset;
+      // agent hooks keep the read-only hook shape.
+      const named = request.agent ? discoverAgents(hookCwd, 'both').agents.find((a) => a.name === request.agent) : undefined
+      const agent = named ?? (request.fullTools ? forkAgent(request) : buildHookAgent(request))
       const result = await runSingleAgent({
         defaultCwd: hookCwd,
         agents: [agent],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.0.36",
+  "version": "1.0.38",
   "description": "Claude Code experience for the pi coding agent: reads your .claude config (rules, commands, skills, hooks, output styles, MCP servers, agents) and adds todo, checkpoints, memory, web, and subagents",
   "keywords": [
     "pi",