@esso0428/pi-subagents 0.15.0

package/dist/agent-types.d.ts

@@ -0,0 +1,67 @@
+/**
+ * agent-types.ts — Unified agent type registry.
+ *
+ * Merges embedded default agents with user-defined agents from .pi/agents/*.md, .agents/agents/*.md, and global agents.
+ * User agents override defaults with the same name. Disabled agents are kept but excluded from spawning.
+ */
+import type { AgentConfig } from "./types.js";
+/**
+ * All known built-in tool names, derived from pi's own tool factories rather
+ * than hardcoded so the set tracks pi-mono if it adds/renames a built-in.
+ * `createCodingTools` → read/bash/edit/write; `createReadOnlyTools` →
+ * read/grep/find/ls; their de-duplicated union is the 7 built-ins
+ * (read, bash, edit, write, grep, find, ls). The `cwd` only binds tool
+ * operations we never invoke here — we read each tool's `.name` and discard it.
+ */
+export declare const BUILTIN_TOOL_NAMES: string[];
+/** Check whether default agents are disabled. */
+export declare function isDefaultsDisabled(): boolean;
+/** Set whether default agents are disabled. */
+export declare function setDefaultsDisabled(b: boolean): void;
+/**
+ * Register agents into the unified registry.
+ * Starts with DEFAULT_AGENTS, then overlays user agents (overrides defaults with same name).
+ * Disabled agents (enabled === false) are kept in the registry but excluded from spawning.
+ */
+export declare function registerAgents(userAgents: Map<string, AgentConfig>): void;
+/**
+ * Apply npm:pi-subagents-style JSON overrides to the current agent registry.
+ * Reads from ~/.pi/agent/settings.json and .pi/settings.json and applies
+ * them as the highest-priority layer. Auto-registers agents that don't
+ * exist in the registry yet.
+ */
+export declare function applyNicoOverrides(): void;
+/** Resolve a type name case-insensitively. Returns the canonical key or undefined. */
+export declare function resolveType(name: string): string | undefined;
+/** Get the agent config for a type (case-insensitive). */
+export declare function getAgentConfig(name: string): AgentConfig | undefined;
+/** Get all enabled type names (for spawning and tool descriptions). */
+export declare function getAvailableTypes(): string[];
+/** Get all type names including disabled (for UI listing). */
+export declare function getAllTypes(): string[];
+/** Get names of default agents currently in the registry. */
+export declare function getDefaultAgentNames(): string[];
+/** Get names of user-defined agents (non-defaults) currently in the registry. */
+export declare function getUserAgentNames(): string[];
+/** Check if a type is valid and enabled (case-insensitive). */
+export declare function isValidType(type: string): boolean;
+/**
+ * Get memory tool names (read/write/edit) not already in the provided set.
+ */
+export declare function getMemoryToolNames(existingToolNames: Set<string>): string[];
+/**
+ * Get read-only memory tool names not already in the provided set.
+ */
+export declare function getReadOnlyMemoryToolNames(existingToolNames: Set<string>): string[];
+/** Get built-in tool names for a type (case-insensitive). */
+export declare function getToolNamesForType(type: string): string[];
+/** Get config for a type (case-insensitive, returns a SubagentTypeConfig-compatible object). Falls back to general-purpose. */
+export declare function getConfig(type: string): {
+    displayName: string;
+    description: string;
+    builtinToolNames: string[];
+    extensions: true | string[] | false;
+    excludeExtensions?: string[];
+    skills: true | string[] | false;
+    promptMode: "replace" | "append";
+};

package/dist/agent-types.js

