@ilya-lesikov/pi-pi 0.8.0 → 0.10.0

package/3p/pi-subagents/src/agent-types.ts

@@ -5,33 +5,21 @@
  * User agents override defaults with the same name. Disabled agents are kept but excluded from spawning.
  */
 
-import type { AgentTool } from "@earendil-works/pi-agent-core";
-import {
-  createBashTool,
-  createEditTool,
-  createFindTool,
-  createGrepTool,
-  createLsTool,
-  createReadTool,
-  createWriteTool,
-} from "@earendil-works/pi-coding-agent";
+import { createCodingTools, createReadOnlyTools } from "@earendil-works/pi-coding-agent";
 import { DEFAULT_AGENTS } from "./default-agents.js";
 import type { AgentConfig } from "./types.js";
 
-type ToolFactory = (cwd: string) => AgentTool<any>;
-
-const TOOL_FACTORIES: Record<string, ToolFactory> = {
-  read: (cwd) => createReadTool(cwd),
-  bash: (cwd) => createBashTool(cwd),
-  edit: (cwd) => createEditTool(cwd),
-  write: (cwd) => createWriteTool(cwd),
-  grep: (cwd) => createGrepTool(cwd),
-  find: (cwd) => createFindTool(cwd),
-  ls: (cwd) => createLsTool(cwd),
-};
-
-/** All known built-in tool names, derived from the factory registry. */
-export const BUILTIN_TOOL_NAMES = Object.keys(TOOL_FACTORIES);
+/**
+ * All known built-in tool names, derived from pi's own tool factories rather
+ * than hardcoded so the set tracks pi-mono if it adds/renames a built-in.
+ * `createCodingTools` → read/bash/edit/write; `createReadOnlyTools` →
+ * read/grep/find/ls; their de-duplicated union is the 7 built-ins
+ * (read, bash, edit, write, grep, find, ls). The `cwd` only binds tool
+ * operations we never invoke here — we read each tool's `.name` and discard it.
+ */
+export const BUILTIN_TOOL_NAMES: string[] = [
+  ...new Set([...createCodingTools("."), ...createReadOnlyTools(".")].map((t) => t.name)),
+];
 
 /** Unified runtime registry of all agents (defaults + user-defined). */
 const agents = new Map<string, AgentConfig>();
@@ -39,13 +27,20 @@ const agents = new Map<string, AgentConfig>();
 /** Extension-injected agents (highest priority, survive reloads). */
 const extensionAgents = new Map<string, AgentConfig>();
 
+/** When true, DEFAULT_AGENTS are skipped during registration. */
+let disableDefaults = false;
+
 /** When true, only extension-registered agents are used. Defaults and user .md files are skipped. */
 let extensionOnlyMode = false;
 
+/** Check whether default agents are disabled. */
+export function isDefaultsDisabled(): boolean { return disableDefaults; }
+
+/** Set whether default agents are disabled. */
+export function setDefaultsDisabled(b: boolean): void { disableDefaults = b; }
+
 /** Enable extension-only mode: skip defaults and user .md agents entirely. */
-export function setExtensionOnlyMode(enabled: boolean): void {
-  extensionOnlyMode = enabled;
-}
+export function setExtensionOnlyMode(enabled: boolean): void { extensionOnlyMode = enabled; }
 
 /**
  * Register agents into the unified registry.
@@ -57,9 +52,11 @@ export function registerAgents(userAgents: Map<string, AgentConfig>): void {
   agents.clear();
 
   if (!extensionOnlyMode) {
-    // Start with defaults
-    for (const [name, config] of DEFAULT_AGENTS) {
-      agents.set(name, config);
+    // Start with defaults (unless disabled via settings)
+    if (!disableDefaults) {
+      for (const [name, config] of DEFAULT_AGENTS) {
+        agents.set(name, config);
+      }
     }
 
     // Overlay user agents (overrides defaults with same name)
@@ -68,14 +65,14 @@ export function registerAgents(userAgents: Map<string, AgentConfig>): void {
     }
   }
 
-  // Overlay extension-injected agents (highest priority)
+  // Overlay extension-injected agents (highest priority, survive reloads)
   for (const [name, config] of extensionAgents) {
     agents.set(name, config);
   }
 }
 
 /**
- * Register agents from another extension (e.g. pi-pi).
+ * Register agents from another extension (e.g. pi-pi orchestrator).
  * These persist across reloadCustomAgents() calls and take highest priority.
  */
 export function registerExtensionAgents(newAgents: Map<string, AgentConfig>): void {
@@ -84,18 +81,14 @@ export function registerExtensionAgents(newAgents: Map<string, AgentConfig>): vo
   }
 }
 
