pi-code 1.0.37 → 1.0.39

package/extensions/commands.ts

@@ -236,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.

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. */
@@ -539,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
@@ -557,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()
@@ -608,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])
@@ -618,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/plugins.ts

@@ -16,6 +16,7 @@ import * as fs from 'node:fs'
 import * as path from 'node:path'
 
 import { claudeConfigDir } from './config-dir.js'
+import { readManagedSettings } from './managed-settings.js'
 
 export interface InstalledPlugin {
   name: string
@@ -169,16 +170,30 @@ export function installedPlugins(home: string, extraSettingsFiles: string[] = []
   return plugins
 }
 
+/** The plugin's effective enablement per Claude's precedence: a managed
+ * enabledPlugins entry force-enables or blocks, then the user's setting, then the
+ * manifest's defaultEnabled, which defaults to true ("starts in an enabled state
+ * when the user has not set one"). */
+function pluginEnabled(qualified: string, pluginDir: string, enabled: Record<string, boolean>, manifest: Record<string, unknown>): boolean {
+  const managedEntry = readManagedSettings().enabledPlugins
+  if (managedEntry !== null && typeof managedEntry === 'object') {
+    const managedState = (managedEntry as Record<string, unknown>)[qualified] ?? (managedEntry as Record<string, unknown>)[pluginDir]
+    if (typeof managedState === 'boolean') return managedState
+  }
+  const userState = enabled[qualified] ?? enabled[pluginDir]
+  if (typeof userState === 'boolean') return userState
+  return manifest.defaultEnabled !== false
+}
+
 /** Resolve one cached plugin directory into an enabled InstalledPlugin, or null to skip
- * it: not turned on in settings, or no version directory on disk yet. */
+ * it: turned off by managed/user settings or defaultEnabled, or no version yet. */
 function resolvePlugin(home: string, cacheDir: string, marketplace: string, pluginDir: string, enabled: Record<string, boolean>, configs: Record<string, Record<string, string>>): InstalledPlugin | null {
   const qualified = `${pluginDir}@${marketplace}`
-  const state = enabled[qualified] ?? enabled[pluginDir]
-  if (state !== true) return null
   const version = newestVersion(listDirs(path.join(cacheDir, marketplace, pluginDir)))
   if (!version) return null
   const root = path.join(cacheDir, marketplace, pluginDir, version)
   const manifest = readJson(path.join(root, '.claude-plugin', 'plugin.json'))
+  if (!pluginEnabled(qualified, pluginDir, enabled, manifest)) return null
   const name = typeof manifest.name === 'string' && manifest.name.length > 0 ? manifest.name : pluginDir
   // Claude: "{id} is the plugin identifier with characters outside a-z, A-Z, 0-9,
   // _, and - replaced by -", one dash per character, underscores kept.

package/extensions/mcp/index.ts

@@ -595,6 +595,34 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     status.clear()
   })
 
+  // Claude references MCP resources with @server:uri mentions, fetched into the
+  // conversation when referenced. Only mentions naming a connected server expand;
+  // anything else (an email, a handle) stays untouched.
+  pi.on('input', async (event) => {
+    if (event.source === 'extension') return
+    const mentions = [...event.text.matchAll(/@([A-Za-z0-9_-]+):(\S+)/g)].filter((match) => clients.has(match[1]))
+    if (mentions.length === 0) return
+    const sections: string[] = []
+    for (const match of mentions) {
+      const [, server, uri] = match
+      try {
+        const client = clients.get(server)
+        if (!client) continue
+        const wall = callTimeoutMs()
+        const result = await withTimeout(client.readResource({ uri }, callRequestOptions(wall, callTuning(server))), wall, `read ${uri}`)
+        const text = (result.contents as Array<{ text?: string }>)
+          .map((entry) => entry.text)
+          .filter((value): value is string => typeof value === 'string')
+          .join('\n')
+        if (text) sections.push(capForContext(`<mcp-resource server="${server}" uri="${uri}">\n${text}\n</mcp-resource>`))
+      } catch {
+        // An unreadable resource leaves the mention as plain text.
+      }
+    }
+    if (sections.length === 0) return
+    return { action: 'transform', text: `${event.text}\n\n${sections.join('\n\n')}` }
+  })
+
   pi.registerCommand('mcp', {
     description: 'Show MCP server status and tools',
     handler: async (_args, ctx) => {

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.37",
+  "version": "1.0.39",
   "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",