@@ -0,0 +1,168 @@
+/**
+ * agent-types.ts — Unified agent type registry.
+ *
+ * Merges embedded default agents with user-defined agents from .pi/agents/*.md, .agents/agents/*.md, and global agents.
+ * User agents override defaults with the same name. Disabled agents are kept but excluded from spawning.
+ */
+import { createCodingTools, createReadOnlyTools } from "@earendil-works/pi-coding-agent";
+import { DEFAULT_AGENTS } from "./default-agents.js";
+import { applyNicoOverridesToMap, readNicoAgentOverrides } from "./nico-overrides.js";
+/**
+ * All known built-in tool names, derived from pi's own tool factories rather
+ * than hardcoded so the set tracks pi-mono if it adds/renames a built-in.
+ * `createCodingTools` → read/bash/edit/write; `createReadOnlyTools` →
+ * read/grep/find/ls; their de-duplicated union is the 7 built-ins
+ * (read, bash, edit, write, grep, find, ls). The `cwd` only binds tool
+ * operations we never invoke here — we read each tool's `.name` and discard it.
+ */
+export const BUILTIN_TOOL_NAMES = [
+    ...new Set([...createCodingTools("."), ...createReadOnlyTools(".")].map((t) => t.name)),
+];
+/** Unified runtime registry of all agents (defaults + user-defined). */
+const agents = new Map();
+/** When true, DEFAULT_AGENTS are skipped during registration. */
+let disableDefaults = false;
+/** Check whether default agents are disabled. */
+export function isDefaultsDisabled() { return disableDefaults; }
+/** Set whether default agents are disabled. */
+export function setDefaultsDisabled(b) { disableDefaults = b; }
+/**
+ * Register agents into the unified registry.
+ * Starts with DEFAULT_AGENTS, then overlays user agents (overrides defaults with same name).
+ * Disabled agents (enabled === false) are kept in the registry but excluded from spawning.
+ */
+export function registerAgents(userAgents) {
+    agents.clear();
+    // Start with defaults (unless disabled via settings)
+    if (!disableDefaults) {
+        for (const [name, config] of DEFAULT_AGENTS) {
+            agents.set(name, config);
+        }
+    }
+    // Overlay user agents (overrides defaults with same name)
+    for (const [name, config] of userAgents) {
+        agents.set(name, config);
+    }
+}
+/**
+ * Apply npm:pi-subagents-style JSON overrides to the current agent registry.
+ * Reads from ~/.pi/agent/settings.json and .pi/settings.json and applies
+ * them as the highest-priority layer. Auto-registers agents that don't
+ * exist in the registry yet.
+ */
+export function applyNicoOverrides() {
+    const { overrides, defaultModel } = readNicoAgentOverrides(process.cwd());
+    applyNicoOverridesToMap(agents, overrides, defaultModel);
+}
+/** Case-insensitive key resolution. */
+function resolveKey(name) {
+    if (agents.has(name))
+        return name;
+    const lower = name.toLowerCase();
+    for (const key of agents.keys()) {
+        if (key.toLowerCase() === lower)
+            return key;
+    }
+    return undefined;
+}
+/** Resolve a type name case-insensitively. Returns the canonical key or undefined. */
+export function resolveType(name) {
+    return resolveKey(name);
+}
+/** Get the agent config for a type (case-insensitive). */
+export function getAgentConfig(name) {
+    const key = resolveKey(name);
+    return key ? agents.get(key) : undefined;
+}
+/** Get all enabled type names (for spawning and tool descriptions). */
+export function getAvailableTypes() {
+    return [...agents.entries()]
+        .filter(([_, config]) => config.enabled !== false)
+        .map(([name]) => name);
+}
+/** Get all type names including disabled (for UI listing). */
+export function getAllTypes() {
+    return [...agents.keys()];
+}
+/** Get names of default agents currently in the registry. */
+export function getDefaultAgentNames() {
+    return [...agents.entries()]
+        .filter(([_, config]) => config.isDefault === true)
+        .map(([name]) => name);
+}
+/** Get names of user-defined agents (non-defaults) currently in the registry. */
+export function getUserAgentNames() {
+    return [...agents.entries()]
+        .filter(([_, config]) => config.isDefault !== true)
+        .map(([name]) => name);
+}
+/** Check if a type is valid and enabled (case-insensitive). */
+export function isValidType(type) {
+    const key = resolveKey(type);
+    if (!key)
+        return false;
+    return agents.get(key)?.enabled !== false;
+}
+/** Tool names required for memory management. */
+const MEMORY_TOOL_NAMES = ["read", "write", "edit"];
+/**
+ * Get memory tool names (read/write/edit) not already in the provided set.
+ */
+export function getMemoryToolNames(existingToolNames) {
+    return MEMORY_TOOL_NAMES.filter(n => !existingToolNames.has(n));
+}
+/** Tool names needed for read-only memory access. */
+const READONLY_MEMORY_TOOL_NAMES = ["read"];
+/**
+ * Get read-only memory tool names not already in the provided set.
+ */
+export function getReadOnlyMemoryToolNames(existingToolNames) {
+    return READONLY_MEMORY_TOOL_NAMES.filter(n => !existingToolNames.has(n));
+}
+/** Get built-in tool names for a type (case-insensitive). */
+export function getToolNamesForType(type) {
+    const key = resolveKey(type);
+    const raw = key ? agents.get(key) : undefined;
+    const config = raw?.enabled !== false ? raw : undefined;
+    // `undefined` (definition omitted the field) → all built-ins; an explicit `[]`
+    // (`tools: none` or a `tools:` with only `ext:` entries) → zero built-ins.
+    return config?.builtinToolNames ?? [...BUILTIN_TOOL_NAMES];
+}
+/** Get config for a type (case-insensitive, returns a SubagentTypeConfig-compatible object). Falls back to general-purpose. */
+export function getConfig(type) {
+    const key = resolveKey(type);
+    const config = key ? agents.get(key) : undefined;
+    if (config && config.enabled !== false) {
+        return {
+            displayName: config.displayName ?? config.name,
+            description: config.description,
+            builtinToolNames: config.builtinToolNames ?? BUILTIN_TOOL_NAMES,
+            extensions: config.extensions,
+            excludeExtensions: config.excludeExtensions,
+            skills: config.skills,
+            promptMode: config.promptMode,
+        };
+    }
+    // Fallback for unknown/disabled types — general-purpose config
+    const gp = agents.get("general-purpose");
+    if (gp && gp.enabled !== false) {
+        return {
+            displayName: gp.displayName ?? gp.name,
+            description: gp.description,
+            builtinToolNames: gp.builtinToolNames ?? BUILTIN_TOOL_NAMES,
+            extensions: gp.extensions,
+            excludeExtensions: gp.excludeExtensions,
+            skills: gp.skills,
+            promptMode: gp.promptMode,
+        };
+    }
+    // Absolute fallback (should never happen)
+    return {
+        displayName: "Agent",
+        description: "General-purpose agent for complex, multi-step tasks",
+        builtinToolNames: BUILTIN_TOOL_NAMES,
+        extensions: true,
+        skills: true,
+        promptMode: "append",
+    };
+}

