pi-subagents-lite 1.3.0 → 1.4.0

package/src/{agent-discovery.ts → agents/agent-discovery.ts}

@@ -11,8 +11,9 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { AgentConfig, ThinkingLevel } from "./types.js";
-import { parseThinkingLevel } from "./utils.js";
+import type { AgentConfig } from "./types.js";
+import type { ThinkingLevel } from "../types.js";
+import { parseThinkingLevel } from "../utils.js";
 
 /* ------------------------------------------------------------------ */
 /*  Types                                                             */
@@ -32,6 +33,7 @@ export interface AgentConfigFromMd {
   model?: string;
   thinking?: ThinkingLevel;
   max_turns?: number;
+  max_tokens?: number;
   hidden?: boolean;
   systemPrompt: string;
   source: "user" | "project";
@@ -273,6 +275,7 @@ export function parseAgentFile(
     model: parseString(frontmatter, "model"),
     thinking: parseThinkingLevel(parseString(frontmatter, "thinking")),
     max_turns: parseNumber(frontmatter, "max_turns"),
+    max_tokens: parseNumber(frontmatter, "max_tokens"),
     hidden: parseBoolean(frontmatter, "hidden"),
     systemPrompt: body,
     source: source,
@@ -397,8 +400,9 @@ function fromMd(md: AgentConfigFromMd): Partial<AgentConfig> {
     skills: md.skills,
     preloadSkills: md.preload_skills,
     model: md.model,
-    thinking: md.thinking,
+    thinkingLevel: md.thinking,
     maxTurns: md.max_turns,
+    maxTokens: md.max_tokens,
     hidden: md.hidden,
     systemPrompt: md.systemPrompt,
     source: md.source === "project" ? "project" : "global",
@@ -414,7 +418,6 @@ function fromMd(md: AgentConfigFromMd): Partial<AgentConfig> {
 const BASE_DEFAULTS: AgentConfig = {
   name: "unknown",
   description: "",
-  extensions: true,
-  skills: true,
+  // extensions and skills intentionally omitted — resolved by global default
   systemPrompt: "",
 };

package/src/{agent-manager.ts → agents/agent-manager.ts}

@@ -5,21 +5,21 @@
  */
 
 import { randomUUID } from "node:crypto";
-import type { Model } from "@earendil-works/pi-ai";
 import type { AgentSession, ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { runAgent, type ToolActivity } from "./agent-runner.js";
-import { createOutputFilePath, streamToOutputFile, writeInitialEntry } from "./output-file.js";
+import { runAgent } from "./agent-runner.js";
+import { AgentOutputLog } from "./output-file.js";
 import {
-  type AgentInvocation,
   type AgentRecord,
   type AgentStatus,
   type CompactionInfo,
+  type RunCallbacks,
   SHORT_ID_LENGTH,
-  type SubagentType,
-  type ThinkingLevel,
-} from "./types.js";
+  type SpawnConfig,
+  type ToolActivity,
+} from "../types.js";
+import type { SubagentType } from "./types.js";
 import { addUsage, getLifetimeTotal, getSessionContextPercent, type LifetimeUsage } from "./usage.js";
-import { errorMessage } from "./utils.js";
+import { errorMessage } from "../utils.js";
 
 /** How often to check for expired agent records (milliseconds). */
 const CLEANUP_INTERVAL_MS = 60_000;
@@ -35,27 +35,6 @@ const AGENT_ID_PREFIX_LENGTH = 17;
 /** Default per-model concurrency limit when not specified in config. */
 const DEFAULT_CONCURRENCY_LIMIT = 4;
 
-/**
- * Create a cleanup function for the output file stream.
- * Captures final stats from the record at cleanup time so the DONE line
- * reflects actual turn count, tool uses, and total tokens.
- */
-function createOutputCleanup(
-  session: AgentSession,
-  path: string,
-  record: AgentRecord,
-): () => void {
-  const outputStats = { turnCount: 0, toolUseCount: 0, totalTokens: 0, cost: 0 };
-  const cleanup = streamToOutputFile(session, path, outputStats);
-  return () => {
-    outputStats.turnCount = record.stats.turnCount ?? 0;
-    outputStats.toolUseCount = record.stats.toolUses;
-    outputStats.totalTokens = getLifetimeTotal(record.stats.lifetimeUsage);
-    outputStats.cost = record.stats.lifetimeUsage.cost;
-    cleanup();
-  };
-}
-
 /** Whether the agent status is terminal (no longer running or queued). */
 function isTerminalStatus(status: AgentStatus): boolean {
   return status !== "running" && status !== "queued";
@@ -88,40 +67,10 @@ interface SpawnArgs {
   options: SpawnOptions;
 }
 
-export interface SpawnOptions {
-  description: string;
-  model?: Model<any>;
-  maxTurns?: number;
-  thinkingLevel?: ThinkingLevel;
+export interface SpawnOptions extends SpawnConfig, RunCallbacks {
   isBackground?: boolean;
-  /** Resolved worktree path — forwarded as cwd to runAgent. */
-  worktreePath?: string;
-  /** Short display label for the worktree (set on record display after spawn). */
-  worktreeLabel?: string;
-  /**
-   * Model key for concurrency pool lookup (e.g. "llamacpp/4b_small").
-   * When set, the agent is counted against that model's concurrency limit.
-   * When unset, the agent bypasses per-model concurrency limits.
-   */
-  modelKey?: string;
-  /** Resolved invocation snapshot captured for UI display. */
-  invocation?: AgentInvocation;
   /** Parent abort signal — when aborted, the subagent is also stopped. */
   signal?: AbortSignal;
-  /** 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;
-  /** Called once per assistant message_end with that message's usage delta. */
-  onAssistantUsage?: (usage: LifetimeUsage) => void;
-  /** Called when the session successfully compacts. */
-  onCompaction?: (info: CompactionInfo) => void;
-  /** Grace turns: extra turns allowed after hitting maxTurns. */
-  graceTurns?: number;
 }
 
 export class AgentManager {
@@ -273,6 +222,7 @@ export class AgentManager {
       stats: {
         lifetimeUsage: { input: 0, output: 0, cacheWrite: 0, cost: 0 },
         toolUses: 0,
+        turnCount: 1,
         compactionCount: 0,
         maxTurns: options.maxTurns,
       },
@@ -307,9 +257,9 @@ export class AgentManager {
     record.lifecycle.status = "running";
     record.lifecycle.startedAt = Date.now();
 
-    // Create output file for this agent
-    record.display.outputFile = createOutputFilePath(id);
-    writeInitialEntry(record.display.outputFile, prompt);
+    // Create output log for this agent (creates file + writes [USER] entry)
+    record.execution.outputLog = new AgentOutputLog(id, prompt);
+    record.display.outputFile = record.execution.outputLog.path;
 
     this.onStart?.(record);
 
@@ -323,6 +273,7 @@ export class AgentManager {
       agentId: id,
       model: options.model,
       maxTurns: options.maxTurns,
+      maxTokens: options.maxTokens,
       thinkingLevel: options.thinkingLevel,
       cwd: options.worktreePath,
       graceTurns: options.graceTurns,
@@ -345,19 +296,17 @@ export class AgentManager {
           }
           record.execution.pendingSteers = undefined;
         }
-        // Stream session events to the output file
-        if (record.display.outputFile) {
-          record.execution.outputCleanup = createOutputCleanup(
-            session, record.display.outputFile, record,
-          );
+        // Attach output log stream to session
+        if (record.execution.outputLog) {
+          record.execution.outputLog.attach(session);
         }
         options.onSessionCreated?.(session);
       },
     })
-      .then(({ responseText, session, aborted, steered }) => {
+      .then(({ responseText, session, aborted, turnLimited }) => {
         // Don't overwrite status if externally stopped via abort()
         if (record.lifecycle.status !== "stopped") {
-          record.lifecycle.status = aborted ? "aborted" : steered ? "steered" : "completed";
+          record.lifecycle.status = aborted ? "aborted" : turnLimited ? "turn_limited" : "completed";
         }
         record.result = responseText;
         record.execution.session = session;
@@ -375,10 +324,17 @@ export class AgentManager {
         return "";
       })
       .finally(() => {
-        // Final flush of streaming output file
-        if (record.execution.outputCleanup) {
-          try { record.execution.outputCleanup(); } catch { /* ignore */ }
-          record.execution.outputCleanup = undefined;
+        // Finalize output log with final stats
+        if (record.execution.outputLog) {
+          try {
+            record.execution.outputLog.finalize({
+              turnCount: record.stats.turnCount ?? 0,
+              toolUseCount: record.stats.toolUses,
+              totalTokens: getLifetimeTotal(record.stats.lifetimeUsage),
+              cost: record.stats.lifetimeUsage.cost,
+            });
+          } catch { /* ignore */ }
+          record.execution.outputLog = undefined;
         }
 
         // Decrement per-model concurrency count
@@ -397,6 +353,10 @@ export class AgentManager {
     try { this.onComplete?.(record); } catch { /* ignore */ }
   }
 
+  setOnComplete(cb: OnAgentComplete): void {
+    this.onComplete = cb;
+  }
+
   /** Get the session-level cumulative agent cost. Survives agent eviction. */
   getTotalAgentCost(): number {
     return this.totalAgentCost;

package/src/{agent-runner.ts → agents/agent-runner.ts}

@@ -1,11 +1,11 @@
 /**
  * Core execution engine: creates sessions, runs agents, collects results.
  *
- * EXCLUDED_TOOL_NAMES prevents sub-subagent spawning.
+ * Tool visibility policy is owned by agent-types.ts (resolveVisibleTools).
  */
 
+import fs from "node:fs";
 import path from "node:path";
-import type { Model } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
   type AgentSession,
@@ -14,23 +14,25 @@ import {
   DefaultResourceLoader,
   type ExtensionAPI,
   getAgentDir,
+  loadProjectContextFiles,
   SessionManager,
   SettingsManager,
 } from "@earendil-works/pi-coding-agent";
-import { getAgentConfig, getConfig, getToolNamesForType, BUILTIN_TOOL_NAMES } from "./agent-types.js";
-import { extractText } from "./context.js";
+import { getAgentConfig, getConfig, getToolNamesForType, resolveVisibleTools } from "./agent-types.js";
+import { extractText } from "../prompt/context.js";
 import type { LifetimeUsage } from "./usage.js";
-import { findModelInRegistry } from "./utils.js";
+import { findModelInRegistry } from "../utils.js";
 import { DEFAULT_AGENTS } from "./default-agents.js";
-import { buildAgentPrompt, type PromptExtras } from "./prompts.js";
-import { preloadSkills, loadSkillMeta, type SkillMeta } from "./skill-loader.js";
-import { type CompactionInfo, type EnvInfo, SHORT_ID_LENGTH, type SubagentType, type ThinkingLevel } from "./types.js";
+import { buildAgentPrompt, type PromptExtras } from "../prompt/prompts.js";
+import { preloadSkills, loadSkillMeta, type SkillMeta } from "../prompt/skill-loader.js";
+import { type EnvInfo, type RunCallbacks, type RunTunables, SHORT_ID_LENGTH } from "../types.js";
+import type { SubagentType, SystemPromptMode } from "./types.js";
+import { getStore } from "../shell.js";
+import { DEFAULT_GRACE_TURNS } from "../config/config-io.js";
 
-/** Names of tools registered by this extension that subagents must NOT inherit. */
-const EXCLUDED_TOOL_NAMES = ["Agent"];
+/** Path to custom prompt file. Exported for use in menus.ts. */
+export const CUSTOM_PROMPT_PATH = path.join(process.env.HOME || "", ".pi", "agent", "subagents-lite-prompt.md");
 
-/** Default grace turns when not specified in config. */
-const DEFAULT_GRACE_TURNS = 6;
 
 /** Timeout for quick git commands (branch detection, repo check). */
 const GIT_EXEC_TIMEOUT_MS = 5000;
@@ -42,42 +44,15 @@ function normalizeMaxTurns(n: number | undefined): number | undefined {
 }
 
 /** Info about a tool event in the subagent. */
-export interface ToolActivity {
-  type: "start" | "end";
-  toolName: string;
-}
-
-interface RunOptions {
+interface RunOptions extends RunTunables, RunCallbacks {
   /** ExtensionAPI instance — used for pi.exec() for git detection. */
   pi: ExtensionAPI;
   /** Manager-assigned id; suffixes session name to disambiguate parallel spawns (e.g. `Explore#a1b2c3d4`). */
   agentId?: string;
-  model?: Model<any>;
-  maxTurns?: number;
-  signal?: AbortSignal;
-  thinkingLevel?: ThinkingLevel;
-  /** Override working directory. */
+  /** Override working directory (resolved worktree path). */
   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;
-  /**
-   * Called once per assistant message_end with that message's usage delta.
-   * Lets callers maintain a lifetime accumulator that survives compaction
-   * (which replaces session.state.messages and resets stats-derived sums).
-   */
-  onAssistantUsage?: (usage: LifetimeUsage) => void;
-  /**
-   * Called when the session successfully compacts. `tokensBefore` is upstream's
-   * pre-compaction context size estimate. Aborted compactions don't fire.
-   */
-  onCompaction?: (info: CompactionInfo) => void;
-  /** Grace turns: extra turns allowed after hitting maxTurns. Defaults to 6. */
-  graceTurns?: number;
+  /** Parent abort signal — when aborted, the subagent is also stopped. */
+  signal?: AbortSignal;
 }
 
 interface RunResult {
@@ -85,8 +60,8 @@ interface RunResult {
   session: AgentSession;
   /** True if the agent was hard-aborted (max_turns + grace exceeded). */
   aborted: boolean;
-  /** True if the agent was steered to wrap up (hit soft turn limit) but finished in time. */
-  steered: boolean;
+  /** True if the agent hit the soft turn limit and wrapped up within grace turns. */
+  turnLimited: boolean;
 }
 
 /**
@@ -229,120 +204,6 @@ function extractExtensionName(extPath: string): string {
   return path.basename(path.dirname(extPath));
 }
 
-/**
- * Resolve tool entries (with ext/* syntax) into concrete tool names.
- * Returns a set of resolved tool names.
- */
-function resolveToolEntries(
-  entries: string[],
-  extToolMap: Map<string, string[]> | undefined,
-  notify?: (msg: string) => void,
-): Set<string> {
-  const resolved = new Set<string>();
-
-  for (const entry of entries) {
-    const slashIdx = entry.indexOf("/");
-    if (slashIdx !== -1) {
-      // ext/* or ext/tool syntax
-      const extName = entry.slice(0, slashIdx);
-      const toolPart = entry.slice(slashIdx + 1);
-      if (toolPart === "*") {
-        const extTools = extToolMap?.get(extName);
-        if (extTools && extTools.length > 0) {
-          for (const t of extTools) resolved.add(t);
-        } else {
-          notify?.(`extension "${extName}" is not loaded, "${entry}" will have no effect`);
-        }
-      } else {
-        // ext/tool syntax: e.g. "tavily/web_search"
-        resolved.add(toolPart);
-      }
-    } else {
-      // Bare tool name
-      resolved.add(entry);
-    }
-  }
-
-  return resolved;
-}
-
-/**
- * Filter active tools: apply tools allowlist/denylist and EXCLUDED_TOOL_NAMES.
- *
- * The `tools` config controls which tool schemas the LLM sees (built-in + extension).
- * The `extensions` config controls which extensions are loaded (hooks + commands).
- * `extensions` does NOT affect tool visibility — that's `tools`'s job.
- *
- * Supports ext/* syntax for both whitelist and blacklist modes.
- *
- * `tools` and `excludeTools` are mutually exclusive. If both set, `tools` wins.
- *
- * Returns null when no filtering is needed, otherwise the filtered tool list.
- */
-function filterActiveTools(
-  activeTools: string[],
-  extToolMap: Map<string, string[]> | undefined,
-  tools: true | string[] | false | undefined,
-  excludeTools: string[] | undefined,
-  notify?: (msg: string) => void,
-): string[] | null {
-  // Blacklist mode: excludeTools set and tools not set as whitelist
-  if (excludeTools && !Array.isArray(tools)) {
-    const excludeSet = resolveToolEntries(excludeTools, extToolMap, notify);
-    const filtered = activeTools.filter(t =>
-      !EXCLUDED_TOOL_NAMES.includes(t) && !excludeSet.has(t)
-    );
-    return filtered.length !== activeTools.length ? filtered : null;
-  }
-
-  if (Array.isArray(tools)) {
-    // Whitelist mode: resolve entries with ext/* expansion
-    const allBuiltinSet = new Set(BUILTIN_TOOL_NAMES);
-    const allowedTools = resolveToolEntries(tools, extToolMap, notify);
-
-    // Warn about unknown entries
-    for (const entry of tools) {
-      const slashIdx = entry.indexOf("/");
-      if (slashIdx === -1 && !allBuiltinSet.has(entry)) {
-        // Bare name, not a known built-in — check if it's an extension tool
-        const toolExts = extToolMap ? [...extToolMap.entries()].filter(([, tools]) => tools.includes(entry)) : [];
-        if (toolExts.length === 0) {
-          notify?.(`tool "${entry}" not found in any loaded extension`);
-        }
-      }
-    }
-
-    const visibleSet = new Set<string>();
-    for (const t of activeTools) {
-      if (EXCLUDED_TOOL_NAMES.includes(t)) continue;
-      if (allowedTools.has(t)) {
-        visibleSet.add(t);
-      }
-    }
-
-    // Warn if a loaded extension has none of its tools in `tools`
-    if (extToolMap) {
-      for (const [extName, extTools] of extToolMap) {
-        const hasAny = extTools.some(t => allowedTools.has(t));
-        if (!hasAny) {
-          notify?.(`extension "${extName}" is loaded but none of its tools are in tools: [${tools.join(", ")}]`);
-        }
-      }
-    }
-
-    return [...visibleSet];
-  }
-
-  if (tools === false) {
-    return [];
-  }
-
-  // tools: true or undefined — all tools visible (except excluded)
-  const hasExcluded = activeTools.some(t => EXCLUDED_TOOL_NAMES.includes(t));
-  if (!hasExcluded) return null;
-  return activeTools.filter(t => !EXCLUDED_TOOL_NAMES.includes(t));
-}
-
 /** Run a git command via pi.exec, returning stdout on success or null on failure. */
 async function execGit(pi: ExtensionAPI, args: string[], cwd: string): Promise<string | null> {
   try {
@@ -371,8 +232,62 @@ async function detectEnv(pi: ExtensionAPI, cwd: string): Promise<EnvInfo> {
 
 // ── runAgent phases ────────────────────────────────────────────────
 
+/**
+ * Resolve system prompt mode, fetch the appropriate source prompt, and
+ * load project context files. Returns everything buildPrompt needs.
+ */
+function resolveSystemPromptSources(
+  ctx: ExtensionContext,
+  cwd: string,
+  notify: (msg: string) => void,
+): { mode: SystemPromptMode; extras: Pick<PromptExtras, "parentSystemPrompt" | "customSystemPrompt" | "contextFiles"> } {
+  const store = getStore();
+  const mode = store.agent.systemPromptMode;
+  const extras: Pick<PromptExtras, "parentSystemPrompt" | "customSystemPrompt" | "contextFiles"> = {};
+
+  // Fetch parent system prompt for inherit mode
+  if (mode === "inherit") {
+    try {
+      extras.parentSystemPrompt = ctx.getSystemPrompt();
+    } catch (err) {
+      notify(`Failed to get parent system prompt: ${err}. Falling back to replace mode.`);
+    }
+  }
+
+  // Read custom prompt file for custom mode
+  if (mode === "custom") {
+    try {
+      const content = fs.readFileSync(CUSTOM_PROMPT_PATH, "utf-8").trim();
+      if (content) {
+        extras.customSystemPrompt = content;
+      } else {
+        notify(`Custom prompt file is empty: ${CUSTOM_PROMPT_PATH}. Falling back to replace mode.`);
+      }
+    } catch (err: any) {
+      if (err.code === "ENOENT") {
+        notify(`Custom prompt file not found: ${CUSTOM_PROMPT_PATH}. Falling back to replace mode.`);
+      } else {
+        notify(`Failed to read custom prompt file: ${err.message}. Falling back to replace mode.`);
+      }
+    }
+  }
+
+  // Load AGENTS.md context files when the setting is enabled
+  if (store.agent.includeContextFiles) {
+    try {
+      extras.contextFiles = loadProjectContextFiles({ cwd, agentDir: getAgentDir() });
+    } catch {
+      // Non-fatal: context files are supplementary
+    }
+  }
+
+  return { mode, extras };
+}
+
 /**
  * Phase 1: Resolve system prompt from agent config, skills, and env info.
+ *
+ * @param resolverExtras  Partial extras from resolveSystemPromptSources (mode-specific prompts + context files).
  */
 function buildPrompt(
   type: SubagentType,
@@ -380,8 +295,10 @@ function buildPrompt(
   config: ReturnType<typeof getConfig>,
   cwd: string,
   env: EnvInfo,
+  systemPromptMode: SystemPromptMode = "replace",
+  resolverExtras: Pick<PromptExtras, "parentSystemPrompt" | "customSystemPrompt" | "contextFiles"> = {},
 ): string {
-  const extras: PromptExtras = {};
+  const extras: PromptExtras = { ...resolverExtras };
   if (Array.isArray(agentConfig?.preloadSkills)) {
     extras.skillBlocks = preloadSkills(agentConfig.preloadSkills, cwd);
   }
@@ -389,11 +306,11 @@ function buildPrompt(
     extras.skillMetas = loadSkillMeta(config.skills, cwd);
   }
   if (agentConfig) {
-    return buildAgentPrompt(agentConfig, cwd, env, extras);
+    return buildAgentPrompt(agentConfig, cwd, env, extras, systemPromptMode);
   }
   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);
+  return buildAgentPrompt({ ...fallback, name: type }, cwd, env, extras, systemPromptMode);
 }
 
 /** Build extension name → tool names map from loaded extensions. */
@@ -482,7 +399,7 @@ async function initSession(
   const model = options.model ?? findModelInRegistry(
     agentConfig?.model, ctx.modelRegistry, ctx.model,
   );
-  const thinkingLevel = options.thinkingLevel ?? agentConfig?.thinking;
+  const thinkingLevel = options.thinkingLevel ?? agentConfig?.thinkingLevel;
   const agentDir = getAgentDir();
   const sessionOpts: Parameters<typeof createAgentSession>[0] = {
     cwd, agentDir,
@@ -492,7 +409,22 @@ async function initSession(
     tools: getToolNamesForType(type), resourceLoader: loader,
   };
   if (thinkingLevel) sessionOpts.thinkingLevel = thinkingLevel;
-  return createAgentSession(sessionOpts);
+  const result = await createAgentSession(sessionOpts);
+
+  // Inject max_tokens into provider request payloads.
+  // Spawn-time value wins over agent config (frontmatter).
+  const maxTokens = options.maxTokens ?? agentConfig?.maxTokens;
+  if (maxTokens != null && maxTokens > 0 && model) {
+    const field = (model.compat as any)?.maxTokensField ?? "max_tokens";
+    const origOnPayload = result.session.agent.onPayload;
+    result.session.agent.onPayload = async (payload, m) => {
+      const applied = origOnPayload ? (await origOnPayload(payload, m)) ?? payload : payload;
+      const obj = typeof applied === "object" && applied && !Array.isArray(applied) ? applied : {};
+      return { ...obj, [field]: maxTokens };
+    };
+  }
+
+  return result;
 }
 
 /**
@@ -518,10 +450,13 @@ async function createAndConfigureSession(
       type: "end", toolName: `extension-error:${err.extensionPath}`,
     }),
   });
-  const filteredTools = filterActiveTools(
-    session.getActiveToolNames(), buildExtToolMap(extResult.extensions),
-    agentConfig?.tools, agentConfig?.excludeTools, notify,
-  );
+  const filteredTools = resolveVisibleTools({
+    activeTools: session.getActiveToolNames(),
+    tools: agentConfig?.tools,
+    excludeTools: agentConfig?.excludeTools,
+    extToolMap: buildExtToolMap(extResult.extensions),
+    notify,
+  });
   if (filteredTools) session.setActiveToolsByName(filteredTools);
   options.onSessionCreated?.(session);
   return session;
@@ -555,7 +490,7 @@ function wireTurnTracking(
     }
   });
 
-  return { unsubscribe, getAborted: () => aborted, getSteered: () => softLimitReached };
+  return { unsubscribe, getAborted: () => aborted, getTurnLimited: () => softLimitReached };
 }
 
 /**
@@ -589,7 +524,8 @@ export async function runAgent(
   prompt: string,
   options: RunOptions,
 ): Promise<RunResult> {
-  const config = getConfig(type);
+  const store = getStore();
+  const config = getConfig(type, store.agent.loadSkillsImplicitly, store.agent.loadExtensionsImplicitly);
   const agentConfig = getAgentConfig(type);
 
   // Warn on mutual exclusion violations
@@ -607,17 +543,23 @@ export async function runAgent(
   const effectiveCwd = options.cwd ?? ctx.cwd;
   const env = await detectEnv(options.pi, effectiveCwd);
 
-  const systemPrompt = buildPrompt(type, agentConfig, config, effectiveCwd, env);
+  // Resolve system prompt mode + source prompts + context files
+  const { mode, extras: promptExtras } = resolveSystemPromptSources(ctx, effectiveCwd, notify);
+
+  const systemPrompt = buildPrompt(
+    type, agentConfig, config, effectiveCwd, env,
+    mode, promptExtras,
+  );
   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, {
+  const { unsubscribe: unsubTurns, getAborted, getTurnLimited } = wireTurnTracking(session, {
     ...options,
     maxTurns: options.maxTurns ?? agentConfig?.maxTurns,
   });
 
   const responseText = await runTurnLoop(session, prompt, options, unsubTurns);
-  return { responseText, session, aborted: getAborted(), steered: getSteered() };
+  return { responseText, session, aborted: getAborted(), turnLimited: getTurnLimited() };
 }

package/src/{agent-status.ts → agents/agent-status.ts}

@@ -7,9 +7,9 @@
  */
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { AgentRecord } from "./types.js";
-import { SHORT_ID_LENGTH } from "./types.js";
-import { getManager } from "./state.js";
+import type { AgentRecord } from "../types.js";
+import { SHORT_ID_LENGTH } from "../types.js";
+import { getManager } from "../shell.js";
 
 /**
  * Format a single agent record as "type·short_id·status".
@@ -32,7 +32,7 @@ export async function executeAgentStatusTool(
   _onUpdate: ((update: any) => void) | undefined,
   _ctx: ExtensionContext,
 ): Promise<any> {
-  const manager = getManager();
+  const manager = getManager()!;
   const agents = manager.listAgents();
 
   const nudge = "Don't poll — you'll receive notifications when agents complete.";