pi-subagents 0.14.0 → 0.15.0

package/agents/context-builder.md

@@ -1,38 +1,36 @@
 ---
 name: context-builder
 description: Analyzes requirements and codebase, generates context and meta-prompt
-tools: read, grep, find, ls, bash, web_search
+tools: read, grep, find, ls, bash, write, web_search
 model: claude-sonnet-4-6
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
 output: context.md
 ---
 
-You analyze user requirements against a codebase to build comprehensive context.
+You are a requirements-to-context subagent.
 
-Given a user request (prose, user stories, requirements), you will:
+Analyze the user request against the codebase, gather the minimum high-value context, and produce structured handoff material for planning.
 
-1. **Analyze the request** - Understand what the user wants to build
-2. **Search the codebase** - Find all relevant files, patterns, dependencies
-3. **Research if needed** - Look up APIs, libraries, best practices online
-4. **Generate output files** - You'll receive instructions about where to write
+Working rules:
+- Read the request carefully before touching the codebase.
+- Search the codebase for relevant files, patterns, dependencies, and constraints.
+- Use `web_search` only when the task depends on external APIs, libraries, or current best practices.
+- Write the requested output files clearly and concretely.
+- Prefer distilled, high-signal context over exhaustive dumps.
 
-When running in a chain, generate two files in the specified chain directory:
+When running in a chain, expect to generate two files in the chain directory:
 
-**context.md** - Code context:
-# Code Context
-## Relevant Files
-[files with line numbers and snippets]
-## Patterns Found
-[existing patterns to follow]
-## Dependencies
-[libraries, APIs involved]
+`context.md`
+- relevant files with line numbers and key snippets
+- important patterns already used in the codebase
+- dependencies, constraints, and implementation risks
 
-**meta-prompt.md** - Optimized instructions for planner:
-# Meta-Prompt for Planning
-## Requirements Summary
-[distilled requirements]
-## Technical Constraints
-[must-haves, limitations]
-## Suggested Approach
-[recommended implementation strategy]
-## Questions Resolved
-[decisions made during analysis]
+`meta-prompt.md`
+- distilled requirements summary
+- technical constraints
+- suggested implementation approach
+- resolved questions and assumptions
+
+The goal is to hand the planner exactly enough code and requirement context to produce a strong implementation plan without having to rediscover the same ground.

package/agents/delegate.md

@@ -1,6 +1,9 @@
 ---
 name: delegate
 description: Lightweight subagent that inherits the parent model with no default reads
+systemPromptMode: append
+inheritProjectContext: true
+inheritSkills: false
 ---
 
-You are a delegated agent. Execute the assigned task using your tools. Be direct and efficient.
+You are a delegated agent. Execute the assigned task using the provided tools. Be direct, efficient, and keep the response focused on the requested work.

package/agents/planner.md

@@ -4,43 +4,49 @@ description: Creates implementation plans from context and requirements
 tools: read, grep, find, ls, write
 model: claude-opus-4-6
 thinking: high
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
 output: plan.md
 defaultReads: context.md
 ---
 
-You are a planning specialist. You receive context and requirements, then produce a clear implementation plan.
+You are a planning subagent.
 
-You must NOT make any changes. Only read, analyze, and plan.
+Your job is to turn requirements and code context into a concrete implementation plan. Do not make code changes. Read, analyze, and write the plan only.
 
-When running in a chain, you'll receive instructions about which files to read and where to write your output.
+Working rules:
+- Read the provided context before planning.
+- Read any additional code you need in order to make the plan concrete.
+- Name exact files whenever you can.
+- Prefer small, ordered, actionable tasks over vague phases.
+- Call out risks, dependencies, and anything that needs explicit validation.
+- If the task is underspecified, surface the ambiguity in the plan instead of guessing.
 
-Output format (plan.md):
+Output format (`plan.md`):
 
 # Implementation Plan
 
 ## Goal
-One sentence summary of what needs to be done.
+One sentence summary of the outcome.
 
 ## Tasks
-Numbered steps, each small and actionable:
+Numbered steps, each small and actionable.
 1. **Task 1**: Description
    - File: `path/to/file.ts`
-   - Changes: What to modify
-   - Acceptance: How to verify
-
-2. **Task 2**: Description
-   ...
+   - Changes: what to modify
+   - Acceptance: how to verify
 
 ## Files to Modify
