@tintinweb/pi-subagents 0.4.0 → 0.4.3

package/dist/ui/conversation-viewer.d.ts

@@ -0,0 +1,31 @@
+/**
+ * conversation-viewer.ts — Live conversation overlay for viewing agent sessions.
+ *
+ * Displays a scrollable, live-updating view of an agent's conversation.
+ * Subscribes to session events for real-time streaming updates.
+ */
+import { type Component, type TUI } from "@mariozechner/pi-tui";
+import type { AgentSession } from "@mariozechner/pi-coding-agent";
+import type { Theme } from "./agent-widget.js";
+import { type AgentActivity } from "./agent-widget.js";
+import type { AgentRecord } from "../types.js";
+export declare class ConversationViewer implements Component {
+    private tui;
+    private session;
+    private record;
+    private activity;
+    private theme;
+    private done;
+    private scrollOffset;
+    private autoScroll;
+    private unsubscribe;
+    private lastInnerW;
+    private closed;
+    constructor(tui: TUI, session: AgentSession, record: AgentRecord, activity: AgentActivity | undefined, theme: Theme, done: (result: undefined) => void);
+    handleInput(data: string): void;
+    render(width: number): string[];
+    invalidate(): void;
+    dispose(): void;
+    private viewportHeight;
+    private buildContentLines;
+}

package/dist/ui/conversation-viewer.js