-/**
- * Remove extension-registered agents by name.
- */
+/** Remove extension-registered agents by name. */
 export function unregisterExtensionAgents(names: string[]): void {
   for (const name of names) {
     extensionAgents.delete(name);
   }
 }
 
-/**
- * Remove extension-registered agents whose names start with a prefix.
- */
+/** Remove extension-registered agents whose names start with a prefix. */
 export function unregisterExtensionAgentsByPrefix(prefix: string): void {
   for (const name of extensionAgents.keys()) {
     if (name.startsWith(prefix)) {
@@ -104,9 +97,7 @@ export function unregisterExtensionAgentsByPrefix(prefix: string): void {
   }
 }
 
-/**
- * Remove all extension-registered agents.
- */
+/** Remove all extension-registered agents. */
 export function clearExtensionAgents(): void {
   extensionAgents.clear();
 }
@@ -169,35 +160,30 @@ export function isValidType(type: string): boolean {
 const MEMORY_TOOL_NAMES = ["read", "write", "edit"];
 
 /**
- * Get the tools needed for memory management (read, write, edit).
- * Only returns tools that are NOT already in the provided set.
+ * Get memory tool names (read/write/edit) not already in the provided set.
  */
-export function getMemoryTools(cwd: string, existingToolNames: Set<string>): AgentTool<any>[] {
-  return MEMORY_TOOL_NAMES
-    .filter(n => !existingToolNames.has(n) && n in TOOL_FACTORIES)
-    .map(n => TOOL_FACTORIES[n](cwd));
+export function getMemoryToolNames(existingToolNames: Set<string>): string[] {
+  return MEMORY_TOOL_NAMES.filter(n => !existingToolNames.has(n));
 }
 
 /** Tool names needed for read-only memory access. */
 const READONLY_MEMORY_TOOL_NAMES = ["read"];
 
 /**
- * Get only the read tool for read-only memory access.
- * Only returns tools that are NOT already in the provided set.
+ * Get read-only memory tool names not already in the provided set.
  */
-export function getReadOnlyMemoryTools(cwd: string, existingToolNames: Set<string>): AgentTool<any>[] {
-  return READONLY_MEMORY_TOOL_NAMES
-    .filter(n => !existingToolNames.has(n) && n in TOOL_FACTORIES)
-    .map(n => TOOL_FACTORIES[n](cwd));
+export function getReadOnlyMemoryToolNames(existingToolNames: Set<string>): string[] {
+  return READONLY_MEMORY_TOOL_NAMES.filter(n => !existingToolNames.has(n));
 }
 
-/** Get built-in tools for a type (case-insensitive). */
-export function getToolsForType(type: string, cwd: string): AgentTool<any>[] {
+/** Get built-in tool names for a type (case-insensitive). */
+export function getToolNamesForType(type: string): string[] {
   const key = resolveKey(type);
   const raw = key ? agents.get(key) : undefined;
   const config = raw?.enabled !== false ? raw : undefined;
-  const toolNames = config?.builtinToolNames?.length ? config.builtinToolNames : BUILTIN_TOOL_NAMES;
-  return toolNames.filter((n) => n in TOOL_FACTORIES).map((n) => TOOL_FACTORIES[n](cwd));
+  // `undefined` (definition omitted the field) → all built-ins; an explicit `[]`
+  // (`tools: none` or a `tools:` with only `ext:` entries) → zero built-ins.
+  return config?.builtinToolNames ?? [...BUILTIN_TOOL_NAMES];
 }
 
 /** Get config for a type (case-insensitive, returns a SubagentTypeConfig-compatible object). Falls back to general-purpose. */
@@ -206,6 +192,7 @@ export function getConfig(type: string): {
   description: string;
   builtinToolNames: string[];
   extensions: true | string[] | false;
+  excludeExtensions?: string[];
   skills: true | string[] | false;
   promptMode: "replace" | "append";
 } {
@@ -217,6 +204,7 @@ export function getConfig(type: string): {
       description: config.description,
       builtinToolNames: config.builtinToolNames ?? BUILTIN_TOOL_NAMES,
       extensions: config.extensions,
+      excludeExtensions: config.excludeExtensions,
       skills: config.skills,
       promptMode: config.promptMode,
     };
@@ -230,6 +218,7 @@ export function getConfig(type: string): {
       description: gp.description,
       builtinToolNames: gp.builtinToolNames ?? BUILTIN_TOOL_NAMES,
       extensions: gp.extensions,
+      excludeExtensions: gp.excludeExtensions,
       skills: gp.skills,
       promptMode: gp.promptMode,
     };

package/3p/pi-subagents/src/cross-extension-rpc.ts

@@ -9,6 +9,8 @@
  *   error   → { success: false, error: string }
  */
 
+import { type ModelRegistry, resolveModel } from "./model-resolver.js";
+
 /** Minimal event bus interface needed by the RPC handlers. */
 export interface EventBus {
   on(event: string, handler: (data: unknown) => void): () => void;
@@ -29,18 +31,10 @@ export interface SpawnCapable {
   abort(id: string): boolean;
 }
 
-export interface SpawnRequest {
-  requestId: string;
-  type: string;
-  prompt: string;
-  options?: any;
-}
-
 export interface RpcDeps {
   events: EventBus;
   pi: unknown;                    // passed through to manager.spawn
   getCtx: () => unknown | undefined;  // returns current ExtensionContext
-  isSubagentSession?: (ctx: unknown) => boolean;
   manager: SpawnCapable;
 }
 
@@ -50,10 +44,6 @@ export interface RpcHandle {
   unsubStop: () => void;
 }
 
-function emitReply(events: EventBus, channel: string, requestId: string, reply: RpcReply<unknown>): void {
-  events.emit(`${channel}:reply:${requestId}`, reply);
-}
-
 /**
  * Wire a single RPC handler: listen on `channel`, run `fn(params)`,
  * emit the reply envelope on `channel:reply:${requestId}`.
@@ -83,47 +73,63 @@ function handleRpc<P extends { requestId: string }>(
  * Returns unsub functions for cleanup.
  */
 export function registerRpcHandlers(deps: RpcDeps): RpcHandle {
-  const { events, pi, getCtx, isSubagentSession, manager } = deps;
+  const { events, pi, getCtx, manager } = deps;
 
   const unsubPing = handleRpc(events, "subagents:rpc:ping", () => {
     return { version: PROTOCOL_VERSION };
   });
 
-  const unsubSpawn = events.on("subagents:rpc:spawn", (raw: unknown) => {
-    const params = raw as SpawnRequest;
-    const ctx = getCtx();
-    if (!ctx) {
-      emitReply(events, "subagents:rpc:spawn", params.requestId, { success: false, error: "No active session" });
-      return;
-    }
-    if (isSubagentSession?.(ctx)) {
-      emitReply(events, "subagents:rpc:spawn", params.requestId, {
-        success: false,
-        error: "Cannot spawn subagents from a subagent session context",
-      });
-      return;
-    }
+  const unsubSpawn = handleRpc<{ requestId: string; type: string; prompt: string; options?: any }>(
+    events, "subagents:rpc:spawn", ({ type, prompt, options }) => {
+      const ctx = getCtx();
+      if (!ctx) throw new Error("No active session");
 
-    queueMicrotask(() => {
-      try {
-        const rawOpts = params.options ?? {};
-        const spawnOpts = { ...rawOpts, isBackground: rawOpts.isBackground ?? rawOpts.run_in_background ?? true };
-        const id = manager.spawn(pi, ctx, params.type, params.prompt, spawnOpts);
-        events.emit("subagents:created", {
-          id,
-          type: params.type,
-          description: params.options?.description ?? params.type,
-          isBackground: params.options?.run_in_background ?? true,
-        });
-        emitReply(events, "subagents:rpc:spawn", params.requestId, { success: true, data: { id } });
-      } catch (err: any) {
-        emitReply(events, "subagents:rpc:spawn", params.requestId, {
-          success: false,
-          error: err?.message ?? String(err),
-        });
+      // Cross-extension RPC callers (e.g. pi-tasks TaskExecute) naturally
+      // forward serializable values, so options.model can be a string like
+      // "openai-codex/gpt-5.5". Resolve it to a real Model instance here
+      // — same pattern the scheduler path already uses — so the spawned
+      // agent's auth lookup doesn't crash with "No API key found for
+      // undefined".
+      let normalizedOptions = options ?? {};
+      if (typeof normalizedOptions.model === "string") {
+        const registry = (ctx as { modelRegistry?: ModelRegistry }).modelRegistry;
+        if (!registry) {
+          throw new Error(
+            `Model override "${normalizedOptions.model}" provided but ctx.modelRegistry is unavailable`,
+          );
+        }
+        const resolved = resolveModel(normalizedOptions.model, registry);
+        if (typeof resolved === "string") {
+          // resolveModel returns a human-readable error string when the
+          // input doesn't match any available model. Surface it instead of
+          // silently falling back so the caller sees the auth/typo issue.
+          throw new Error(resolved);
+        }
+        normalizedOptions = { ...normalizedOptions, model: resolved };
       }
-    });
-  });
+
+      // Cross-extension RPC callers (e.g. pi-pi orchestrator planners/
+      // reviewers) forward `run_in_background`; map it to the manager's
+      // `isBackground` flag so background RPC spawns are queued/tracked and
+      // stay visible in the widget rather than being treated as foreground.
+      if (normalizedOptions.isBackground === undefined && normalizedOptions.run_in_background !== undefined) {
+        normalizedOptions = { ...normalizedOptions, isBackground: normalizedOptions.run_in_background };
+      }
+
+      const id = manager.spawn(pi, ctx, type, prompt, normalizedOptions);
+      // Announce the spawn so orchestrating extensions can wire the widget's
+      // UICtx and track the agent. RPC spawns happen outside an LLM turn, so
+      // without this event the above-editor widget never receives a UICtx and
+      // stays blank while orchestrator subagents run.
+      events.emit("subagents:created", {
+        id,
+        type,
+        description: normalizedOptions.description ?? type,
+        isBackground: normalizedOptions.isBackground ?? true,
+      });
+      return { id };
+    },
+  );
 
   const unsubStop = handleRpc<{ requestId: string; agentId: string }>(
     events, "subagents:rpc:stop", ({ agentId }) => {

package/3p/pi-subagents/src/custom-agents.ts

@@ -1,11 +1,10 @@
 /**
- * custom-agents.ts — Load user-defined agents from project (.pi/agents/) and global (~/.pi/agent/agents/) locations.
+ * custom-agents.ts — Load user-defined agents from project (.pi/agents/) and global ($PI_CODING_AGENT_DIR/agents/, default ~/.pi/agent/agents/) locations.
  */
 
 import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { basename, join } from "node:path";
-import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
+import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
 import { BUILTIN_TOOL_NAMES } from "./agent-types.js";
 import type { AgentConfig, MemoryScope, ThinkingLevel } from "./types.js";
 
@@ -13,13 +12,13 @@ import type { AgentConfig, MemoryScope, ThinkingLevel } from "./types.js";
  * Scan for custom agent .md files from multiple locations.
  * Discovery hierarchy (higher priority wins):
  *   1. Project: <cwd>/.pi/agents/*.md
- *   2. Global:  ~/.pi/agent/agents/*.md
+ *   2. Global:  $PI_CODING_AGENT_DIR/agents/*.md (default: ~/.pi/agent/agents/*.md)
  *
  * Project-level agents override global ones with the same name.
  * Any name is allowed — names matching defaults (e.g. "Explore") override them.
  */
 export function loadCustomAgents(cwd: string): Map<string, AgentConfig> {
-  const globalDir = join(homedir(), ".pi", "agent", "agents");
+  const globalDir = join(getAgentDir(), "agents");
   const projectDir = join(cwd, ".pi", "agents");
 
   const agents = new Map<string, AgentConfig>();
@@ -51,17 +50,23 @@ function loadFromDir(dir: string, agents: Map<string, AgentConfig>, source: "pro
 
     const { frontmatter: fm, body } = parseFrontmatter<Record<string, unknown>>(content);
 
+    const { builtinToolNames, extSelectors } = parseToolsField(fm.tools);
+
     agents.set(name, {
       name,
       displayName: str(fm.display_name),
       description: str(fm.description) ?? name,
-      builtinToolNames: csvList(fm.tools, BUILTIN_TOOL_NAMES),
+      builtinToolNames,
+      extSelectors,
       disallowedTools: csvListOptional(fm.disallowed_tools),
       extensions: inheritField(fm.extensions ?? fm.inherit_extensions),
+      excludeExtensions: csvListOptional(fm.exclude_extensions),
       skills: inheritField(fm.skills ?? fm.inherit_skills),
       model: str(fm.model),
       thinking: str(fm.thinking) as ThinkingLevel | undefined,
       maxTurns: nonNegativeInt(fm.max_turns),
+      persistSession: fm.persist_session != null ? fm.persist_session === true : undefined,
+      sessionDir: str(fm.session_dir),
       systemPrompt: body.trim(),
       promptMode: fm.prompt_mode === "append" ? "append" : "replace",
       inheritContext: fm.inherit_context != null ? fm.inherit_context === true : undefined,
@@ -108,6 +113,25 @@ function csvList(val: unknown, defaults: string[]): string[] {
   return parseCsvField(val) ?? [];
 }
 
+/**
+ * Partition the `tools:` CSV into the built-in tool allowlist and raw `ext:` selectors.
+ * `*` (and the case-insensitive alias `all`, for `tools: all`) expands to all
+ * built-ins; plain entries are built-in names; `ext:` entries are extension-tool
+ * selectors parsed later by the runner. omitted → all built-ins, no selectors.
+ * `tools:` present with only `ext:` entries → zero built-ins (use `*`).
+ */
+function parseToolsField(val: unknown): { builtinToolNames: string[]; extSelectors: string[] | undefined } {
+  const entries = csvList(val, BUILTIN_TOOL_NAMES);
+  const isWildcard = (e: string) => e === "*" || e.toLowerCase() === "all";
+  const hasWildcard = entries.some(isWildcard);
+  const plain = entries.filter(e => !isWildcard(e) && !e.startsWith("ext:"));
+  const extEntries = entries.filter(e => e.startsWith("ext:"));
+  return {
+    builtinToolNames: hasWildcard ? [...new Set([...BUILTIN_TOOL_NAMES, ...plain])] : plain,
+    extSelectors: extEntries.length > 0 ? extEntries : undefined,
+  };
+}
+
 /**
  * Parse an optional comma-separated list field.
  * omitted → undefined; "none"/empty → undefined; csv → listed items.

package/3p/pi-subagents/src/default-agents.ts

@@ -14,15 +14,14 @@ export const DEFAULT_AGENTS: Map<string, AgentConfig> = new Map([
     {
       name: "general-purpose",
       displayName: "Agent",
-      description: "General-purpose agent for complex, multi-step tasks",
+      description: "General-purpose agent for researching complex questions, searching for code, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you.",
       // builtinToolNames omitted — means "all available tools" (resolved at lookup time)
+      // inheritContext / runInBackground / isolated omitted — strategy fields, callers decide per-call.
+      // Setting them to false would lock callsite intent (see resolveAgentInvocationConfig in invocation-config.ts).
       extensions: true,
       skills: true,
       systemPrompt: "",
       promptMode: "append",
-      inheritContext: false,
-      runInBackground: false,
-      isolated: false,
       isDefault: true,
     },
   ],
@@ -31,11 +30,14 @@ export const DEFAULT_AGENTS: Map<string, AgentConfig> = new Map([
     {
       name: "Explore",
       displayName: "Explore",
-      description: "Fast codebase exploration agent (read-only)",
+      description: "Fast read-only search agent for locating code. Use it to find files by pattern (eg. \"src/components/**/*.tsx\"), grep for symbols or keywords (eg. \"API endpoints\"), or answer \"where is X defined / which files reference Y.\" Do NOT use it for code review, design-doc auditing, cross-file consistency checks, or open-ended analysis — it reads excerpts rather than whole files and will miss content past its read window. When calling, specify search breadth: \"quick\" for a single targeted lookup, \"medium\" for moderate exploration, or \"very thorough\" to search across multiple locations and naming conventions.",
       builtinToolNames: READ_ONLY_TOOLS,
       extensions: true,
       skills: true,
-      model: "anthropic/claude-haiku-4-5-20251001",
+      // Fast/cheap model for read-only search. Provider-preferred but resilient:
+      // resolveModel matches this fuzzily (date-stamp optional) and falls back to
+      // the same model under another provider if anthropic doesn't expose it.
+      model: "anthropic/claude-haiku-4-5",
       systemPrompt: `# CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS
 You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
 Your role is EXCLUSIVELY to search and analyze existing code. You do NOT have access to file editing tools.
@@ -49,32 +51,22 @@ You are STRICTLY PROHIBITED from:
 - Using redirect operators (>, >>, |) or heredocs to write to files
 - Running ANY commands that change system state
 
-# Tool routing — pick the right tool for the question
+Use Bash ONLY for read-only operations: ls, git status, git log, git diff, find, cat, head, tail.
 
-Discovery (don't know where to look):
-- cbm_search: natural-language search across all symbols (best first step)
-- cbm_search_code: graph-augmented grep — finds text, deduplicates into containing functions
-- grep: fast text/regex search for known strings
-
-Structural patterns (find code shapes, not names):
-- ast_search: AST-aware pattern matching (e.g. 'if err != nil { $$$ }', 'type $N interface { $$$ }')
-
-File navigation:
-- find: locate files by name/glob pattern
-- read: read file contents
-- ls: list directory contents
-
-Use Bash ONLY for read-only operations: git status, git log, git diff.
-Make independent tool calls in parallel for efficiency.
+# Tool Usage
+- Use the find tool for file pattern matching (NOT the bash find command)
+- Use the grep tool for content search (NOT bash grep/rg command)
+- Use the read tool for reading files (NOT bash cat/head/tail)
+- Use Bash ONLY for read-only operations
+- Make independent tool calls in parallel for efficiency
+- Adapt search approach based on thoroughness level specified
 
 # Output
 - Use absolute file paths in all references
+- Report findings as regular messages
 - Do not use emojis
 - Be thorough and precise`,
       promptMode: "replace",
-      inheritContext: false,
-      runInBackground: false,
-      isolated: false,
       isDefault: true,
     },
   ],
@@ -83,7 +75,7 @@ Make independent tool calls in parallel for efficiency.
     {
       name: "Plan",
       displayName: "Plan",
-      description: "Software architect for implementation planning (read-only)",
+      description: "Software architect agent for designing implementation plans. Use this when you need to plan the implementation strategy for a task. Returns step-by-step plans, identifies critical files, and considers architectural trade-offs.",
       builtinToolNames: READ_ONLY_TOOLS,
       extensions: true,
       skills: true,
@@ -101,22 +93,9 @@ You are STRICTLY PROHIBITED from:
 - Using redirect operators (>, >>, |) or heredocs to write to files
 - Running ANY commands that change system state
 
-# Tool routing — understand the codebase before planning
-
-Architecture overview:
-- cbm_search: natural-language search for relevant symbols
-- cbm_search_code: graph-augmented grep — deduplicates into containing functions
-
-Detailed understanding:
-- grep: fast text/regex search for known strings
-- read: read file contents
-- find: locate files by name/glob pattern
-
-Use Bash ONLY for read-only operations: git status, git log, git diff.
-
 # Planning Process
 1. Understand requirements
-2. Explore thoroughly (search for patterns, understand architecture)
+2. Explore thoroughly (read files, find patterns, understand architecture)
 3. Design solution based on your assigned perspective
 4. Detail the plan with step-by-step implementation strategy
 
@@ -126,6 +105,12 @@ Use Bash ONLY for read-only operations: git status, git log, git diff.
 - Anticipate potential challenges
 - Follow existing patterns where appropriate
 
+# Tool Usage
+- Use the find tool for file pattern matching (NOT the bash find command)
+- Use the grep tool for content search (NOT bash grep/rg command)
+- Use the read tool for reading files (NOT bash cat/head/tail)
+- Use Bash ONLY for read-only operations
+
 # Output Format
 - Use absolute file paths
 - Do not use emojis
@@ -135,9 +120,6 @@ Use Bash ONLY for read-only operations: git status, git log, git diff.
 List 3-5 files most critical for implementing this plan:
 - /absolute/path/to/file.ts - [Brief reason]`,
       promptMode: "replace",
-      inheritContext: false,
-      runInBackground: false,
-      isolated: false,
       isDefault: true,
     },
   ],