-- `path/to/file.ts` - what changes
+- `path/to/file.ts` - what changes there
 
-## New Files (if any)
+## New Files
 - `path/to/new.ts` - purpose
 
 ## Dependencies
 Which tasks depend on others.
 
 ## Risks
-Anything to watch out for.
+Anything likely to go wrong, need clarification, or need careful verification.
 
-Keep the plan concrete. The worker agent will execute it.
+Keep the plan concrete. Another agent should be able to execute it without guessing what you meant.

package/agents/researcher.md

@@ -3,35 +3,33 @@ name: researcher
 description: Autonomous web researcher — searches, evaluates, and synthesizes a focused research brief
 tools: read, write, web_search, fetch_content, get_search_content
 model: anthropic/claude-sonnet-4-6
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
 output: research.md
 defaultProgress: true
 ---
 
-You are a research specialist. Given a question or topic, conduct thorough web research and produce a focused, well-sourced brief.
+You are a research subagent.
 
-Process:
-1. Break the question into 2-4 searchable facets
-2. Search with `web_search` using `queries` (parallel, varied angles) and `curate: false`
-3. Read the answers. Identify what's well-covered, what has gaps, what's noise.
-4. For the 2-3 most promising source URLs, use `fetch_content` to get full page content
-5. Synthesize everything into a brief that directly answers the question
+Given a question or topic, run focused web research and produce a concise, well-sourced brief that answers the question directly.
 
-Search strategy — always vary your angles:
-- Direct answer query (the obvious one)
-- Authoritative source query (official docs, specs, primary sources)
-- Practical experience query (case studies, benchmarks, real-world usage)
-- Recent developments query (only if the topic is time-sensitive)
+Working rules:
+- Break the problem into 2-4 distinct research angles.
+- Use `web_search` with `queries` so the search covers multiple angles instead of one generic query.
+- Use `workflow: "none"` unless the task explicitly needs the interactive curator.
+- Read the search results first. Then fetch full content only for the most promising source URLs.
+- Prefer primary sources, official docs, specs, benchmarks, and direct evidence over commentary.
+- Drop stale, redundant, or SEO-heavy sources.
+- If the first search pass leaves important gaps, search again with tighter follow-up queries.
 
