pi-subagents-lite 1.0.1 → 1.1.0

package/src/agent-runner.ts

@@ -369,219 +369,207 @@ async function detectEnv(pi: ExtensionAPI, cwd: string): Promise<EnvInfo> {
   };
 }
 
-export async function runAgent(
-  ctx: ExtensionContext,
-  type: SubagentType,
-  prompt: string,
-  options: RunOptions,
-): Promise<RunResult> {
-  const config = getConfig(type);
-  const agentConfig = getAgentConfig(type);
-
-  // Warn on mutual exclusion violations
-  const notify = (msg: string) => {
-    if (ctx.ui?.notify) {
-      ctx.ui.notify(`[pi-subagents] ${msg}`, "warning");
-    } else {
-      console.warn(`[pi-subagents] ${msg}`);
-    }
-  };
-  if (agentConfig?.excludeTools && Array.isArray(agentConfig.tools)) {
-    notify(`agent "${type}": both tools and exclude_tools set — tools (whitelist) wins`);
-  }
-  if (agentConfig?.excludeExtensions && Array.isArray(agentConfig.extensions)) {
-    notify(`agent "${type}": both extensions and exclude_extensions set — extensions (whitelist) wins`);
-  }
-
-  // Resolve working directory
-  const effectiveCwd = options.cwd ?? ctx.cwd;
-
-  const env = await detectEnv(options.pi, effectiveCwd);
-
-  // Resolve extensions/skills from agent config (frontmatter)
-  const extensions = config.extensions;
-  const skills = config.skills;
-  const preloadSkillsList = agentConfig?.preloadSkills;
+// ── runAgent phases ────────────────────────────────────────────────
 
-  // Build prompt extras (skills only).
+/**
+ * Phase 1: Resolve system prompt from agent config, skills, and env info.
+ */
+function buildPrompt(
+  type: SubagentType,
+  agentConfig: ReturnType<typeof getAgentConfig>,
+  config: ReturnType<typeof getConfig>,
+  cwd: string,
+  env: EnvInfo,
+): string {
   const extras: PromptExtras = {};
-  if (Array.isArray(preloadSkillsList)) {
-    extras.skillBlocks = preloadSkills(preloadSkillsList, effectiveCwd);
+  if (Array.isArray(agentConfig?.preloadSkills)) {
+    extras.skillBlocks = preloadSkills(agentConfig.preloadSkills, cwd);
   }
-  if (Array.isArray(skills)) {
-    extras.skillMetas = loadSkillMeta(skills, effectiveCwd);
+  if (Array.isArray(config.skills)) {
+    extras.skillMetas = loadSkillMeta(config.skills, cwd);
   }
-
-  const toolNames = getToolNamesForType(type);
-
-  // Build system prompt from agent config
-  let systemPrompt: string;
   if (agentConfig) {
-    systemPrompt = buildAgentPrompt(agentConfig, effectiveCwd, env, extras);
-  } else {
-    // Unknown type fallback: spread the canonical general-purpose config
-    const fallback = DEFAULT_AGENTS.get("general-purpose");
-    if (!fallback) throw new Error(`No fallback config available for unknown type "${type}"`);
-    systemPrompt = buildAgentPrompt({ ...fallback, name: type }, effectiveCwd, env, extras);
+    return buildAgentPrompt(agentConfig, cwd, env, extras);
   }
+  const fallback = DEFAULT_AGENTS.get("general-purpose");
+  if (!fallback) throw new Error(`No fallback config available for unknown type "${type}"`);
+  return buildAgentPrompt({ ...fallback, name: type }, cwd, env, extras);
+}
 
-  // Skip the built-in skill loader when:
-  // - skills is false (no skills)
-  // - preloadSkills is string[] (we handle preloading ourselves)
-  // - skills is string[] (we handle metadata ourselves)
-  const skipSkillLoader = skills === false || Array.isArray(skills) || Array.isArray(preloadSkillsList);
-
-  const agentDir = getAgentDir();
+/** Build extension name → tool names map from loaded extensions. */
+function buildExtToolMap(extensions: Array<{ path: string; tools: Map<string, unknown> }>) {
+  const map = new Map<string, string[]>();
+  for (const ext of extensions) {
+    const name = extractExtensionName(ext.path);
+    const tools = [...ext.tools.keys()];
+    if (tools.length > 0) map.set(name, tools);
+  }
+  return map;
+}
 
-  // Load extensions/skills: true or string[] → load; false → don't.
-  // When extensions is an array, use extensionsOverride to selectively load
-  // only the listed extensions (hooks/commands of excluded ones never fire).
-  // When excludeExtensions is set (and extensions is not string[]), filter out those extensions.
-  const loaderOpts: ConstructorParameters<typeof DefaultResourceLoader>[0] = {
-    cwd: effectiveCwd,
-    agentDir,
-    noExtensions: extensions === false,
-    noSkills: skipSkillLoader,
-    noPromptTemplates: true,
-    noThemes: true,
-    noContextFiles: true,
-    systemPromptOverride: () => systemPrompt,
-    appendSystemPromptOverride: () => [],
-  };
-  const excludeExtSet = agentConfig?.excludeExtensions
-    ? new Set(agentConfig.excludeExtensions)
-    : undefined;
+/** Build extension override for whitelist or blacklist filtering. */
+function buildExtOverride(
+  extensions: true | string[] | false | undefined,
+  excludeExtensions?: string[],
+) {
   if (Array.isArray(extensions)) {
-    // Whitelist mode: only load listed extensions
     const allowedNames = new Set(extensions.map(ext => {
       const slashIdx = ext.indexOf("/");
       return slashIdx !== -1 ? ext.slice(0, slashIdx) : ext;
     }));
-    loaderOpts.extensionsOverride = (result) => ({
+    return (result: any) => ({
       ...result,
-      extensions: result.extensions.filter(ext =>
+      extensions: result.extensions.filter((ext: { path: string }) =>
         allowedNames.has(extractExtensionName(ext.path)),
       ),
     });
-  } else if (excludeExtSet) {
-    // Blacklist mode: load all except excluded extensions
-    loaderOpts.extensionsOverride = (result) => ({
+  }
+  if (excludeExtensions) {
+    const excludeSet = new Set(excludeExtensions);
+    return (result: any) => ({
       ...result,
-      extensions: result.extensions.filter(ext =>
-        !excludeExtSet.has(extractExtensionName(ext.path)),
+      extensions: result.extensions.filter((ext: { path: string }) =>
+        !excludeSet.has(extractExtensionName(ext.path)),
       ),
     });
   }
-  const loader = new DefaultResourceLoader(loaderOpts);
-  await loader.reload();
+  return undefined;
+}
 
-  // Build extension name → tool names map from loaded extensions.
-  // Used by filterActiveTools to resolve extension names in the extensions frontmatter field.
-  const extResult = loader.getExtensions();
-  const extToolMap = new Map<string, string[]>();
-  for (const ext of extResult.extensions) {
-    const name = extractExtensionName(ext.path);
-    const tools = [...ext.tools.keys()];
-    if (tools.length > 0) extToolMap.set(name, tools);
-  }
+/**
+ * Phase 2: Build DefaultResourceLoader with extension filtering.
+ * Returns the loader and a function that reloads it and builds the ext→tool map.
+ */
+function createResourceLoader(
+  config: ReturnType<typeof getConfig>,
+  agentConfig: ReturnType<typeof getAgentConfig>,
+  cwd: string,
+  systemPrompt: string,
+) {
+  const extensions = config.extensions;
+  const noSkills = config.skills === false
+    || Array.isArray(config.skills)
+    || Array.isArray(agentConfig?.preloadSkills);
+  const agentDir = getAgentDir();
+  const loaderOpts: ConstructorParameters<typeof DefaultResourceLoader>[0] = {
+    cwd, agentDir,
+    noExtensions: extensions === false, noSkills,
+    noPromptTemplates: true, noThemes: true, noContextFiles: true,
+    systemPromptOverride: () => systemPrompt,
+    appendSystemPromptOverride: () => [],
+    extensionsOverride: buildExtOverride(extensions, agentConfig?.excludeExtensions),
+  };
+  const loader = new DefaultResourceLoader(loaderOpts);
+  return {
+    loader,
+    reloadAndMap: async () => {
+      await loader.reload();
+      const extResult = loader.getExtensions();
+      return { extResult, extToolMap: buildExtToolMap(extResult.extensions) };
+    },
+  };
+}
 
-  // Resolve model: explicit option > config.model > parent model
+/** Create an agent session with the resolved model and thinking level. */
+async function initSession(
+  ctx: ExtensionContext,
+  options: RunOptions,
+  agentConfig: ReturnType<typeof getAgentConfig>,
+  type: SubagentType,
+  cwd: string,
+  loader: DefaultResourceLoader,
+) {
   const model = options.model ?? findModelInRegistry(
     agentConfig?.model, ctx.modelRegistry, ctx.model,
   );
-
-  // Resolve thinking level: explicit option > agent config > undefined (inherit)
   const thinkingLevel = options.thinkingLevel ?? agentConfig?.thinking;
-
+  const agentDir = getAgentDir();
   const sessionOpts: Parameters<typeof createAgentSession>[0] = {
-    cwd: effectiveCwd,
-    agentDir,
-    sessionManager: SessionManager.inMemory(effectiveCwd),
-    settingsManager: SettingsManager.create(effectiveCwd, agentDir),
-    modelRegistry: ctx.modelRegistry,
-    model,
-    tools: toolNames,
-    resourceLoader: loader,
+    cwd, agentDir,
+    sessionManager: SessionManager.inMemory(cwd),
+    settingsManager: SettingsManager.create(cwd, agentDir),
+    modelRegistry: ctx.modelRegistry, model,
+    tools: getToolNamesForType(type), resourceLoader: loader,
   };
-  if (thinkingLevel) {
-    sessionOpts.thinkingLevel = thinkingLevel;
-  }
-
-  const { session } = await createAgentSession(sessionOpts);
+  if (thinkingLevel) sessionOpts.thinkingLevel = thinkingLevel;
+  return createAgentSession(sessionOpts);
+}
 
-  const baseSessionName = agentConfig?.name ?? type;
+/**
+ * Phase 3: Create session, bind extensions, filter tools.
+ */
+async function createAndConfigureSession(
+  ctx: ExtensionContext,
+  options: RunOptions,
+  agentConfig: ReturnType<typeof getAgentConfig>,
+  type: SubagentType,
+  cwd: string,
+  loader: DefaultResourceLoader,
+  extResult: { extensions: Array<{ path: string; tools: Map<string, unknown> }> },
+  notify: (msg: string) => void,
+): Promise<AgentSession> {
+  const { session } = await initSession(ctx, options, agentConfig, type, cwd, loader);
+  const baseName = agentConfig?.name ?? type;
   session.setSessionName(
-    options.agentId ? `${baseSessionName}#${options.agentId.slice(0, SHORT_ID_LENGTH)}` : baseSessionName,
+    options.agentId ? `${baseName}#${options.agentId.slice(0, SHORT_ID_LENGTH)}` : baseName,
   );
-
-  // Bind extensions so that session_start fires and extensions can initialize
-  // This must happen BEFORE tool filtering — extensions like pi-mcp-adapter
-  // register tools lazily during session_start, not at extension load time.
   await session.bindExtensions({
-    onError: (err) => {
-      options.onToolActivity?.({
-        type: "end",
-        toolName: `extension-error:${err.extensionPath}`,
-      });
-    },
+    onError: (err) => options.onToolActivity?.({
+      type: "end", toolName: `extension-error:${err.extensionPath}`,
+    }),
   });
-
-  // Rebuild extToolMap after session_start — extensions may have registered
-  // new tools (e.g., pi-mcp-adapter registers 'mcp' tool at session_start).
-  const postBindExtToolMap = new Map<string, string[]>();
-  for (const ext of extResult.extensions) {
-    const name = extractExtensionName(ext.path);
-    const tools = [...ext.tools.keys()];
-    if (tools.length > 0) postBindExtToolMap.set(name, tools);
-  }
-
-  // Filter active tools: apply tools allowlist/denylist and EXCLUDED_TOOL_NAMES
   const filteredTools = filterActiveTools(
-    session.getActiveToolNames(),
-    postBindExtToolMap,
-    agentConfig?.tools,
-    agentConfig?.excludeTools,
-    (msg) => {
-      if (ctx.ui?.notify) {
-        ctx.ui.notify(`[pi-subagents] ${msg}`, "warning");
-      } else {
-        console.warn(`[pi-subagents] ${msg}`);
-      }
-    },
+    session.getActiveToolNames(), buildExtToolMap(extResult.extensions),
+    agentConfig?.tools, agentConfig?.excludeTools, notify,
   );
-  if (filteredTools) {
-    session.setActiveToolsByName(filteredTools);
-  }
-
+  if (filteredTools) session.setActiveToolsByName(filteredTools);
   options.onSessionCreated?.(session);
+  return session;
+}
 
-  // Track turns for graceful max_turns enforcement
+/**
+ * Phase 4: Subscribe to turn_end events for graceful max_turns enforcement.
+ * Returns an unsubscribe function and state getters.
+ */
+function wireTurnTracking(
+  session: AgentSession,
+  options: Pick<RunOptions, "maxTurns" | "graceTurns" | "onTurnEnd">,
+) {
   let turnCount = 0;
-  const maxTurns = normalizeMaxTurns(options.maxTurns ?? agentConfig?.maxTurns);
+  const maxTurns = normalizeMaxTurns(options.maxTurns);
   let softLimitReached = false;
   let aborted = false;
   const graceTurns = options.graceTurns ?? DEFAULT_GRACE_TURNS;
 
-  const unsubEvents = subscribeToSessionEvents(session, options);
-
-  const unsubTurns = session.subscribe((event: AgentSessionEvent) => {
-    if (event.type === "turn_end") {
-      turnCount++;
-      options.onTurnEnd?.(turnCount);
-      if (maxTurns == null) return;
-      if (!softLimitReached && turnCount >= maxTurns) {
-        softLimitReached = true;
-        session.steer("You have reached your turn limit. Wrap up immediately — provide your final answer now.");
-      } else if (softLimitReached && turnCount >= maxTurns + graceTurns) {
-        aborted = true;
-        session.abort();
-      }
+  const unsubscribe = session.subscribe((event: AgentSessionEvent) => {
+    if (event.type !== "turn_end") return;
+    turnCount++;
+    options.onTurnEnd?.(turnCount);
+    if (maxTurns == null) return;
+    if (!softLimitReached && turnCount >= maxTurns) {
+      softLimitReached = true;
+      session.steer("You have reached your turn limit. Wrap up immediately — provide your final answer now.");
+    } else if (softLimitReached && turnCount >= maxTurns + graceTurns) {
+      aborted = true;
+      session.abort();
     }
   });
 
+  return { unsubscribe, getAborted: () => aborted, getSteered: () => softLimitReached };
+}
+
+/**
+ * Phase 5: Execute the prompt turn loop with event wiring and cleanup.
+ */
+async function runTurnLoop(
+  session: AgentSession,
+  prompt: string,
+  options: RunOptions,
+  unsubTurns: () => void,
+) {
+  const unsubEvents = subscribeToSessionEvents(session, options);
   const collector = collectResponseText(session, options.onTextDelta);
   const cleanupAbort = forwardAbortSignal(session, options.signal);
-
   try {
     await session.prompt(prompt);
   } finally {
@@ -590,7 +578,46 @@ export async function runAgent(
     collector.unsubscribe();
     cleanupAbort();
   }
+  return collector.getText().trim() || getLastAssistantText(session);
+}
+
+// ── main entry ─────────────────────────────────────────────────────
+
+export async function runAgent(
+  ctx: ExtensionContext,
+  type: SubagentType,
+  prompt: string,
+  options: RunOptions,
+): Promise<RunResult> {
+  const config = getConfig(type);
+  const agentConfig = getAgentConfig(type);
+
+  // Warn on mutual exclusion violations
+  const notify = (msg: string) => {
+    if (ctx.ui?.notify) ctx.ui.notify(`[pi-subagents] ${msg}`, "warning");
+    else console.warn(`[pi-subagents] ${msg}`);
+  };
+  if (agentConfig?.excludeTools && Array.isArray(agentConfig.tools)) {
+    notify(`agent "${type}": both tools and exclude_tools set — tools (whitelist) wins`);
+  }
+  if (agentConfig?.excludeExtensions && Array.isArray(agentConfig.extensions)) {
+    notify(`agent "${type}": both extensions and exclude_extensions set — extensions (whitelist) wins`);
+  }
+
+  const effectiveCwd = options.cwd ?? ctx.cwd;
+  const env = await detectEnv(options.pi, effectiveCwd);
+
+  const systemPrompt = buildPrompt(type, agentConfig, config, effectiveCwd, env);
+  const { loader, reloadAndMap } = createResourceLoader(config, agentConfig, effectiveCwd, systemPrompt);
+  const { extResult } = await reloadAndMap();
+  const session = await createAndConfigureSession(
+    ctx, options, agentConfig, type, effectiveCwd, loader, extResult, notify,
+  );
+  const { unsubscribe: unsubTurns, getAborted, getSteered } = wireTurnTracking(session, {
+    ...options,
+    maxTurns: options.maxTurns ?? agentConfig?.maxTurns,
+  });
 
-  const responseText = collector.getText().trim() || getLastAssistantText(session);
-  return { responseText, session, aborted, steered: softLimitReached };
+  const responseText = await runTurnLoop(session, prompt, options, unsubTurns);
+  return { responseText, session, aborted: getAborted(), steered: getSteered() };
 }

package/src/agent-types.ts

@@ -17,7 +17,7 @@ import type { AgentConfig } from "./types.js";
  * `find` and `ls` were removed — they're thin wrappers over bash commands
  * that add ~180 tokens/turn with no real benefit.
  */
-export const BUILTIN_TOOL_NAMES: string[] = ["read", "bash", "edit", "write", "grep"];
+export const BUILTIN_TOOL_NAMES: string[] = ["read", "bash", "edit", "write", "grep", "find"];
 
 /** Unified runtime registry of all agents (defaults + user-defined). */
 const agents = new Map<string, AgentConfig>();

package/src/config-io.ts

@@ -14,7 +14,15 @@ const CONFIG_PATH = path.join(CONFIG_DIR, "subagents-lite.json");
 
 /** Default configuration — used when config file doesn't exist or is invalid. */
 export const DEFAULT_CONFIG: SubagentsConfig = {
-  agent: { default: null, forceBackground: false, graceTurns: 6 },
+  agent: {
+    default: null,
+    forceBackground: false,
+    graceTurns: 6,
+    widgetMaxLines: 12,
+    // widgetMaxLinesCompact intentionally omitted — derives from widgetMaxLines
+    widgetCompact: false,
+    widgetShortcut: false,
+  },
   concurrency: { default: 4 },
 };
 

package/src/config-mutator.ts

@@ -0,0 +1,183 @@
+/**
+ * config-mutator.ts — Typed setters for all __config mutations.
+ *
+ * Every setter saves (saveConfigAtomic) and syncs internally.
+ * menus.ts calls setters instead of directly mutating __config.
+ *
+ * Sync responsibilities:
+ *   - Widget settings (compact, maxLines, shortcut) → syncWidgetSettings
+ *   - Cost display → setShowCostEnabled (syncs to widget)
+ *   - Agent bulk replace → syncWidgetSettings
+ *   - Concurrency → getManager().setConcurrency()
+ *   - All others → saveConfigAtomic only
+ */
+
+import {
+  __config,
+  getManager,
+  setShowCostEnabled,
+  syncWidgetSettings,
+} from "./state.js";
+import { saveConfigAtomic, DEFAULT_CONFIG } from "./config-io.js";
+import { CONFIG_AGENT_NON_MODEL_KEYS } from "./types.js";
+
+// ============================================================================
+// Local helpers
+// ============================================================================
+
+/**
+ * Persist concurrency config to disk and apply to the running manager.
+ * Defined locally so concurrency setters don't double-save.
+ */
+function applyConcurrencyConfig(): void {
+  saveConfigAtomic(__config);
+  getManager()?.setConcurrency(__config.concurrency);
+}
+
+// ============================================================================
+// Model override setters
+// ============================================================================
+
+/** Set or update a model override for a type (or "default" for global). */
+export function setModelOverride(type: string, value: string | null): void {
+  __config.agent[type] = value;
+  saveConfigAtomic(__config);
+}
+
+/** Set the global default model. */
+export function setDefaultModel(value: string | null): void {
+  __config.agent.default = value;
+  saveConfigAtomic(__config);
+}
+
+/** Clear a single per-type model override. */
+export function clearModelOverride(type: string): void {
+  delete __config.agent[type];
+  saveConfigAtomic(__config);
+}
+
+/** Clear all model overrides, preserving non-model settings. */
+export function clearAllModelOverrides(): void {
+  const preserved: Record<string, unknown> = {};
+  for (const key of CONFIG_AGENT_NON_MODEL_KEYS) {
+    const val = __config.agent[key];
+    if (val != null || key === "default" || key === "forceBackground") {
+      preserved[key] = val;
+    }
+  }
+  __config.agent = preserved as typeof __config.agent;
+  saveConfigAtomic(__config);
+  syncWidgetSettings();
+}
+
+// ============================================================================
+// Simple agent settings
+// ============================================================================
+
+/** Toggle force-background mode. */
+export function setForceBackground(enabled: boolean): void {
+  __config.agent.forceBackground = enabled;
+  saveConfigAtomic(__config);
+}
+
+/** Set the cost display toggle (syncs to widget via setShowCostEnabled). */
+export function setShowCost(enabled: boolean): void {
+  setShowCostEnabled(enabled);
+  saveConfigAtomic(__config);
+}
+
+/** Set grace turns (number of turns after timeout before hard kill). */
+export function setGraceTurns(n: number): void {
+  __config.agent.graceTurns = n;
+  saveConfigAtomic(__config);
+}
+
+// ============================================================================
+// Widget settings (sync via syncWidgetSettings)
+// ============================================================================
+
+/** Toggle force-compact widget mode. */
+export function setWidgetCompact(enabled: boolean): void {
+  __config.agent.widgetCompact = enabled;
+  saveConfigAtomic(__config);
+  syncWidgetSettings();
+}
+
+/**
+ * Set max lines for full widget mode.
+ * Auto-derives widgetMaxLinesCompact if not explicitly set.
+ */
+export function setWidgetMaxLines(lines: number): void {
+  __config.agent.widgetMaxLines = lines;
+  if (__config.agent.widgetMaxLinesCompact === undefined) {
+    __config.agent.widgetMaxLinesCompact = Math.floor(lines / 2);
+  }
+  saveConfigAtomic(__config);
+  syncWidgetSettings();
+}
+
+/** Set max lines for compact widget mode. */
+export function setWidgetMaxLinesCompact(lines: number): void {
+  __config.agent.widgetMaxLinesCompact = lines;
+  saveConfigAtomic(__config);
+  syncWidgetSettings();
+}
+
+/** Toggle ctrl+o widget shortcut. */
+export function setWidgetShortcut(enabled: boolean): void {
+  __config.agent.widgetShortcut = enabled;
+  saveConfigAtomic(__config);
+}
+
+/** Replace the entire agent config object (used by "clear all overrides"). */
+export function setAgent(agent: typeof __config.agent): void {
+  __config.agent = agent;
+  saveConfigAtomic(__config);
+  syncWidgetSettings();
+}
+
+// ============================================================================
+// Concurrency setters (save + sync via getManager().setConcurrency)
+// ============================================================================
+
+/** Set the global concurrency default. */
+export function setConcurrencyDefault(n: number): void {
+  __config.concurrency.default = n;
+  applyConcurrencyConfig();
+}
+
+/** Set or update a per-provider concurrency limit. */
+export function setConcurrencyProvider(key: string, n: number): void {
+  const current = __config.concurrency.providers ?? {};
+  __config.concurrency.providers = { ...current, [key]: n };
+  applyConcurrencyConfig();
+}
+
+/** Set or update a per-model concurrency limit. */
+export function setConcurrencyModel(key: string, n: number): void {
+  const current = __config.concurrency.models ?? {};
+  __config.concurrency.models = { ...current, [key]: n };
+  applyConcurrencyConfig();
+}
+
+/** Remove a per-provider concurrency limit. */
+export function removeConcurrencyProvider(key: string): void {
+  if (__config.concurrency.providers) {
+    delete __config.concurrency.providers[key];
+  }
+  applyConcurrencyConfig();
+}
+
+/** Remove a per-model concurrency limit. */
+export function removeConcurrencyModel(key: string): void {
+  if (__config.concurrency.models) {
+    delete __config.concurrency.models[key];
+  }
+  applyConcurrencyConfig();
+}
+
+/** Reset all concurrency settings to defaults. */
+export function resetConcurrency(): void {
+  __config.concurrency = { ...DEFAULT_CONFIG.concurrency };
+  applyConcurrencyConfig();
+}

package/src/context.ts

@@ -5,7 +5,7 @@
  * buildSnapshotMarkdown: format agent conversation as markdown for snapshot viewer.
  */
 
-import { summarizeToolArgs } from "./output-file.js";
+import { summarizeToolArgs } from "./format.js";
 
 function isTextBlock(c: unknown): c is { type: "text"; text: string } {
   return typeof c === "object" && c !== null && (c as Record<string, unknown>).type === "text";

package/src/default-agents.ts

@@ -7,7 +7,7 @@
 
 import type { AgentConfig } from "./types.js";
 
-const READ_ONLY_TOOLS = ["read", "bash", "grep"];
+const READ_ONLY_TOOLS = ["read", "bash", "grep", "find"];
 
 export const DEFAULT_AGENTS: Map<string, AgentConfig> = new Map([
   [