package/dist/context.d.ts

@@ -0,0 +1,12 @@
+/**
+ * context.ts — Extract parent conversation context for subagent inheritance.
+ */
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+/** Extract text from a message content block array. */
+export declare function extractText(content: unknown[]): string;
+/**
+ * Build a text representation of the parent conversation context.
+ * Used when inherit_context is true to give the subagent visibility
+ * into what has been discussed/done so far.
+ */
+export declare function buildParentContext(ctx: ExtensionContext): string;

package/dist/context.js

@@ -0,0 +1,56 @@
+/**
+ * context.ts — Extract parent conversation context for subagent inheritance.
+ */
+/** Extract text from a message content block array. */
+export function extractText(content) {
+    return content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text ?? "")
+        .join("\n");
+}
+/**
+ * Build a text representation of the parent conversation context.
+ * Used when inherit_context is true to give the subagent visibility
+ * into what has been discussed/done so far.
+ */
+export function buildParentContext(ctx) {
+    const entries = ctx.sessionManager.getBranch();
+    if (!entries || entries.length === 0)
+        return "";
+    const parts = [];
+    for (const entry of entries) {
+        if (entry.type === "message") {
+            const msg = entry.message;
+            if (msg.role === "user") {
+                const text = typeof msg.content === "string"
+                    ? msg.content
+                    : extractText(msg.content);
+                if (text.trim())
+                    parts.push(`[User]: ${text.trim()}`);
+            }
+            else if (msg.role === "assistant") {
+                const text = extractText(msg.content);
+                if (text.trim())
+                    parts.push(`[Assistant]: ${text.trim()}`);
+            }
+            // Skip toolResult messages — too verbose for context
+        }
+        else if (entry.type === "compaction") {
+            // Include compaction summaries — they're already condensed
+            if (entry.summary) {
+                parts.push(`[Summary]: ${entry.summary}`);
+            }
+        }
+    }
+    if (parts.length === 0)
+        return "";
+    return `# Parent Conversation Context
+The following is the conversation history from the parent session that spawned you.
+Use this context to understand what has been discussed and decided so far.
+
+${parts.join("\n\n")}
+
+---
+# Your Task (below)
+`;
+}

