@tintinweb/pi-subagents 0.4.10 → 0.5.0

package/CHANGELOG.md

@@ -5,17 +5,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.4.10] - 2026-03-18
+## [Unreleased]
 
-### Changed
-- **Default max turns is now unlimited** — subagents no longer have a 50-turn default cap. The default is unlimited (no turn limit), matching Claude Code's main loop behavior. Users can still set explicit limits per-agent via `max_turns` frontmatter or the Agent tool parameter, or globally via `/agents` → Settings (`0` = unlimited).
-- **Live turn counter** — all agents now show a live turn count in the widget, inline result, and completion notification. With a turn limit: `⟳5≤30` (5 of 30 turns). Without: `⟳5`. Updates in real time as turns progress.
+## [0.5.0] - 2026-03-22
 
 ### Added
+- **RPC stop handler** — new `subagents:rpc:stop` event bus RPC allows other extensions to stop running subagents by agent ID. Returns structured error ("Agent not found") on failure.
+- **`abort` in `SpawnCapable` interface** — cross-extension RPC consumers can now stop agents, not just spawn them.
+- **Live turn counter** — all agents now show a live turn count in the widget, inline result, and completion notification. With a turn limit: `⟳5≤30` (5 of 30 turns). Without: `⟳5`. Updates in real time as turns progress via `onTurnEnd` callback.
 - **Biome linting** — added [Biome](https://biomejs.dev/) for correctness linting (unused imports, suspicious patterns). Style rules disabled. Run `npm run lint` to check, `npm run lint:fix` to auto-fix.
 - **CI workflow** — GitHub Actions runs lint, typecheck, and tests on push to master and PRs.
+- **Auto-trigger parent turn on background completion** — background agent completion notifications now use `triggerTurn: true`, automatically prompting the parent agent to process results instead of waiting for user input.
+
+### Changed
+- **Standardized RPC envelope** — cross-extension RPC handlers (`ping`, `spawn`, `stop`) now use a `handleRpc` wrapper that emits structured envelopes (`{ success: true, data }` / `{ success: false, error }`), matching pi-mono's `RpcResponse` convention.
+- **Protocol versioning via ping** — ping reply now includes `{ version: PROTOCOL_VERSION }` (currently v2). Callers can detect version mismatches and warn users to update.
+- **Default max turns is now unlimited** — subagents no longer have a 50-turn default cap. The default is unlimited (no turn limit), matching Claude Code's main loop behavior. Users can still set explicit limits per-agent via `max_turns` frontmatter or the Agent tool parameter, or globally via `/agents` → Settings (`0` = unlimited).
+- **Stale dist in published package** — added `prepublishOnly` hook to build fresh `dist/` on every `npm publish`.
 
 ### Fixed
+- **Tool name display** — `getAgentConversation` now reads `ToolCall.name` (the correct property) instead of `toolName`, resolving `[Tool: unknown]` in conversation viewer and verbose output.
 - **Env test CI failure** — `detectEnv` test assumed a branch name exists, but CI checks out detached HEAD. Split into separate tests for repo detection and branch detection with a controlled temp repo.
 
 ## [0.4.9] - 2026-03-18
@@ -320,6 +329,7 @@ Initial release.
 - **Thinking level** — per-agent extended thinking control
 - **`/agent` and `/agents` commands**
 
+[0.5.0]: https://github.com/tintinweb/pi-subagents/compare/v0.4.9...v0.5.0
 [0.4.9]: https://github.com/tintinweb/pi-subagents/compare/v0.4.8...v0.4.9
 [0.4.8]: https://github.com/tintinweb/pi-subagents/compare/v0.4.7...v0.4.8
 [0.4.7]: https://github.com/tintinweb/pi-subagents/compare/v0.4.6...v0.4.7

package/README.md

@@ -29,7 +29,7 @@ https://github.com/user-attachments/assets/8685261b-9338-4fea-8dfe-1c590d5df543
 - **Tool denylist** — block specific tools via `disallowed_tools` frontmatter
 - **Styled completion notifications** — background agent results render as themed, compact notification boxes (icon, stats, result preview) instead of raw XML. Expandable to show full output. Group completions render each agent individually
 - **Event bus** — lifecycle events (`subagents:created`, `started`, `completed`, `failed`, `steered`) emitted via `pi.events`, enabling other extensions to react to sub-agent activity
-- **Cross-extension RPC** — other pi extensions can spawn subagents via the `pi.events` event bus (`subagents:rpc:ping`, `subagents:rpc:spawn`). Emits `subagents:ready` on load
+- **Cross-extension RPC** — other pi extensions can spawn and stop subagents via the `pi.events` event bus (`subagents:rpc:ping`, `subagents:rpc:spawn`, `subagents:rpc:stop`). Standardized reply envelopes with protocol versioning. Emits `subagents:ready` on load
 
 ## Install
 
@@ -289,7 +289,9 @@ Agent lifecycle events are emitted via `pi.events.emit()` so other extensions ca
 
 ## Cross-Extension RPC
 
-Other pi extensions can spawn subagents programmatically via the `pi.events` event bus, without importing this package directly.
+Other pi extensions can spawn and stop subagents programmatically via the `pi.events` event bus, without importing this package directly.
+
+All RPC replies use a standardized envelope: `{ success: true, data?: T }` on success, `{ success: false, error: string }` on failure.
 
 ### Discovery
 
@@ -297,19 +299,19 @@ Listen for `subagents:ready` to know when RPC handlers are available:
 
 ```typescript
 pi.events.on("subagents:ready", () => {
-  // RPC handlers are registered — safe to call ping/spawn
+  // RPC handlers are registered — safe to call ping/spawn/stop
 });
 ```
 
 ### Ping
 
-Check if the subagents extension is loaded:
+Check if the subagents extension is loaded and get the protocol version:
 
 ```typescript
 const requestId = crypto.randomUUID();
-const unsub = pi.events.on(`subagents:rpc:ping:reply:${requestId}`, () => {
+const unsub = pi.events.on(`subagents:rpc:ping:reply:${requestId}`, (reply) => {
   unsub();
-  // Extension is alive
+  if (reply.success) console.log("Protocol version:", reply.data.version);
 });
 pi.events.emit("subagents:rpc:ping", { requestId });
 ```
@@ -322,10 +324,10 @@ Spawn a subagent and receive its ID:
 const requestId = crypto.randomUUID();
 const unsub = pi.events.on(`subagents:rpc:spawn:reply:${requestId}`, (reply) => {
   unsub();
-  if (reply.error) {
+  if (!reply.success) {
     console.error("Spawn failed:", reply.error);
   } else {
-    console.log("Agent ID:", reply.id);
+    console.log("Agent ID:", reply.data.id);
   }
 });
 pi.events.emit("subagents:rpc:spawn", {
@@ -336,6 +338,19 @@ pi.events.emit("subagents:rpc:spawn", {
 });
 ```
 
+### Stop
+
+Stop a running agent by ID:
+
+```typescript
+const requestId = crypto.randomUUID();
+const unsub = pi.events.on(`subagents:rpc:stop:reply:${requestId}`, (reply) => {
+  unsub();
+  if (!reply.success) console.error("Stop failed:", reply.error);
+});
+pi.events.emit("subagents:rpc:stop", { requestId, agentId: "agent-id-here" });
+```
+
 Reply channels are scoped per `requestId`, so concurrent requests don't interfere.
 
 ## Persistent Agent Memory

package/dist/agent-manager.d.ts

@@ -5,12 +5,12 @@
  * Excess agents are queued and auto-started as running agents complete.
  * Foreground agents bypass the queue (they block the parent anyway).
  */
-import type { ExtensionContext, ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import type { Model } from "@mariozechner/pi-ai";
-import type { AgentSession } from "@mariozechner/pi-coding-agent";
+import type { AgentSession, ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { type ToolActivity } from "./agent-runner.js";
-import type { SubagentType, AgentRecord, ThinkingLevel } from "./types.js";
+import type { AgentRecord, IsolationMode, SubagentType, ThinkingLevel } from "./types.js";
 export type OnAgentComplete = (record: AgentRecord) => void;
+export type OnAgentStart = (record: AgentRecord) => void;
 interface SpawnOptions {
     description: string;
     model?: Model<any>;
@@ -19,23 +19,28 @@ interface SpawnOptions {
     inheritContext?: boolean;
     thinkingLevel?: ThinkingLevel;
     isBackground?: boolean;
+    /** Isolation mode — "worktree" creates a temp git worktree for the agent. */
+    isolation?: IsolationMode;
     /** Called on tool start/end with activity info (for streaming progress to UI). */
     onToolActivity?: (activity: ToolActivity) => void;
     /** Called on streaming text deltas from the assistant response. */
     onTextDelta?: (delta: string, fullText: string) => void;
     /** Called when the agent session is created (for accessing session stats). */
     onSessionCreated?: (session: AgentSession) => void;
+    /** Called at the end of each agentic turn with the cumulative count. */
+    onTurnEnd?: (turnCount: number) => void;
 }
 export declare class AgentManager {
     private agents;
     private cleanupInterval;
     private onComplete?;
+    private onStart?;
     private maxConcurrent;
     /** Queue of background agents waiting to start. */
     private queue;
     /** Number of currently running background agents. */
     private runningBackground;
-    constructor(onComplete?: OnAgentComplete, maxConcurrent?: number);
+    constructor(onComplete?: OnAgentComplete, maxConcurrent?: number, onStart?: OnAgentStart);
     /** Update the max concurrent background agents limit. */
     setMaxConcurrent(n: number): void;
     getMaxConcurrent(): number;
@@ -60,9 +65,18 @@ export declare class AgentManager {
     getRecord(id: string): AgentRecord | undefined;
     listAgents(): AgentRecord[];
     abort(id: string): boolean;
+    /** Dispose a record's session and remove it from the map. */
+    private removeRecord;
     private cleanup;
+    /**
+     * Remove all completed/stopped/errored records immediately.
+     * Called on session start/switch so tasks from a prior session don't persist.
+     */
+    clearCompleted(): void;
     /** Whether any agents are still running or queued. */
     hasRunning(): boolean;
+    /** Abort all running and queued agents immediately. */
+    abortAll(): number;
     /** Wait for all running and queued agents to complete (including queued ones). */
     waitForAll(): Promise<void>;
     dispose(): void;

package/dist/agent-manager.js

@@ -6,20 +6,23 @@
  * Foreground agents bypass the queue (they block the parent anyway).
  */
 import { randomUUID } from "node:crypto";
-import { runAgent, resumeAgent } from "./agent-runner.js";
+import { resumeAgent, runAgent } from "./agent-runner.js";
+import { cleanupWorktree, createWorktree, pruneWorktrees, } from "./worktree.js";
 /** Default max concurrent background agents. */
 const DEFAULT_MAX_CONCURRENT = 4;
 export class AgentManager {
     agents = new Map();
     cleanupInterval;
     onComplete;
+    onStart;
     maxConcurrent;
     /** Queue of background agents waiting to start. */
     queue = [];
     /** Number of currently running background agents. */
     runningBackground = 0;
-    constructor(onComplete, maxConcurrent = DEFAULT_MAX_CONCURRENT) {
+    constructor(onComplete, maxConcurrent = DEFAULT_MAX_CONCURRENT, onStart) {
         this.onComplete = onComplete;
+        this.onStart = onStart;
         this.maxConcurrent = maxConcurrent;
         // Cleanup completed agents after 10 minutes (but keep sessions for resume)
         this.cleanupInterval = setInterval(() => this.cleanup(), 60_000);
@@ -65,22 +68,47 @@ export class AgentManager {
         record.startedAt = Date.now();
         if (options.isBackground)
             this.runningBackground++;
-        const promise = runAgent(ctx, type, prompt, {
+        this.onStart?.(record);
+        // Worktree isolation: create a temporary git worktree if requested
+        let worktreeCwd;
+        let worktreeWarning = "";
+        if (options.isolation === "worktree") {
+            const wt = createWorktree(ctx.cwd, id);
+            if (wt) {
+                record.worktree = wt;
+                worktreeCwd = wt.path;
+            }
+            else {
+                worktreeWarning = "\n\n[WARNING: Worktree isolation was requested but failed (not a git repo, or no commits yet). Running in the main working directory instead.]";
+            }
+        }
+        // Prepend worktree warning to prompt if isolation failed
+        const effectivePrompt = worktreeWarning ? worktreeWarning + "\n\n" + prompt : prompt;
+        const promise = runAgent(ctx, type, effectivePrompt, {
             pi,
             model: options.model,
             maxTurns: options.maxTurns,
             isolated: options.isolated,
             inheritContext: options.inheritContext,
             thinkingLevel: options.thinkingLevel,
+            cwd: worktreeCwd,
             signal: record.abortController.signal,
             onToolActivity: (activity) => {
                 if (activity.type === "end")
                     record.toolUses++;
                 options.onToolActivity?.(activity);
             },
+            onTurnEnd: options.onTurnEnd,
             onTextDelta: options.onTextDelta,
             onSessionCreated: (session) => {
                 record.session = session;
+                // Flush any steers that arrived before the session was ready
+                if (record.pendingSteers?.length) {
+                    for (const msg of record.pendingSteers) {
+                        session.steer(msg).catch(() => { });
+                    }
+                    record.pendingSteers = undefined;
+                }
                 options.onSessionCreated?.(session);
             },
         })
@@ -92,6 +120,23 @@ export class AgentManager {
             record.result = responseText;
             record.session = session;
             record.completedAt ??= Date.now();
+            // Final flush of streaming output file
+            if (record.outputCleanup) {
+                try {
+                    record.outputCleanup();
+                }
+                catch { /* ignore */ }
+                record.outputCleanup = undefined;
+            }
+            // Clean up worktree if used
+            if (record.worktree) {
+                const wtResult = cleanupWorktree(ctx.cwd, record.worktree, options.description);
+                record.worktreeResult = wtResult;
+                if (wtResult.hasChanges && wtResult.branch) {
+                    record.result = (record.result ?? "") +
+                        `\n\n---\nChanges saved to branch \`${wtResult.branch}\`. Merge with: \`git merge ${wtResult.branch}\``;
+                }
+            }
             if (options.isBackground) {
                 this.runningBackground--;
                 this.onComplete?.(record);
@@ -106,6 +151,22 @@ export class AgentManager {
             }
             record.error = err instanceof Error ? err.message : String(err);
             record.completedAt ??= Date.now();
+            // Final flush of streaming output file on error
+            if (record.outputCleanup) {
+                try {
+                    record.outputCleanup();
+                }
+                catch { /* ignore */ }
+                record.outputCleanup = undefined;
+            }
+            // Best-effort worktree cleanup on error
+            if (record.worktree) {
+                try {
+                    const wtResult = cleanupWorktree(ctx.cwd, record.worktree, options.description);
+                    record.worktreeResult = wtResult;
+                }
+                catch { /* ignore cleanup errors */ }
+            }
             if (options.isBackground) {
                 this.runningBackground--;
                 this.onComplete?.(record);
@@ -190,6 +251,12 @@ export class AgentManager {
         record.completedAt = Date.now();
         return true;
     }
+    /** Dispose a record's session and remove it from the map. */
+    removeRecord(id, record) {
+        record.session?.dispose?.();
+        record.session = undefined;
+        this.agents.delete(id);
+    }
     cleanup() {
         const cutoff = Date.now() - 10 * 60_000;
         for (const [id, record] of this.agents) {
@@ -197,18 +264,48 @@ export class AgentManager {
                 continue;
             if ((record.completedAt ?? 0) >= cutoff)
                 continue;
-            // Dispose and clear session so memory can be reclaimed
-            if (record.session) {
-                record.session.dispose();
-                record.session = undefined;
-            }
-            this.agents.delete(id);
+            this.removeRecord(id, record);
+        }
+    }
+    /**
+     * Remove all completed/stopped/errored records immediately.
+     * Called on session start/switch so tasks from a prior session don't persist.
+     */
+    clearCompleted() {
+        for (const [id, record] of this.agents) {
+            if (record.status === "running" || record.status === "queued")
+                continue;
+            this.removeRecord(id, record);
         }
     }
     /** Whether any agents are still running or queued. */
     hasRunning() {
         return [...this.agents.values()].some(r => r.status === "running" || r.status === "queued");
     }
+    /** Abort all running and queued agents immediately. */
+    abortAll() {
+        let count = 0;
+        // Clear queued agents first
+        for (const queued of this.queue) {
+            const record = this.agents.get(queued.id);
+            if (record) {
+                record.status = "stopped";
+                record.completedAt = Date.now();
+                count++;
+            }
+        }
+        this.queue = [];
+        // Abort running agents
+        for (const record of this.agents.values()) {
+            if (record.status === "running") {
+                record.abortController?.abort();
+                record.status = "stopped";
+                record.completedAt = Date.now();
+                count++;
+            }
+        }
+        return count;
+    }
     /** Wait for all running and queued agents to complete (including queued ones). */
     async waitForAll() {
         // Loop because drainQueue respects the concurrency limit — as running
@@ -232,5 +329,10 @@ export class AgentManager {
             record.session?.dispose();
         }
         this.agents.clear();
+        // Prune any orphaned git worktrees (crash recovery)
+        try {
+            pruneWorktrees(process.cwd());
+        }
+        catch { /* ignore */ }
     }
 }

package/dist/agent-runner.d.ts

@@ -1,14 +1,14 @@
 /**
  * agent-runner.ts — Core execution engine: creates sessions, runs agents, collects results.
  */
-import { type AgentSession, type ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
 import type { Model } from "@mariozechner/pi-ai";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { type AgentSession, type ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import type { SubagentType, ThinkingLevel } from "./types.js";
-/** Get the default max turns value. */
-export declare function getDefaultMaxTurns(): number;
-/** Set the default max turns value (minimum 1). */
-export declare function setDefaultMaxTurns(n: number): void;
+/** Get the default max turns value. undefined = unlimited. */
+export declare function getDefaultMaxTurns(): number | undefined;
+/** Set the default max turns value. undefined = unlimited, otherwise minimum 1. */
+export declare function setDefaultMaxTurns(n: number | undefined): void;
 /** Get the grace turns value. */
 export declare function getGraceTurns(): number;
 /** Set the grace turns value (minimum 1). */
@@ -27,11 +27,15 @@ export interface RunOptions {
     isolated?: boolean;
     inheritContext?: boolean;
     thinkingLevel?: ThinkingLevel;
+    /** Override working directory (e.g. for worktree isolation). */
+    cwd?: string;
     /** Called on tool start/end with activity info. */
     onToolActivity?: (activity: ToolActivity) => void;
     /** Called on streaming text deltas from the assistant response. */
     onTextDelta?: (delta: string, fullText: string) => void;
     onSessionCreated?: (session: AgentSession) => void;
+    /** Called at the end of each agentic turn with the cumulative count. */
+    onTurnEnd?: (turnCount: number) => void;
 }
 export interface RunResult {
     responseText: string;

package/dist/agent-runner.js

@@ -2,18 +2,20 @@
  * agent-runner.ts — Core execution engine: creates sessions, runs agents, collects results.
  */
 import { createAgentSession, DefaultResourceLoader, SessionManager, SettingsManager, } from "@mariozechner/pi-coding-agent";
-import { getToolsForType, getConfig, getAgentConfig } from "./agent-types.js";
-import { buildAgentPrompt } from "./prompts.js";
+import { getAgentConfig, getConfig, getMemoryTools, getReadOnlyMemoryTools, getToolsForType } from "./agent-types.js";
 import { buildParentContext, extractText } from "./context.js";
 import { detectEnv } from "./env.js";
+import { buildMemoryBlock, buildReadOnlyMemoryBlock } from "./memory.js";
+import { buildAgentPrompt } from "./prompts.js";
+import { preloadSkills } from "./skill-loader.js";
 /** Names of tools registered by this extension that subagents must NOT inherit. */
 const EXCLUDED_TOOL_NAMES = ["Agent", "get_subagent_result", "steer_subagent"];
-/** Default max turns to prevent subagents from looping indefinitely. */
-let defaultMaxTurns = 50;
-/** Get the default max turns value. */
+/** Default max turns. undefined = unlimited (no turn limit). */
+let defaultMaxTurns;
+/** Get the default max turns value. undefined = unlimited. */
 export function getDefaultMaxTurns() { return defaultMaxTurns; }
-/** Set the default max turns value (minimum 1). */
-export function setDefaultMaxTurns(n) { defaultMaxTurns = Math.max(1, n); }
+/** Set the default max turns value. undefined = unlimited, otherwise minimum 1. */
+export function setDefaultMaxTurns(n) { defaultMaxTurns = n != null ? Math.max(1, n) : undefined; }
 /** Additional turns allowed after the soft limit steer message. */
 let graceTurns = 5;
 /** Get the grace turns value. */
@@ -73,13 +75,52 @@ function forwardAbortSignal(session, signal) {
 export async function runAgent(ctx, type, prompt, options) {
     const config = getConfig(type);
     const agentConfig = getAgentConfig(type);
-    const env = await detectEnv(options.pi, ctx.cwd);
+    // Resolve working directory: worktree override > parent cwd
+    const effectiveCwd = options.cwd ?? ctx.cwd;
+    const env = await detectEnv(options.pi, effectiveCwd);
     // Get parent system prompt for append-mode agents
     const parentSystemPrompt = ctx.getSystemPrompt();
+    // Build prompt extras (memory, skill preloading)
+    const extras = {};
+    // Resolve extensions/skills: isolated overrides to false
+    const extensions = options.isolated ? false : config.extensions;
+    const skills = options.isolated ? false : config.skills;
+    // Skill preloading: when skills is string[], preload their content into prompt
+    if (Array.isArray(skills)) {
+        const loaded = preloadSkills(skills, effectiveCwd);
+        if (loaded.length > 0) {
+            extras.skillBlocks = loaded;
+        }
+    }
+    let tools = getToolsForType(type, effectiveCwd);
+    // Persistent memory: detect write capability and branch accordingly.
+    // Account for disallowedTools — a tool in the base set but on the denylist is not truly available.
+    if (agentConfig?.memory) {
+        const existingNames = new Set(tools.map(t => t.name));
+        const denied = agentConfig.disallowedTools ? new Set(agentConfig.disallowedTools) : undefined;
+        const effectivelyHas = (name) => existingNames.has(name) && !denied?.has(name);
+        const hasWriteTools = effectivelyHas("write") || effectivelyHas("edit");
+        if (hasWriteTools) {
+            // Read-write memory: add any missing memory tools (read/write/edit)
+            const memTools = getMemoryTools(effectiveCwd, existingNames);
+            if (memTools.length > 0)
+                tools = [...tools, ...memTools];
+            extras.memoryBlock = buildMemoryBlock(agentConfig.name, agentConfig.memory, effectiveCwd);
+        }
+        else {
+            // Read-only memory: only add read tool, use read-only prompt
+            if (!existingNames.has("read")) {
+                const readTools = getReadOnlyMemoryTools(effectiveCwd, existingNames);
+                if (readTools.length > 0)
+                    tools = [...tools, ...readTools];
+            }
+            extras.memoryBlock = buildReadOnlyMemoryBlock(agentConfig.name, agentConfig.memory, effectiveCwd);
+        }
+    }
     // Build system prompt from agent config
     let systemPrompt;
     if (agentConfig) {
-        systemPrompt = buildAgentPrompt(agentConfig, ctx.cwd, env, parentSystemPrompt);
+        systemPrompt = buildAgentPrompt(agentConfig, effectiveCwd, env, parentSystemPrompt, extras);
     }
     else {
         // Unknown type fallback: general-purpose (defensive — unreachable in practice
@@ -94,17 +135,16 @@ export async function runAgent(ctx, type, prompt, options) {
             inheritContext: false,
             runInBackground: false,
             isolated: false,
-        }, ctx.cwd, env, parentSystemPrompt);
+        }, effectiveCwd, env, parentSystemPrompt, extras);
     }
-    const tools = getToolsForType(type, ctx.cwd);
-    // Resolve extensions/skills: isolated overrides to false
-    const extensions = options.isolated ? false : config.extensions;
-    const skills = options.isolated ? false : config.skills;
+    // When skills is string[], we've already preloaded them into the prompt.
+    // Still pass noSkills: true since we don't need the skill loader to load them again.
+    const noSkills = skills === false || Array.isArray(skills);
     // Load extensions/skills: true or string[] → load; false → don't
     const loader = new DefaultResourceLoader({
-        cwd: ctx.cwd,
+        cwd: effectiveCwd,
         noExtensions: extensions === false,
-        noSkills: skills === false,
+        noSkills,
         noPromptTemplates: true,
         noThemes: true,
         systemPromptOverride: () => systemPrompt,
@@ -115,8 +155,8 @@ export async function runAgent(ctx, type, prompt, options) {
     // Resolve thinking level: explicit option > agent config > undefined (inherit)
     const thinkingLevel = options.thinkingLevel ?? agentConfig?.thinking;
     const sessionOpts = {
-        cwd: ctx.cwd,
-        sessionManager: SessionManager.inMemory(ctx.cwd),
+        cwd: effectiveCwd,
+        sessionManager: SessionManager.inMemory(effectiveCwd),
         settingsManager: SettingsManager.create(),
         modelRegistry: ctx.modelRegistry,
         model,
@@ -128,13 +168,19 @@ export async function runAgent(ctx, type, prompt, options) {
     }
     // createAgentSession's type signature may not include thinkingLevel yet
     const { session } = await createAgentSession(sessionOpts);
+    // Build disallowed tools set from agent config
+    const disallowedSet = agentConfig?.disallowedTools
+        ? new Set(agentConfig.disallowedTools)
+        : undefined;
     // Filter active tools: remove our own tools to prevent nesting,
-    // and apply extension allowlist if specified
+    // apply extension allowlist if specified, and apply disallowedTools denylist
     if (extensions !== false) {
         const builtinToolNames = new Set(tools.map(t => t.name));
         const activeTools = session.getActiveToolNames().filter((t) => {
             if (EXCLUDED_TOOL_NAMES.includes(t))
                 return false;
+            if (disallowedSet?.has(t))
+                return false;
             if (builtinToolNames.has(t))
                 return true;
             if (Array.isArray(extensions)) {
@@ -144,6 +190,11 @@ export async function runAgent(ctx, type, prompt, options) {
         });
         session.setActiveToolsByName(activeTools);
     }
+    else if (disallowedSet) {
+        // Even with extensions disabled, apply denylist to built-in tools
+        const activeTools = session.getActiveToolNames().filter(t => !disallowedSet.has(t));
+        session.setActiveToolsByName(activeTools);
+    }
     options.onSessionCreated?.(session);
     // Track turns for graceful max_turns enforcement
     let turnCount = 0;
@@ -154,13 +205,16 @@ export async function runAgent(ctx, type, prompt, options) {
     const unsubTurns = session.subscribe((event) => {
         if (event.type === "turn_end") {
             turnCount++;
-            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();
+            options.onTurnEnd?.(turnCount);
+            if (maxTurns != null) {
+                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();
+                }
             }
         }
         if (event.type === "message_start") {
@@ -248,7 +302,7 @@ export function getAgentConversation(session) {
                 if (c.type === "text" && c.text)
                     textParts.push(c.text);
                 else if (c.type === "toolCall")
-                    toolCalls.push(`  Tool: ${c.toolName ?? "unknown"}`);
+                    toolCalls.push(`  Tool: ${c.name ?? c.toolName ?? "unknown"}`);
             }
             if (textParts.length > 0)
                 parts.push(`[Assistant]: ${textParts.join("\n")}`);

package/dist/agent-types.d.ts

@@ -28,6 +28,16 @@ export declare function getDefaultAgentNames(): string[];
 export declare function getUserAgentNames(): string[];
 /** Check if a type is valid and enabled (case-insensitive). */
 export declare function isValidType(type: string): boolean;
+/**
+ * Get the tools needed for memory management (read, write, edit).
+ * Only returns tools that are NOT already in the provided set.
+ */
+export declare function getMemoryTools(cwd: string, existingToolNames: Set<string>): AgentTool<any>[];
+/**
+ * Get only the read tool for read-only memory access.
+ * Only returns tools that are NOT already in the provided set.
+ */
+export declare function getReadOnlyMemoryTools(cwd: string, existingToolNames: Set<string>): AgentTool<any>[];
 /** Get built-in tools for a type (case-insensitive). */
 export declare function getToolsForType(type: string, cwd: string): AgentTool<any>[];
 /** Get config for a type (case-insensitive, returns a SubagentTypeConfig-compatible object). Falls back to general-purpose. */

package/dist/agent-types.js

@@ -4,7 +4,7 @@
  * Merges embedded default agents with user-defined agents from .pi/agents/*.md.
  * User agents override defaults with the same name. Disabled agents are kept but excluded from spawning.
  */
-import { createReadTool, createBashTool, createEditTool, createWriteTool, createGrepTool, createFindTool, createLsTool, } from "@mariozechner/pi-coding-agent";
+import { createBashTool, createEditTool, createFindTool, createGrepTool, createLsTool, createReadTool, createWriteTool, } from "@mariozechner/pi-coding-agent";
 import { DEFAULT_AGENTS } from "./default-agents.js";
 const TOOL_FACTORIES = {
     read: (cwd) => createReadTool(cwd),
@@ -84,6 +84,28 @@ export function isValidType(type) {
         return false;
     return agents.get(key)?.enabled !== false;
 }
+/** Tool names required for memory management. */
+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.
+ */
+export function getMemoryTools(cwd, existingToolNames) {
+    return MEMORY_TOOL_NAMES
+        .filter(n => !existingToolNames.has(n) && n in TOOL_FACTORIES)
+        .map(n => TOOL_FACTORIES[n](cwd));
+}
+/** 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.
+ */
+export function getReadOnlyMemoryTools(cwd, existingToolNames) {
+    return READONLY_MEMORY_TOOL_NAMES
+        .filter(n => !existingToolNames.has(n) && n in TOOL_FACTORIES)
+        .map(n => TOOL_FACTORIES[n](cwd));
+}
 /** Get built-in tools for a type (case-insensitive). */
 export function getToolsForType(type, cwd) {
     const key = resolveKey(type);