bylua-lspec-subagents 1.0.2

package/dist/context.d.ts

@@ -0,0 +1,12 @@
+/**
+ * context.ts — Extract parent conversation context for subagent inheritance.
+ */
+import type { ExtensionContext } from "@mariozechner/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,14 @@
+/**
+ * custom-agents.ts — Load user-defined agents from project (.pi/agents/) 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
+ *   2. Global:  $PI_CODING_AGENT_DIR/agents/*.md (default: ~/.pi/agent/agents/*.md)
+ *
+ * Project-level agents override global ones with the same name.
+ * 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,127 @@
+/**
+ * custom-agents.ts — Load user-defined agents from project (.pi/agents/) 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 "@mariozechner/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
+ *   2. Global:  $PI_CODING_AGENT_DIR/agents/*.md (default: ~/.pi/agent/agents/*.md)
+ *
+ * Project-level agents override global ones with the same name.
+ * Any name is allowed — names matching defaults (e.g. "Explore") override them.
+ */
+export function loadCustomAgents(cwd) {
+    const globalDir = join(getAgentDir(), "agents");
+    const projectDir = join(cwd, ".pi", "agents");
+    const agents = new Map();
+    loadFromDir(globalDir, agents, "global"); // lower priority
+    loadFromDir(projectDir, agents, "project"); // higher 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);
+        agents.set(name, {
+            name,
+            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),
+            thinking: str(fm.thinking),
+            maxTurns: nonNegativeInt(fm.max_turns),
+            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) ?? [];
+}
+/**
+ * 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,12 @@
+/**
+ * default-agents.ts — L-Spec 9 embedded agent configurations.
+ *
+ * Uses model placeholders ({{model:agent_name}}) resolved at startup
+ * from lspec-model-config.json (project or global) or embedded defaults.
+ *
+ * Based on oh-my-opencode-slim agent roster:
+ *   orchestrator, explorer, librarian, oracle, designer,
+ *   fixer, observer, council, councillor
+ */
+import type { AgentConfig } from "./types.js";
+export declare const DEFAULT_AGENTS: Map<string, AgentConfig>;