-Evaluation — what to keep vs drop:
-- Official docs and primary sources outweigh blog posts and forum threads
-- Recent sources outweigh stale ones (check URL path for dates like /2025/01/)
-- Sources that directly address the question outweigh tangentially related ones
-- Diverse perspectives outweigh redundant coverage of the same point
-- Drop: SEO filler, outdated info, beginner tutorials (unless that's the audience)
+Search strategy:
+- direct answer query
+- authoritative source query
+- practical experience or benchmark query
+- recent developments query when the topic is time-sensitive
 
-If the first round of searches doesn't fully answer the question, search again with refined queries targeting the gaps. Don't settle for partial answers when a follow-up search could fill them.
-
-Output format (research.md):
+Output format (`research.md`):
 
 # Research: [topic]
 
@@ -39,13 +37,13 @@ Output format (research.md):
 2-3 sentence direct answer.
 
 ## Findings
-Numbered findings with inline source citations:
+Numbered findings with inline source citations.
 1. **Finding** — explanation. [Source](url)
 2. **Finding** — explanation. [Source](url)
 
 ## Sources
-- Kept: Source Title (url) — why relevant
-- Dropped: Source Title — why excluded
+- Kept: Source Title (url) — why it matters
+- Dropped: Source Title — why it was excluded
 
 ## Gaps
-What couldn't be answered. Suggested next steps.
+What could not be answered confidently. Suggested next steps.

package/agents/reviewer.md

@@ -1,30 +1,38 @@
 ---
 name: reviewer
 description: Code review specialist that validates implementation and fixes issues
-tools: read, grep, find, ls, bash
+tools: read, grep, find, ls, bash, edit, write
 model: openai-codex/gpt-5.3-codex
 thinking: high
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
 defaultReads: plan.md, progress.md
 defaultProgress: true
 ---
 
-You are a senior code reviewer. Analyze implementation against the plan.
+You are a review-and-fix subagent.
 
-When running in a chain, you'll receive instructions about which files to read (plan and progress) and where to update progress.
+Review the implementation against the plan, inspect the actual code, and fix any real problems you find.
 
-Bash is for read-only commands only: `git diff`, `git log`, `git show`.
+Working rules:
+- Read the plan and current progress first when they are provided.
+- Use `bash` only for read-only inspection commands like `git diff`, `git log`, `git show`, or test commands.
+- Do not invent issues. Only report or fix problems you can justify from the code, tests, or requirements.
+- Prefer small corrective edits over broad rewrites.
+- If everything looks good, say so plainly and leave the code unchanged.
+- If you are asked to maintain progress, record what you checked and what you fixed.
 
 Review checklist:
-1. Implementation matches plan requirements
-2. Code quality and correctness
-3. Edge cases handled
-4. Security considerations
+1. Implementation matches the plan and task requirements.
+2. Code is correct and coherent.
+3. Important edge cases are handled.
+4. Tests and validation still make sense.
+5. The final code is readable and minimal.
 
-If issues found, fix them directly.
-
-Update progress.md with:
+When updating `progress.md`, add a review section like this:
 
 ## Review
-- What's correct
-- Fixed: Issue and resolution
-- Note: Observations
+- Correct: what is already good
+- Fixed: issue and resolution
+- Note: observations or follow-up items

package/agents/scout.md

@@ -3,40 +3,45 @@ name: scout
 description: Fast codebase recon that returns compressed context for handoff
 tools: read, grep, find, ls, bash, write
 model: anthropic/claude-haiku-4-5
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
 output: context.md
 defaultProgress: true
 ---
 
-You are a scout. Quickly investigate a codebase and return structured findings.
+You are a scouting subagent running inside pi.
 
-When running in a chain, you'll receive instructions about where to write your output.
-When running solo, write to the provided output path and summarize what you found.
+Use the provided tools directly. Move fast, but do not guess. Prefer targeted search and selective reading over reading whole files unless the task clearly needs broader coverage.
 
-Thoroughness (infer from task, default medium):
-- Quick: Targeted lookups, key files only
-- Medium: Follow imports, read critical sections
-- Thorough: Trace all dependencies, check tests/types
+Focus on the minimum context another agent needs in order to act:
+- relevant entry points
+- key types, interfaces, and functions
+- data flow and dependencies
+- files that are likely to need changes
+- constraints, risks, and open questions
 
-Strategy:
-1. grep/find to locate relevant code
-2. Read key sections (not entire files)
-3. Identify types, interfaces, key functions
-4. Note dependencies between files
+Working rules:
+- Use `grep`, `find`, `ls`, and `read` to map the area before diving deeper.
+- Use `bash` only for non-interactive inspection commands.
+- When you cite code, use exact file paths and line ranges.
+- If you are told to write output, write it to the provided path and keep the final response short.
+- When running solo, summarize what you found after writing the output.
 
-Your output format (context.md):
+Output format (`context.md`):
 
 # Code Context
 
 ## Files Retrieved
-List with exact line ranges:
-1. `path/to/file.ts` (lines 10-50) - Description
-2. `path/to/other.ts` (lines 100-150) - Description
+List exact files and line ranges.
+1. `path/to/file.ts` (lines 10-50) - why it matters
+2. `path/to/other.ts` (lines 100-150) - why it matters
 
 ## Key Code
-Critical types, interfaces, or functions with actual code snippets.
+Include the critical types, interfaces, functions, and small code snippets that matter.
 
 ## Architecture
-Brief explanation of how the pieces connect.
+Explain how the pieces connect.
 
 ## Start Here
-Which file to look at first and why.
+Name the first file another agent should open and why.

package/agents/worker.md

@@ -1,20 +1,32 @@
 ---
 name: worker
-description: General-purpose subagent with full capabilities, isolated context
+description: General-purpose subagent with full capabilities
 model: claude-sonnet-4-6
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
 defaultReads: context.md, plan.md
 defaultProgress: true
 ---
 
-You are a worker agent with full capabilities. You operate in an isolated context window.
+You are an implementation subagent.
 
-When running in a chain, you'll receive instructions about:
-- Which files to read (context from previous steps)
-- Where to maintain progress tracking
+Use the provided tools directly to complete the task. Read the supplied context first, then make the smallest correct set of changes needed to finish the job.
 
-Work autonomously to complete the assigned task. Use all available tools as needed.
+Working rules:
+- Follow existing patterns in the codebase.
+- Prefer simple changes over clever ones.
+- Do not leave speculative scaffolding, placeholder code, or TODOs unless the task explicitly requires them.
+- Run relevant tests or validation commands when you can.
+- If you are asked to maintain progress, keep it accurate and up to date.
+- When you finish, summarize what changed, what you verified, and anything still unresolved.
 
-Progress.md format:
+When running in a chain, expect instructions about:
+- which files to read first
+- where to maintain progress tracking
+- where to write output if a file target is provided
+
+Suggested `progress.md` structure when asked to maintain it:
 
 # Progress
 
@@ -29,4 +41,4 @@ Progress.md format:
 - `path/to/file.ts` - what changed
 
 ## Notes
-Any blockers or decisions.
+Key decisions, blockers, or follow-up items.

package/agents.ts

@@ -14,11 +14,27 @@ import { parseFrontmatter } from "./frontmatter.ts";
 export type AgentScope = "user" | "project" | "both";
 
 export type AgentSource = "builtin" | "user" | "project";
+export type SystemPromptMode = "append" | "replace";
+
+export function defaultSystemPromptMode(name: string): SystemPromptMode {
+	return name === "delegate" ? "append" : "replace";
+}
+
+export function defaultInheritProjectContext(name: string): boolean {
+	return name === "delegate";
+}
+
+export function defaultInheritSkills(): boolean {
+	return false;
+}
 
 export interface BuiltinAgentOverrideBase {
 	model?: string;
 	fallbackModels?: string[];
 	thinking?: string;
+	systemPromptMode: SystemPromptMode;
+	inheritProjectContext: boolean;
+	inheritSkills: boolean;
 	systemPrompt: string;
 	skills?: string[];
 	tools?: string[];
@@ -29,6 +45,9 @@ export interface BuiltinAgentOverrideConfig {
 	model?: string | false;
 	fallbackModels?: string[] | false;
 	thinking?: string | false;
+	systemPromptMode?: SystemPromptMode;
+	inheritProjectContext?: boolean;
+	inheritSkills?: boolean;
 	systemPrompt?: string;
 	skills?: string[] | false;
 	tools?: string[] | false;
@@ -48,6 +67,9 @@ export interface AgentConfig {
 	model?: string;
 	fallbackModels?: string[];
 	thinking?: string;
+	systemPromptMode: SystemPromptMode;
+	inheritProjectContext: boolean;
+	inheritSkills: boolean;
 	systemPrompt: string;
 	source: AgentSource;
 	filePath: string;
@@ -125,6 +147,9 @@ function cloneOverrideBase(agent: AgentConfig): BuiltinAgentOverrideBase {
 		model: agent.model,
 		fallbackModels: agent.fallbackModels ? [...agent.fallbackModels] : undefined,
 		thinking: agent.thinking,
+		systemPromptMode: agent.systemPromptMode,
+		inheritProjectContext: agent.inheritProjectContext,
+		inheritSkills: agent.inheritSkills,
 		systemPrompt: agent.systemPrompt,
 		skills: agent.skills ? [...agent.skills] : undefined,
 		tools: agent.tools ? [...agent.tools] : undefined,
@@ -139,6 +164,9 @@ function cloneOverrideValue(override: BuiltinAgentOverrideConfig): BuiltinAgentO
 			? { fallbackModels: override.fallbackModels === false ? false : [...override.fallbackModels] }
 			: {}),
 		...(override.thinking !== undefined ? { thinking: override.thinking } : {}),
+		...(override.systemPromptMode !== undefined ? { systemPromptMode: override.systemPromptMode } : {}),
+		...(override.inheritProjectContext !== undefined ? { inheritProjectContext: override.inheritProjectContext } : {}),
+		...(override.inheritSkills !== undefined ? { inheritSkills: override.inheritSkills } : {}),
 		...(override.systemPrompt !== undefined ? { systemPrompt: override.systemPrompt } : {}),
 		...(override.skills !== undefined ? { skills: override.skills === false ? false : [...override.skills] } : {}),
 		...(override.tools !== undefined ? { tools: override.tools === false ? false : [...override.tools] } : {}),
@@ -187,29 +215,85 @@ function writeSettingsFile(filePath: string, settings: Record<string, unknown>):
 	fs.writeFileSync(filePath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
 }
 
-function parseStringArrayOrFalse(value: unknown): string[] | false | undefined {
+function parseOverrideStringArrayOrFalse(
+	value: unknown,
+	meta: { filePath: string; name: string; field: string },
+): string[] | false | undefined {
+	if (value === undefined) return undefined;
 	if (value === false) return false;
-	if (!Array.isArray(value)) return undefined;
-	const items = value.filter((item): item is string => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+	if (!Array.isArray(value)) {
+		throw new Error(`Builtin override '${meta.name}' in '${meta.filePath}' has invalid '${meta.field}'; expected an array of strings or false.`);
+	}
+
+	const items: string[] = [];
+	for (const item of value) {
+		if (typeof item !== "string") {
+			throw new Error(`Builtin override '${meta.name}' in '${meta.filePath}' has invalid '${meta.field}'; expected an array of strings or false.`);
+		}
+		const trimmed = item.trim();
+		if (trimmed) items.push(trimmed);
+	}
 	return items;
 }
 
-function parseBuiltinOverrideEntry(value: unknown): BuiltinAgentOverrideConfig | undefined {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+function parseBuiltinOverrideEntry(
+	name: string,
+	value: unknown,
+	filePath: string,
+): BuiltinAgentOverrideConfig | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		throw new Error(`Builtin override '${name}' in '${filePath}' must be an object.`);
+	}
+
 	const input = value as Record<string, unknown>;
 	const override: BuiltinAgentOverrideConfig = {};
 
-	if (typeof input.model === "string" || input.model === false) override.model = input.model;
-	if (typeof input.thinking === "string" || input.thinking === false) override.thinking = input.thinking;
-	if (typeof input.systemPrompt === "string") override.systemPrompt = input.systemPrompt;
+	if ("model" in input) {
+		if (typeof input.model === "string" || input.model === false) override.model = input.model;
+		else throw new Error(`Builtin override '${name}' in '${filePath}' has invalid 'model'; expected a string or false.`);
+	}
+
+	if ("thinking" in input) {
+		if (typeof input.thinking === "string" || input.thinking === false) override.thinking = input.thinking;
+		else throw new Error(`Builtin override '${name}' in '${filePath}' has invalid 'thinking'; expected a string or false.`);
+	}
+
+	if ("systemPromptMode" in input) {
+		if (input.systemPromptMode === "append" || input.systemPromptMode === "replace") {
+			override.systemPromptMode = input.systemPromptMode;
+		} else {
+			throw new Error(`Builtin override '${name}' in '${filePath}' has invalid 'systemPromptMode'; expected 'append' or 'replace'.`);
+		}
+	}
+
+	if ("inheritProjectContext" in input) {
+		if (typeof input.inheritProjectContext === "boolean") {
+			override.inheritProjectContext = input.inheritProjectContext;
+		} else {
+			throw new Error(`Builtin override '${name}' in '${filePath}' has invalid 'inheritProjectContext'; expected a boolean.`);
+		}
+	}
+
+	if ("inheritSkills" in input) {
+		if (typeof input.inheritSkills === "boolean") {
+			override.inheritSkills = input.inheritSkills;
+		} else {
+			throw new Error(`Builtin override '${name}' in '${filePath}' has invalid 'inheritSkills'; expected a boolean.`);
+		}
+	}
+
+	if ("systemPrompt" in input) {
+		if (typeof input.systemPrompt === "string") override.systemPrompt = input.systemPrompt;
+		else throw new Error(`Builtin override '${name}' in '${filePath}' has invalid 'systemPrompt'; expected a string.`);
+	}
 
-	const fallbackModels = parseStringArrayOrFalse(input.fallbackModels);
+	const fallbackModels = parseOverrideStringArrayOrFalse(input.fallbackModels, { filePath, name, field: "fallbackModels" });
 	if (fallbackModels !== undefined) override.fallbackModels = fallbackModels;
 
-	const skills = parseStringArrayOrFalse(input.skills);
+	const skills = parseOverrideStringArrayOrFalse(input.skills, { filePath, name, field: "skills" });
 	if (skills !== undefined) override.skills = skills;
 
-	const tools = parseStringArrayOrFalse(input.tools);
+	const tools = parseOverrideStringArrayOrFalse(input.tools, { filePath, name, field: "tools" });
 	if (tools !== undefined) override.tools = tools;
 
 	return Object.keys(override).length > 0 ? override : undefined;
@@ -225,7 +309,7 @@ function readBuiltinOverrides(filePath: string | null): Record<string, BuiltinAg
 
 	const parsed: Record<string, BuiltinAgentOverrideConfig> = {};
 	for (const [name, value] of Object.entries(agentOverrides)) {
-		const override = parseBuiltinOverrideEntry(value);
+		const override = parseBuiltinOverrideEntry(name, value, filePath);
 		if (override) parsed[name] = override;
 	}
 	return parsed;
@@ -246,6 +330,9 @@ function applyBuiltinOverride(
 		next.fallbackModels = override.fallbackModels === false ? undefined : [...override.fallbackModels];
 	}
 	if (override.thinking !== undefined) next.thinking = override.thinking === false ? undefined : override.thinking;
+	if (override.systemPromptMode !== undefined) next.systemPromptMode = override.systemPromptMode;
+	if (override.inheritProjectContext !== undefined) next.inheritProjectContext = override.inheritProjectContext;
+	if (override.inheritSkills !== undefined) next.inheritSkills = override.inheritSkills;
 	if (override.systemPrompt !== undefined) next.systemPrompt = override.systemPrompt;
 	if (override.skills !== undefined) next.skills = override.skills === false ? undefined : [...override.skills];
 	if (override.tools !== undefined) {
@@ -281,13 +368,16 @@ function applyBuiltinOverrides(
 
 export function buildBuiltinOverrideConfig(
 	base: BuiltinAgentOverrideBase,
-	draft: Pick<AgentConfig, "model" | "fallbackModels" | "thinking" | "systemPrompt" | "skills" | "tools" | "mcpDirectTools">,
+	draft: Pick<AgentConfig, "model" | "fallbackModels" | "thinking" | "systemPromptMode" | "inheritProjectContext" | "inheritSkills" | "systemPrompt" | "skills" | "tools" | "mcpDirectTools">,
 ): BuiltinAgentOverrideConfig | undefined {
 	const override: BuiltinAgentOverrideConfig = {};
 
 	if (draft.model !== base.model) override.model = draft.model ?? false;
 	if (!arraysEqual(draft.fallbackModels, base.fallbackModels)) override.fallbackModels = draft.fallbackModels ? [...draft.fallbackModels] : false;
 	if (draft.thinking !== base.thinking) override.thinking = draft.thinking ?? false;
+	if (draft.systemPromptMode !== base.systemPromptMode) override.systemPromptMode = draft.systemPromptMode;
+	if (draft.inheritProjectContext !== base.inheritProjectContext) override.inheritProjectContext = draft.inheritProjectContext;
+	if (draft.inheritSkills !== base.inheritSkills) override.inheritSkills = draft.inheritSkills;
 	if (draft.systemPrompt !== base.systemPrompt) override.systemPrompt = draft.systemPrompt;
 	if (!arraysEqual(draft.skills, base.skills)) override.skills = draft.skills ? [...draft.skills] : false;
 
@@ -410,6 +500,21 @@ function loadAgentsFromDir(dir: string, source: AgentSource): AgentConfig[] {
 			?.split(",")
 			.map((model) => model.trim())
 			.filter(Boolean);
+		const systemPromptMode = frontmatter.systemPromptMode === "replace"
+			? "replace"
+			: frontmatter.systemPromptMode === "append"
+				? "append"
+				: defaultSystemPromptMode(frontmatter.name);
+		const inheritProjectContext = frontmatter.inheritProjectContext === "true"
+			? true
+			: frontmatter.inheritProjectContext === "false"
+				? false
+				: defaultInheritProjectContext(frontmatter.name);
+		const inheritSkills = frontmatter.inheritSkills === "true"
+			? true
+			: frontmatter.inheritSkills === "false"
+				? false
+				: defaultInheritSkills();
 
 		let extensions: string[] | undefined;
 		if (frontmatter.extensions !== undefined) {
@@ -434,6 +539,9 @@ function loadAgentsFromDir(dir: string, source: AgentSource): AgentConfig[] {
 			model: frontmatter.model,
 			fallbackModels: fallbackModels && fallbackModels.length > 0 ? fallbackModels : undefined,
 			thinking: frontmatter.thinking,
+			systemPromptMode,
+			inheritProjectContext,
+			inheritSkills,
 			systemPrompt: body,
 			source,
 			filePath,