@@ -0,0 +1,236 @@
+/**
+ * conversation-viewer.ts — Live conversation overlay for viewing agent sessions.
+ *
+ * Displays a scrollable, live-updating view of an agent's conversation.
+ * Subscribes to session events for real-time streaming updates.
+ */
+import { matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
+import { formatTokens, formatDuration, getDisplayName, getPromptModeLabel, describeActivity } from "./agent-widget.js";
+import { extractText } from "../context.js";
+/** Lines consumed by chrome: top border + header + header sep + footer sep + footer + bottom border. */
+const CHROME_LINES = 6;
+const MIN_VIEWPORT = 3;
+export class ConversationViewer {
+    tui;
+    session;
+    record;
+    activity;
+    theme;
+    done;
+    scrollOffset = 0;
+    autoScroll = true;
+    unsubscribe;
+    lastInnerW = 0;
+    closed = false;
+    constructor(tui, session, record, activity, theme, done) {
+        this.tui = tui;
+        this.session = session;
+        this.record = record;
+        this.activity = activity;
+        this.theme = theme;
+        this.done = done;
+        this.unsubscribe = session.subscribe(() => {
+            if (this.closed)
+                return;
+            this.tui.requestRender();
+        });
+    }
+    handleInput(data) {
+        if (matchesKey(data, "escape") || matchesKey(data, "q")) {
+            this.closed = true;
+            this.done(undefined);
+            return;
+        }
+        const totalLines = this.buildContentLines(this.lastInnerW).length;
+        const viewportHeight = this.viewportHeight();
+        const maxScroll = Math.max(0, totalLines - viewportHeight);
+        if (matchesKey(data, "up") || matchesKey(data, "k")) {
+            this.scrollOffset = Math.max(0, this.scrollOffset - 1);
+            this.autoScroll = this.scrollOffset >= maxScroll;
+        }
+        else if (matchesKey(data, "down") || matchesKey(data, "j")) {
+            this.scrollOffset = Math.min(maxScroll, this.scrollOffset + 1);
+            this.autoScroll = this.scrollOffset >= maxScroll;
+        }
+        else if (matchesKey(data, "pageUp")) {
+            this.scrollOffset = Math.max(0, this.scrollOffset - viewportHeight);
+            this.autoScroll = false;
+        }
+        else if (matchesKey(data, "pageDown")) {
+            this.scrollOffset = Math.min(maxScroll, this.scrollOffset + viewportHeight);
+            this.autoScroll = this.scrollOffset >= maxScroll;
+        }
+        else if (matchesKey(data, "home")) {
+            this.scrollOffset = 0;
+            this.autoScroll = false;
+        }
+        else if (matchesKey(data, "end")) {
+            this.scrollOffset = maxScroll;
+            this.autoScroll = true;
+        }
+    }
+    render(width) {
+        if (width < 6)
+            return []; // too narrow for any meaningful rendering
+        const th = this.theme;
+        const innerW = width - 4; // border + padding
+        this.lastInnerW = innerW;
+        const lines = [];
+        const pad = (s, len) => {
+            const vis = visibleWidth(s);
+            return s + " ".repeat(Math.max(0, len - vis));
+        };
+        const row = (content) => th.fg("border", "│") + " " + truncateToWidth(pad(content, innerW), innerW) + " " + th.fg("border", "│");
+        const hrTop = th.fg("border", `╭${"─".repeat(width - 2)}╮`);
+        const hrBot = th.fg("border", `╰${"─".repeat(width - 2)}╯`);
+        const hrMid = row(th.fg("dim", "─".repeat(innerW)));
+        // Header
+        lines.push(hrTop);
+        const name = getDisplayName(this.record.type);
+        const modeLabel = getPromptModeLabel(this.record.type);
+        const modeTag = modeLabel ? ` ${th.fg("dim", `(${modeLabel})`)}` : "";
+        const statusIcon = this.record.status === "running"
+            ? th.fg("accent", "●")
+            : this.record.status === "completed"
+                ? th.fg("success", "✓")
+                : this.record.status === "error"
+                    ? th.fg("error", "✗")
+                    : th.fg("dim", "○");
+        const duration = formatDuration(this.record.startedAt, this.record.completedAt);
+        const headerParts = [duration];
+        const toolUses = this.activity?.toolUses ?? this.record.toolUses;
+        if (toolUses > 0)
+            headerParts.unshift(`${toolUses} tool${toolUses === 1 ? "" : "s"}`);
+        if (this.activity?.session) {
+            try {
+                const tokens = this.activity.session.getSessionStats().tokens.total;
+                if (tokens > 0)
+                    headerParts.push(formatTokens(tokens));
+            }
+            catch { /* */ }
+        }
+        lines.push(row(`${statusIcon} ${th.bold(name)}${modeTag}  ${th.fg("muted", this.record.description)} ${th.fg("dim", "·")} ${th.fg("dim", headerParts.join(" · "))}`));
+        lines.push(hrMid);
+        // Content area — rebuild every render (live data, no cache needed)
+        const contentLines = this.buildContentLines(innerW);
+        const viewportHeight = this.viewportHeight();
+        const maxScroll = Math.max(0, contentLines.length - viewportHeight);
+        if (this.autoScroll) {
+            this.scrollOffset = maxScroll;
+        }
+        const visibleStart = Math.min(this.scrollOffset, maxScroll);
+        const visible = contentLines.slice(visibleStart, visibleStart + viewportHeight);
+        for (let i = 0; i < viewportHeight; i++) {
+            lines.push(row(visible[i] ?? ""));
+        }
+        // Footer
+        lines.push(hrMid);
+        const scrollPct = contentLines.length <= viewportHeight
+            ? "100%"
+            : `${Math.round(((visibleStart + viewportHeight) / contentLines.length) * 100)}%`;
+        const footerLeft = th.fg("dim", `${contentLines.length} lines · ${scrollPct}`);
+        const footerRight = th.fg("dim", "↑↓ scroll · PgUp/PgDn · Esc close");
+        const footerGap = Math.max(1, innerW - visibleWidth(footerLeft) - visibleWidth(footerRight));
+        lines.push(row(footerLeft + " ".repeat(footerGap) + footerRight));
+        lines.push(hrBot);
+        return lines;
+    }
+    invalidate() { }
+    dispose() {
+        this.closed = true;
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = undefined;
+        }
+    }
+    // ---- Private ----
+    viewportHeight() {
+        return Math.max(MIN_VIEWPORT, this.tui.terminal.rows - CHROME_LINES);
+    }
+    buildContentLines(width) {
+        if (width <= 0)
+            return [];
+        const th = this.theme;
+        const messages = this.session.messages;
+        const lines = [];
+        if (messages.length === 0) {
+            lines.push(th.fg("dim", "(waiting for first message...)"));
+            return lines;
+        }
+        let needsSeparator = false;
+        for (const msg of messages) {
+            if (msg.role === "user") {
+                const text = typeof msg.content === "string"
+                    ? msg.content
+                    : extractText(msg.content);
+                if (!text.trim())
+                    continue;
+                if (needsSeparator)
+                    lines.push(th.fg("dim", "───"));
+                lines.push(th.fg("accent", "[User]"));
+                for (const line of wrapTextWithAnsi(text.trim(), width)) {
+                    lines.push(line);
+                }
+            }
+            else if (msg.role === "assistant") {
+                const textParts = [];
+                const toolCalls = [];
+                for (const c of msg.content) {
+                    if (c.type === "text" && c.text)
+                        textParts.push(c.text);
+                    else if (c.type === "toolCall") {
+                        toolCalls.push(c.toolName ?? "unknown");
+                    }
+                }
+                if (needsSeparator)
+                    lines.push(th.fg("dim", "───"));
+                lines.push(th.bold("[Assistant]"));
+                if (textParts.length > 0) {
+                    for (const line of wrapTextWithAnsi(textParts.join("\n").trim(), width)) {
+                        lines.push(line);
+                    }
+                }
+                for (const name of toolCalls) {
+                    lines.push(truncateToWidth(th.fg("muted", `  [Tool: ${name}]`), width));
+                }
+            }
+            else if (msg.role === "toolResult") {
+                const text = extractText(msg.content);
+                const truncated = text.length > 500 ? text.slice(0, 500) + "... (truncated)" : text;
+                if (!truncated.trim())
+                    continue;
+                if (needsSeparator)
+                    lines.push(th.fg("dim", "───"));
+                lines.push(th.fg("dim", "[Result]"));
+                for (const line of wrapTextWithAnsi(truncated.trim(), width)) {
+                    lines.push(th.fg("dim", line));
+                }
+            }
+            else if (msg.role === "bashExecution") {
+                const bash = msg;
+                if (needsSeparator)
+                    lines.push(th.fg("dim", "───"));
+                lines.push(truncateToWidth(th.fg("muted", `  $ ${bash.command}`), width));
+                if (bash.output?.trim()) {
+                    const out = bash.output.length > 500
+                        ? bash.output.slice(0, 500) + "... (truncated)"
+                        : bash.output;
+                    for (const line of wrapTextWithAnsi(out.trim(), width)) {
+                        lines.push(th.fg("dim", line));
+                    }
+                }
+            }
+            else {
+                continue;
+            }
+            needsSeparator = true;
+        }
+        // Streaming indicator for running agents
+        if (this.record.status === "running" && this.activity) {
+            const act = describeActivity(this.activity.activeTools, this.activity.responseText);
+            lines.push("");
+            lines.push(truncateToWidth(th.fg("accent", "▍ ") + th.fg("dim", act), width));
+        }
+        return lines;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tintinweb/pi-subagents",
-  "version": "0.4.0",
+  "version": "0.4.3",
   "description": "A pi extension extension that brings smart Claude Code-style autonomous sub-agents to pi.",
   "author": "tintinweb",
   "license": "MIT",

package/src/agent-manager.ts

@@ -11,9 +11,11 @@ import type { ExtensionContext, ExtensionAPI } from "@mariozechner/pi-coding-age
 import type { Model } from "@mariozechner/pi-ai";
 import type { AgentSession } from "@mariozechner/pi-coding-agent";
 import { runAgent, resumeAgent, type ToolActivity } from "./agent-runner.js";
-import type { SubagentType, AgentRecord, ThinkingLevel } from "./types.js";
+import type { SubagentType, AgentRecord, ThinkingLevel, IsolationMode } from "./types.js";
+import { createWorktree, cleanupWorktree, pruneWorktrees, type WorktreeInfo } from "./worktree.js";
 
 export type OnAgentComplete = (record: AgentRecord) => void;
+export type OnAgentStart = (record: AgentRecord) => void;
 
 /** Default max concurrent background agents. */
 const DEFAULT_MAX_CONCURRENT = 4;
@@ -34,6 +36,8 @@ 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. */
@@ -46,6 +50,7 @@ export class AgentManager {
   private agents = new Map<string, AgentRecord>();
   private cleanupInterval: ReturnType<typeof setInterval>;
   private onComplete?: OnAgentComplete;
+  private onStart?: OnAgentStart;
   private maxConcurrent: number;
 
   /** Queue of background agents waiting to start. */
@@ -53,8 +58,9 @@ export class AgentManager {
   /** Number of currently running background agents. */
   private runningBackground = 0;
 
-  constructor(onComplete?: OnAgentComplete, maxConcurrent = DEFAULT_MAX_CONCURRENT) {
+  constructor(onComplete?: OnAgentComplete, maxConcurrent = DEFAULT_MAX_CONCURRENT, onStart?: OnAgentStart) {
     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);
@@ -112,14 +118,32 @@ export class AgentManager {
     record.status = "running";
     record.startedAt = Date.now();
     if (options.isBackground) this.runningBackground++;
+    this.onStart?.(record);
 
-    const promise = runAgent(ctx, type, prompt, {
+    // Worktree isolation: create a temporary git worktree if requested
+    let worktreeCwd: string | undefined;
+    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++;
@@ -139,6 +163,17 @@ export class AgentManager {
         record.result = responseText;
         record.session = session;
         record.completedAt ??= Date.now();
+
+        // 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);
@@ -153,6 +188,15 @@ export class AgentManager {
         }
         record.error = err instanceof Error ? err.message : String(err);
         record.completedAt ??= Date.now();
+
+        // 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);
@@ -271,6 +315,28 @@ export class AgentManager {
     }
   }
 
+  /** Whether any agents are still running or queued. */
+  hasRunning(): boolean {
+    return [...this.agents.values()].some(
+      r => r.status === "running" || r.status === "queued",
+    );
+  }
+
+  /** Wait for all running and queued agents to complete (including queued ones). */
+  async waitForAll(): Promise<void> {
+    // Loop because drainQueue respects the concurrency limit — as running
+    // agents finish they start queued ones, which need awaiting too.
+    while (true) {
+      this.drainQueue();
+      const pending = [...this.agents.values()]
+        .filter(r => r.status === "running" || r.status === "queued")
+        .map(r => r.promise)
+        .filter(Boolean);
+      if (pending.length === 0) break;
+      await Promise.allSettled(pending);
+    }
+  }
+
   dispose() {
     clearInterval(this.cleanupInterval);
     // Clear queue
@@ -279,5 +345,7 @@ export class AgentManager {
       record.session?.dispose();
     }
     this.agents.clear();
+    // Prune any orphaned git worktrees (crash recovery)
+    try { pruneWorktrees(process.cwd()); } catch { /* ignore */ }
   }
 }

package/src/agent-runner.ts

@@ -13,10 +13,12 @@ import {
 } from "@mariozechner/pi-coding-agent";
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
 import type { Model } from "@mariozechner/pi-ai";
-import { getToolsForType, getConfig, getAgentConfig } from "./agent-types.js";
-import { buildAgentPrompt } from "./prompts.js";
+import { getToolsForType, getConfig, getAgentConfig, getMemoryTools, getReadOnlyMemoryTools } from "./agent-types.js";
+import { buildAgentPrompt, type PromptExtras } from "./prompts.js";
 import { buildParentContext, extractText } from "./context.js";
 import { detectEnv } from "./env.js";
+import { buildMemoryBlock, buildReadOnlyMemoryBlock } from "./memory.js";
+import { preloadSkills } from "./skill-loader.js";
 import type { SubagentType, ThinkingLevel } from "./types.js";
 
 /** Names of tools registered by this extension that subagents must NOT inherit. */
@@ -84,6 +86,8 @@ 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. */
@@ -136,15 +140,59 @@ export async function runAgent(
 ): Promise<RunResult> {
   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: PromptExtras = {};
+
+  // 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: string) => 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: string;
   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
     // since index.ts resolves unknown types to "general-purpose" before calling runAgent)
@@ -158,20 +206,18 @@ export async function runAgent(
       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,
@@ -187,8 +233,8 @@ export async function runAgent(
   const thinkingLevel = options.thinkingLevel ?? agentConfig?.thinking;
 
   const sessionOpts: Record<string, unknown> = {
-    cwd: ctx.cwd,
-    sessionManager: SessionManager.inMemory(ctx.cwd),
+    cwd: effectiveCwd,
+    sessionManager: SessionManager.inMemory(effectiveCwd),
     settingsManager: SettingsManager.create(),
     modelRegistry: ctx.modelRegistry,
     model,
@@ -202,12 +248,18 @@ export async function runAgent(
   // createAgentSession's type signature may not include thinkingLevel yet
   const { session } = await createAgentSession(sessionOpts as Parameters<typeof createAgentSession>[0]);
 
+  // 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)) {
         return extensions.some(ext => t.startsWith(ext) || t.includes(ext));
@@ -215,6 +267,10 @@ export async function runAgent(
       return true;
     });
     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);

package/src/agent-types.ts

@@ -109,6 +109,32 @@ export function isValidType(type: string): boolean {
   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: 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));
+}
+
+/** 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: 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));
+}
+
 /** Get built-in tools for a type (case-insensitive). */
 export function getToolsForType(type: string, cwd: string): AgentTool<any>[] {
   const key = resolveKey(type);

package/src/custom-agents.ts

@@ -6,7 +6,7 @@ import { parseFrontmatter } from "@mariozechner/pi-coding-agent";
 import { readFileSync, readdirSync, existsSync } from "node:fs";
 import { join, basename } from "node:path";
 import { homedir } from "node:os";
-import type { AgentConfig, ThinkingLevel } from "./types.js";
+import type { AgentConfig, ThinkingLevel, MemoryScope, IsolationMode } from "./types.js";
 import { BUILTIN_TOOL_NAMES } from "./agent-types.js";
 
 /**
@@ -56,6 +56,7 @@ function loadFromDir(dir: string, agents: Map<string, AgentConfig>, source: "pro
       displayName: str(fm.display_name),
       description: str(fm.description) ?? name,
       builtinToolNames: csvList(fm.tools, BUILTIN_TOOL_NAMES),
+      disallowedTools: csvListOptional(fm.disallowed_tools),
       extensions: inheritField(fm.extensions ?? fm.inherit_extensions),
       skills: inheritField(fm.skills ?? fm.inherit_skills),
       model: str(fm.model),
@@ -66,6 +67,8 @@ function loadFromDir(dir: string, agents: Map<string, AgentConfig>, source: "pro
       inheritContext: fm.inherit_context === true,
       runInBackground: fm.run_in_background === true,
       isolated: fm.isolated === true,
+      memory: parseMemory(fm.memory),
+      isolation: fm.isolation === "worktree" ? "worktree" : undefined,
       enabled: fm.enabled !== false,  // default true; explicitly false disables
       source,
     });
@@ -86,14 +89,40 @@ function positiveInt(val: unknown): number | undefined {
 }
 
 /**
- * Parse a comma-separated list field.
+ * Parse a raw CSV field value into items, or undefined if absent/empty/"none".
+ */
+function parseCsvField(val: unknown): string[] | undefined {
+  if (val === undefined || val === null) return undefined;
+  const s = String(val).trim();
+  if (!s || s === "none") return undefined;
+  const items = s.split(",").map(t => t.trim()).filter(Boolean);
+  return items.length > 0 ? items : undefined;
+}
+
+/**
+ * Parse a comma-separated list field with defaults.
  * omitted → defaults; "none"/empty → []; csv → listed items.
  */
 function csvList(val: unknown, defaults: string[]): string[] {
   if (val === undefined || val === null) return defaults;
-  const s = String(val).trim();
-  if (!s || s === "none") return [];
-  return s.split(",").map(t => t.trim()).filter(Boolean);
+  return parseCsvField(val) ?? [];
+}
+
+/**
+ * Parse an optional comma-separated list field.
+ * omitted → undefined; "none"/empty → undefined; csv → listed items.
+ */
+function csvListOptional(val: unknown): string[] | undefined {
+  return parseCsvField(val);
+}
+
+/**
+ * Parse a memory scope field.
+ * omitted → undefined; "user"/"project"/"local" → MemoryScope.
+ */
+function parseMemory(val: unknown): MemoryScope | undefined {
+  if (val === "user" || val === "project" || val === "local") return val;
+  return undefined;
 }
 
 /**