package/dist/cross-extension-rpc.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Cross-extension RPC handlers for the subagents extension.
+ *
+ * Exposes ping, spawn, and stop RPCs over the pi.events event bus,
+ * using per-request scoped reply channels.
+ *
+ * Reply envelope follows pi-mono convention:
+ *   success → { success: true, data?: T }
+ *   error   → { success: false, error: string }
+ */
+/** Minimal event bus interface needed by the RPC handlers. */
+export interface EventBus {
+    on(event: string, handler: (data: unknown) => void): () => void;
+    emit(event: string, data: unknown): void;
+}
+/** RPC reply envelope — matches pi-mono's RpcResponse shape. */
+export type RpcReply<T = void> = {
+    success: true;
+    data?: T;
+} | {
+    success: false;
+    error: string;
+};
+/** RPC protocol version — bumped when the envelope or method contracts change. */
+export declare const PROTOCOL_VERSION = 2;
+/** Minimal AgentManager interface needed by the spawn/stop RPCs. */
+export interface SpawnCapable {
+    spawn(pi: unknown, ctx: unknown, type: string, prompt: string, options: any): string;
+    abort(id: string): boolean;
+}
+export interface RpcDeps {
+    events: EventBus;
+    pi: unknown;
+    getCtx: () => unknown | undefined;
+    manager: SpawnCapable;
+}
+export interface RpcHandle {
+    unsubPing: () => void;
+    unsubSpawn: () => void;
+    unsubStop: () => void;
+}
+/**
+ * Register ping, spawn, and stop RPC handlers on the event bus.
+ * Returns unsub functions for cleanup.
+ */
+export declare function registerRpcHandlers(deps: RpcDeps): RpcHandle;

package/dist/cross-extension-rpc.js

@@ -0,0 +1,76 @@
+/**
+ * Cross-extension RPC handlers for the subagents extension.
+ *
+ * Exposes ping, spawn, and stop RPCs over the pi.events event bus,
+ * using per-request scoped reply channels.
+ *
+ * Reply envelope follows pi-mono convention:
+ *   success → { success: true, data?: T }
+ *   error   → { success: false, error: string }
+ */
+import { resolveModel } from "./model-resolver.js";
+/** RPC protocol version — bumped when the envelope or method contracts change. */
+export const PROTOCOL_VERSION = 2;
+/**
+ * Wire a single RPC handler: listen on `channel`, run `fn(params)`,
+ * emit the reply envelope on `channel:reply:${requestId}`.
+ */
+function handleRpc(events, channel, fn) {
+    return events.on(channel, async (raw) => {
+        const params = raw;
+        try {
+            const data = await fn(params);
+            const reply = { success: true };
+            if (data !== undefined)
+                reply.data = data;
+            events.emit(`${channel}:reply:${params.requestId}`, reply);
+        }
+        catch (err) {
+            events.emit(`${channel}:reply:${params.requestId}`, {
+                success: false, error: err?.message ?? String(err),
+            });
+        }
+    });
+}
+/**
+ * Register ping, spawn, and stop RPC handlers on the event bus.
+ * Returns unsub functions for cleanup.
+ */
+export function registerRpcHandlers(deps) {
+    const { events, pi, getCtx, manager } = deps;
+    const unsubPing = handleRpc(events, "subagents:rpc:ping", () => {
+        return { version: PROTOCOL_VERSION };
+    });
+    const unsubSpawn = handleRpc(events, "subagents:rpc:spawn", ({ type, prompt, options }) => {
+        const ctx = getCtx();
+        if (!ctx)
+            throw new Error("No active session");
+        // Cross-extension RPC callers (e.g. pi-tasks TaskExecute) naturally
+        // forward serializable values, so options.model can be a string like
+        // "openai-codex/gpt-5.5". Resolve it to a real Model instance here
+        // — same pattern the scheduler path already uses — so the spawned
+        // agent's auth lookup doesn't crash with "No API key found for
+        // undefined".
+        let normalizedOptions = options ?? {};
+        if (typeof normalizedOptions.model === "string") {
+            const registry = ctx.modelRegistry;
+            if (!registry) {
+                throw new Error(`Model override "${normalizedOptions.model}" provided but ctx.modelRegistry is unavailable`);
+            }
+            const resolved = resolveModel(normalizedOptions.model, registry);
+            if (typeof resolved === "string") {
+                // resolveModel returns a human-readable error string when the
+                // input doesn't match any available model. Surface it instead of
+                // silently falling back so the caller sees the auth/typo issue.
+                throw new Error(resolved);
+            }
+            normalizedOptions = { ...normalizedOptions, model: resolved };
+        }
+        return { id: manager.spawn(pi, ctx, type, prompt, normalizedOptions) };
+    });
+    const unsubStop = handleRpc(events, "subagents:rpc:stop", ({ agentId }) => {
+        if (!manager.abort(agentId))
+            throw new Error("Agent not found");
+    });
+    return { unsubPing, unsubSpawn, unsubStop };
+}

package/dist/custom-agents.d.ts

@@ -0,0 +1,17 @@
+/**
+ * custom-agents.ts — Load user-defined agents from project (.pi/agents/, plus the shared .agents/agents/ workspace) and global ($PI_CODING_AGENT_DIR/agents/, default ~/.pi/agent/agents/) locations.
+ */
+import type { AgentConfig } from "./types.js";
+/**
+ * Scan for custom agent .md files from multiple locations.
+ * Discovery hierarchy (higher priority wins):
+ *   1. Project:   <cwd>/.pi/agents/*.md (authoritative — also where /agents writes)
+ *   2. Workspace: <cwd>/.agents/agents/*.md (shared cross-tool .agents workspace, read-only)
+ *   3. Global:    $PI_CODING_AGENT_DIR/agents/*.md (default: ~/.pi/agent/agents/*.md)
+ *
+ * Project-level agents override global ones with the same name. On a name clash
+ * between the two project locations, .pi/agents wins — .pi stays the project
+ * authority; .agents/agents is an additional read location.
+ * Any name is allowed — names matching defaults (e.g. "Explore") override them.
+ */
+export declare function loadCustomAgents(cwd: string): Map<string, AgentConfig>;

package/dist/custom-agents.js

@@ -0,0 +1,156 @@
+/**
+ * custom-agents.ts — Load user-defined agents from project (.pi/agents/, plus the shared .agents/agents/ workspace) and global ($PI_CODING_AGENT_DIR/agents/, default ~/.pi/agent/agents/) locations.
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
+import { BUILTIN_TOOL_NAMES } from "./agent-types.js";
+/**
+ * Scan for custom agent .md files from multiple locations.
+ * Discovery hierarchy (higher priority wins):
+ *   1. Project:   <cwd>/.pi/agents/*.md (authoritative — also where /agents writes)
+ *   2. Workspace: <cwd>/.agents/agents/*.md (shared cross-tool .agents workspace, read-only)
+ *   3. Global:    $PI_CODING_AGENT_DIR/agents/*.md (default: ~/.pi/agent/agents/*.md)
+ *
+ * Project-level agents override global ones with the same name. On a name clash
+ * between the two project locations, .pi/agents wins — .pi stays the project
+ * authority; .agents/agents is an additional read location.
+ * Any name is allowed — names matching defaults (e.g. "Explore") override them.
+ */
+export function loadCustomAgents(cwd) {
+    const globalDir = join(getAgentDir(), "agents");
+    const workspaceProjectDir = join(cwd, ".agents", "agents");
+    const projectDir = join(cwd, ".pi", "agents");
+    const agents = new Map();
+    loadFromDir(globalDir, agents, "global"); // lowest priority
+    loadFromDir(workspaceProjectDir, agents, "project"); // shared workspace
+    loadFromDir(projectDir, agents, "project"); // highest priority (overwrites)
+    return agents;
+}
+/** Load agent configs from a directory into the map. */
+function loadFromDir(dir, agents, source) {
+    if (!existsSync(dir))
+        return;
+    let files;
+    try {
+        files = readdirSync(dir).filter(f => f.endsWith(".md"));
+    }
+    catch {
+        return;
+    }
+    for (const file of files) {
+        const name = basename(file, ".md");
+        let content;
+        try {
+            content = readFileSync(join(dir, file), "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const { frontmatter: fm, body } = parseFrontmatter(content);
+        const { builtinToolNames, extSelectors } = parseToolsField(fm.tools);
+        agents.set(name, {
+            name,
+            displayName: str(fm.display_name),
+            description: str(fm.description) ?? name,
+            builtinToolNames,
+            extSelectors,
+            disallowedTools: csvListOptional(fm.disallowed_tools),
+            extensions: inheritField(fm.extensions ?? fm.inherit_extensions),
+            excludeExtensions: csvListOptional(fm.exclude_extensions),
+            skills: inheritField(fm.skills ?? fm.inherit_skills),
+            model: str(fm.model),
+            thinking: str(fm.thinking),
+            maxTurns: nonNegativeInt(fm.max_turns),
+            persistSession: fm.persist_session != null ? fm.persist_session === true : undefined,
+            outputTranscript: fm.output_transcript != null ? fm.output_transcript !== false : undefined,
+            sessionDir: str(fm.session_dir),
+            systemPrompt: body.trim(),
+            promptMode: fm.prompt_mode === "append" ? "append" : "replace",
+            inheritContext: fm.inherit_context != null ? fm.inherit_context === true : undefined,
+            runInBackground: fm.run_in_background != null ? fm.run_in_background === true : undefined,
+            isolated: fm.isolated != null ? fm.isolated === true : undefined,
+            memory: parseMemory(fm.memory),
+            isolation: fm.isolation === "worktree" ? "worktree" : undefined,
+            enabled: fm.enabled !== false, // default true; explicitly false disables
+            source,
+        });
+    }
+}
+// ---- Field parsers ----
+// All follow the same convention: omitted → default, "none"/empty → nothing, value → exact.
+/** Extract a string or undefined. */
+function str(val) {
+    return typeof val === "string" ? val : undefined;
+}
+/** Extract a non-negative integer or undefined. 0 means unlimited for max_turns. */
+function nonNegativeInt(val) {
+    return typeof val === "number" && val >= 0 ? val : undefined;
+}
+/**
+ * Parse a raw CSV field value into items, or undefined if absent/empty/"none".
+ */
+function parseCsvField(val) {
+    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, defaults) {
+    if (val === undefined || val === null)
+        return defaults;
+    return parseCsvField(val) ?? [];
+}
+/**
+ * Partition the `tools:` CSV into the built-in tool allowlist and raw `ext:` selectors.
+ * `*` (and the case-insensitive alias `all`, for `tools: all`) expands to all
+ * built-ins; plain entries are built-in names; `ext:` entries are extension-tool
+ * selectors parsed later by the runner. omitted → all built-ins, no selectors.
+ * `tools:` present with only `ext:` entries → zero built-ins (use `*`).
+ */
+function parseToolsField(val) {
+    const entries = csvList(val, BUILTIN_TOOL_NAMES);
+    const isWildcard = (e) => e === "*" || e.toLowerCase() === "all";
+    const hasWildcard = entries.some(isWildcard);
+    const plain = entries.filter(e => !isWildcard(e) && !e.startsWith("ext:"));
+    const extEntries = entries.filter(e => e.startsWith("ext:"));
+    return {
+        builtinToolNames: hasWildcard ? [...new Set([...BUILTIN_TOOL_NAMES, ...plain])] : plain,
+        extSelectors: extEntries.length > 0 ? extEntries : undefined,
+    };
+}
+/**
+ * Parse an optional comma-separated list field.
+ * omitted → undefined; "none"/empty → undefined; csv → listed items.
+ */
+function csvListOptional(val) {
+    return parseCsvField(val);
+}
+/**
+ * Parse a memory scope field.
+ * omitted → undefined; "user"/"project"/"local" → MemoryScope.
+ */
+function parseMemory(val) {
+    if (val === "user" || val === "project" || val === "local")
+        return val;
+    return undefined;
+}
+/**
+ * Parse an inherit field (extensions, skills).
+ * omitted/true → true (inherit all); false/"none"/empty → false; csv → listed names.
+ */
+function inheritField(val) {
+    if (val === undefined || val === null || val === true)
+        return true;
+    if (val === false || val === "none")
+        return false;
+    const items = csvList(val, []);
+    return items.length > 0 ? items : false;
+}

package/dist/default-agents.d.ts

@@ -0,0 +1,7 @@
+/**
+ * default-agents.ts — Embedded default agent configurations.
+ *
+ * These are always available but can be overridden by user .md files with the same name.
+ */
+import type { AgentConfig } from "./types.js";
+export declare const DEFAULT_AGENTS: Map<string, AgentConfig>;