@aexol/spectral 0.7.1 → 0.7.5

package/CHANGELOG.md

@@ -5,6 +5,11 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.7.2] - 2026-05-25
+
+### Changed
+- Version bump for monorepo release
+
 ### Added
 - Admin OpenRouter catalog picker in `/studio/admin/models` (Base Models tab):
   search across 368 models from `https://openrouter.ai/api/v1/models` and add

package/dist/agent/agents.js

@@ -17,7 +17,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { getAgentDir, parseFrontmatter } from "@mariozechner/pi-coding-agent";
+import { getAgentDir, parseFrontmatter } from "../pi/coding-agent/index.js";
 function loadAgentsFromDir(dir, source) {
     const agents = [];
     if (!fs.existsSync(dir)) {

package/dist/agent/index.js

@@ -2,10 +2,10 @@
  * Subagent Delegation Extension for Spectral
  *
  * Registers a `subagent` tool that allows the coding agent to delegate tasks
- * to specialized sub-agents running in isolated `pi` / `spectral` processes.
+ * to specialized sub-agents running in-process via `agentLoop()`.
  *
- * Each subagent invocation spawns a separate process with its own context
- * window, keeping the main conversation lean and focused.
+ * Each subagent invocation runs with its own fresh AgentContext (isolated
+ * context window), keeping the main conversation lean and focused.
  *
  * Three execution modes:
  *   - Single:   { agent: "name", task: "..." }
@@ -16,20 +16,25 @@
  *   - ~/.pi/agent/agents/*.md    (user-level, always loaded)
  *   - .pi/agents/*.md            (project-level, opt-in via agentScope)
  *
- * The subagent binary is auto-detected:
- *   - If running via `spectral`, uses the same invocation path
- *   - Falls back to `pi` otherwise
+ * Subagents use an in-process `agentLoop()` for:
+ *   - Clean context isolation (fresh messages array)
+ *   - Combined system prompt (main agent + subagent-specific instructions)
+ *   - Tool filtering (only the tools specified in agent config)
+ *   - Model selection (session model preferred, agent-configured as fallback)
+ *   - Signal propagation (abort passthrough)
+ *   - Access to observational memory via the recall tool
  */
-import { spawn } from "node:child_process";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { StringEnum } from "@mariozechner/pi-ai";
-import { withFileMutationQueue, } from "@mariozechner/pi-coding-agent";
-import { Text } from "@mariozechner/pi-tui";
+import { agentLoop } from "../pi/agent-core/index.js";
+import { StringEnum } from "../pi/ai/index.js";
+import { Text } from "../pi/tui/index.js";
 import { Type } from "typebox";
 import { discoverAgents } from "./agents.js";
 // ---------------------------------------------------------------------------
+// Built-in tool resolution (no spawn needed — tools are registered in-process)
+// ---------------------------------------------------------------------------
+import { createTool, allToolNames } from "../pi/coding-agent/core/tools/index.js";
+import { wrapToolDefinition } from "../pi/coding-agent/core/tools/tool-definition-wrapper.js";
+// ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
 const MAX_PARALLEL_TASKS = 8;
@@ -83,7 +88,72 @@ function getFinalOutput(messages) {
     return "";
 }
 // ---------------------------------------------------------------------------
-// Helpers — concurrency, temp files, binary detection
+// Helpers — model resolution
+// ---------------------------------------------------------------------------
+/**
+ * Resolve a model string (e.g. "claude-sonnet-4-5" or "anthropic/claude-sonnet-4-5")
+ * to a Model object from the registry.
+ */
+function resolveModelString(modelStr, modelRegistry) {
+    if (!modelStr)
+        return undefined;
+    const allModels = modelRegistry.getAll();
+    // Try "provider/modelId" format
+    const slashIdx = modelStr.indexOf("/");
+    if (slashIdx !== -1) {
+        const provider = modelStr.substring(0, slashIdx);
+        const modelId = modelStr.substring(slashIdx + 1);
+        const match = allModels.find((m) => m.provider.toLowerCase() === provider.toLowerCase() && m.id.toLowerCase() === modelId.toLowerCase());
+        if (match)
+            return match;
+    }
+    // Try exact model ID match
+    const idMatch = allModels.find((m) => m.id.toLowerCase() === modelStr.toLowerCase());
+    if (idMatch)
+        return idMatch;
+    // Try fuzzy match (model ID contains the string)
+    const fuzzy = allModels.find((m) => m.id.toLowerCase().includes(modelStr.toLowerCase()));
+    return fuzzy;
+}
+// ---------------------------------------------------------------------------
+// Helpers — tool resolution
+// ---------------------------------------------------------------------------
+/**
+ * Resolve tool names from an agent definition into AgentTool objects.
+ *
+ * Built-in tools (read, bash, edit, write, grep, find, ls) are created via
+ * `createTool()`. Extension-registered tools (e.g., recall) are resolved
+ * via the ExtensionAPI and wrapped.
+ */
+function resolveSubagentTools(toolNames, cwd, pi, ctx) {
+    if (!toolNames || toolNames.length === 0)
+        return [];
+    const tools = [];
+    for (const name of toolNames) {
+        // Built-in tools
+        if (allToolNames.has(name)) {
+            try {
+                const tool = createTool(name, cwd);
+                tools.push(tool);
+            }
+            catch {
+                // Tool creation failed — skip
+            }
+            continue;
+        }
+        // Extension-registered tools (recall, designer_*, etc.)
+        // pi at runtime is the embedded ExtensionAPI which has getToolDefinition;
+        // the npm types don't expose it, so we cast.
+        const richPi = pi;
+        const toolDef = richPi.getToolDefinition(name);
+        if (toolDef) {
+            tools.push(wrapToolDefinition(toolDef, () => ctx));
+        }
+    }
+    return tools;
+}
+// ---------------------------------------------------------------------------
+// Helpers — concurrency
 // ---------------------------------------------------------------------------
 async function mapWithConcurrencyLimit(items, concurrency, fn) {
     if (items.length === 0)
@@ -102,65 +172,10 @@ async function mapWithConcurrencyLimit(items, concurrency, fn) {
     await Promise.all(workers);
     return results;
 }
-async function writePromptToTempFile(agentName, prompt) {
-    const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "spectral-subagent-"));
-    const safeName = agentName.replace(/[^\w.-]+/g, "_");
-    const filePath = path.join(tmpDir, `prompt-${safeName}.md`);
-    await withFileMutationQueue(filePath, async () => {
-        await fs.promises.writeFile(filePath, prompt, { encoding: "utf-8", mode: 0o600 });
-    });
-    return { dir: tmpDir, filePath };
-}
-/**
- * Detect the correct binary for spawning subagent processes.
- *
- * Strategy:
- *   1. If `process.argv[1]` points to an existing script (unlikely in bundled
- *      env but possible during dev with tsx), use that script with node.
- *   2. If the executor is named `spectral` or `aexol`, use it directly (the
- *      wrapper ensures MCP + memory extensions are auto-loaded).
- *   3. Otherwise fall back to `pi`.
- */
-function getPiInvocation(subagentArgs) {
-    const currentScript = process.argv[1];
-    // Case 1: running via tsx with an existing script file
-    if (currentScript && fs.existsSync(currentScript)) {
-        return { command: process.execPath, args: [currentScript, ...subagentArgs] };
-    }
-    // Case 2: check if this is the spectral/aexol wrapper binary
-    const execName = path.basename(process.execPath).toLowerCase();
-    if (execName === "spectral" || execName === "aexol") {
-        return { command: process.execPath, args: subagentArgs };
-    }
-    // Case 3: generic node — try spectral first, then pi
-    function hasBin(name) {
-        const PATH = process.env.PATH || "";
-        const envPathSep = process.platform === "win32" ? ";" : ":";
-        for (const dir of PATH.split(envPathSep)) {
-            const candidate = path.join(dir, name);
-            try {
-                if (fs.existsSync(candidate))
-                    return true;
-            }
-            catch {
-                /* skip */
-            }
-        }
-        return false;
-    }
-    if (hasBin("spectral")) {
-        return { command: "spectral", args: subagentArgs };
-    }
-    if (hasBin("pi")) {
-        return { command: "pi", args: subagentArgs };
-    }
-    // Last resort: use node with pi from node_modules (matches pi's own fallback)
-    return { command: "pi", args: subagentArgs };
-}
 // ---------------------------------------------------------------------------
-// Core — run a single subagent
+// Core — run a single subagent in-process via agentLoop
 // ---------------------------------------------------------------------------
-async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails) {
+async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails, pi, ctx) {
     const agent = agents.find((a) => a.name === agentName);
     if (!agent) {
         const available = agents.map((a) => `"${a.name}"`).join(", ") || "none";
@@ -175,13 +190,47 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, si
             step,
         };
     }
-    const args = ["--mode", "json", "-p", "--no-session"];
-    if (agent.model)
-        args.push("--model", agent.model);
-    if (agent.tools && agent.tools.length > 0)
-        args.push("--tools", agent.tools.join(","));
-    let tmpPromptDir = null;
-    let tmpPromptPath = null;
+    // Build combined system prompt: main agent's + subagent's
+    const mainSystemPrompt = ctx.getSystemPrompt();
+    const combinedPrompt = mainSystemPrompt
+        ? `${mainSystemPrompt}\n\n---\n\nSubagent: ${agent.name}\n${agent.systemPrompt}`
+        : agent.systemPrompt;
+    // Resolve model — session model preferred, agent-configured as fallback
+    const sessionModel = ctx.model && ctx.modelRegistry.hasConfiguredAuth(ctx.model) ? ctx.model : undefined;
+    const model = sessionModel ?? resolveModelString(agent.model, ctx.modelRegistry);
+    if (!model) {
+        return {
+            agent: agentName,
+            agentSource: agent.source,
+            task,
+            exitCode: 1,
+            messages: [],
+            stderr: `Cannot resolve model "${agent.model ?? "(none specified)"}". Make sure the model is configured.`,
+            usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+            model: agent.model,
+            step,
+            errorMessage: `Model not found: ${agent.model ?? "unspecified"}`,
+        };
+    }
+    // Resolve auth for the model
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+    if (!auth.ok || !auth.apiKey) {
+        return {
+            agent: agentName,
+            agentSource: agent.source,
+            task,
+            exitCode: 1,
+            messages: [],
+            stderr: `No API key configured for model "${model.provider}/${model.id}".`,
+            usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+            model: agent.model,
+            step,
+            errorMessage: `No API key for ${model.provider}/${model.id}`,
+        };
+    }
+    // Resolve tools
+    const effectiveCwd = cwd ?? defaultCwd;
+    const tools = resolveSubagentTools(agent.tools, effectiveCwd, pi, ctx);
     const currentResult = {
         agent: agentName,
         agentSource: agent.source,
@@ -190,7 +239,7 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, si
         messages: [],
         stderr: "",
         usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
-        model: agent.model,
+        model: model.id,
         step,
     };
     const emitUpdate = () => {
@@ -202,113 +251,79 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, si
         }
     };
     try {
-        if (agent.systemPrompt.trim()) {
-            const tmp = await writePromptToTempFile(agent.name, agent.systemPrompt);
-            tmpPromptDir = tmp.dir;
-            tmpPromptPath = tmp.filePath;
-            args.push("--append-system-prompt", tmpPromptPath);
-        }
-        args.push(`Task: ${task}`);
-        let wasAborted = false;
-        const exitCode = await new Promise((resolve) => {
-            const invocation = getPiInvocation(args);
-            const proc = spawn(invocation.command, invocation.args, {
-                cwd: cwd ?? defaultCwd,
-                shell: false,
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-            let buffer = "";
-            const processLine = (line) => {
-                if (!line.trim())
-                    return;
-                let event;
-                try {
-                    event = JSON.parse(line);
-                }
-                catch {
-                    return;
-                }
-                if (event.type === "message_end" && event.message) {
-                    const msg = event.message;
-                    currentResult.messages.push(msg);
-                    if (msg.role === "assistant") {
-                        currentResult.usage.turns++;
-                        const usage = msg.usage;
-                        if (usage) {
-                            currentResult.usage.input += usage.input || 0;
-                            currentResult.usage.output += usage.output || 0;
-                            currentResult.usage.cacheRead += usage.cacheRead || 0;
-                            currentResult.usage.cacheWrite += usage.cacheWrite || 0;
-                            currentResult.usage.cost += usage.cost?.total || 0;
-                            currentResult.usage.contextTokens = usage.totalTokens || 0;
-                        }
-                        if (!currentResult.model && msg.model)
-                            currentResult.model = msg.model;
-                        if (msg.stopReason)
-                            currentResult.stopReason = msg.stopReason;
-                        if (msg.errorMessage)
-                            currentResult.errorMessage = msg.errorMessage;
+        const config = {
+            model,
+            apiKey: auth.apiKey,
+            headers: auth.headers,
+            convertToLlm: (msgs) => msgs.filter((m) => m.role === "user" || m.role === "assistant" || m.role === "toolResult"),
+            toolExecution: "parallel",
+        };
+        const stream = agentLoop([{ role: "user", content: [{ type: "text", text: task }], timestamp: Date.now() }], {
+            systemPrompt: combinedPrompt,
+            messages: [],
+            tools,
+        }, config, signal);
+        // Collect messages from the stream
+        const collectedMessages = [];
+        let hadError = false;
+        for await (const event of stream) {
+            if (signal?.aborted) {
+                hadError = true;
+                break;
+            }
+            if (event.type === "message_end" && event.message) {
+                const msg = event.message;
+                collectedMessages.push(msg);
+                if (msg.role === "assistant") {
+                    currentResult.usage.turns++;
+                    const usage = msg.usage;
+                    if (usage) {
+                        currentResult.usage.input += usage.input || 0;
+                        currentResult.usage.output += usage.output || 0;
+                        currentResult.usage.cacheRead += usage.cacheRead || 0;
+                        currentResult.usage.cacheWrite += usage.cacheWrite || 0;
+                        currentResult.usage.cost += usage.cost?.total || 0;
+                        currentResult.usage.contextTokens = usage.totalTokens || 0;
+                    }
+                    if (!currentResult.model && msg.model)
+                        currentResult.model = msg.model;
+                    if (msg.stopReason)
+                        currentResult.stopReason = msg.stopReason;
+                    if (msg.errorMessage)
+                        currentResult.errorMessage = msg.errorMessage;
+                    if (msg.stopReason === "error" || msg.stopReason === "aborted") {
+                        hadError = true;
                     }
-                    emitUpdate();
-                }
-                if (event.type === "tool_result_end" && event.message) {
-                    currentResult.messages.push(event.message);
-                    emitUpdate();
                 }
-            };
-            proc.stdout.on("data", (data) => {
-                buffer += data.toString();
-                const lines = buffer.split("\n");
-                buffer = lines.pop() || "";
-                for (const line of lines)
-                    processLine(line);
-            });
-            proc.stderr.on("data", (data) => {
-                currentResult.stderr += data.toString();
-            });
-            proc.on("close", (code) => {
-                if (buffer.trim())
-                    processLine(buffer);
-                resolve(code ?? 0);
-            });
-            proc.on("error", () => {
-                resolve(1);
-            });
-            if (signal) {
-                const killProc = () => {
-                    wasAborted = true;
-                    proc.kill("SIGTERM");
-                    setTimeout(() => {
-                        if (!proc.killed)
-                            proc.kill("SIGKILL");
-                    }, 5000);
-                };
-                if (signal.aborted)
-                    killProc();
-                else
-                    signal.addEventListener("abort", killProc, { once: true });
+                currentResult.messages = [...collectedMessages];
+                emitUpdate();
+            }
+            if (event.type === "tool_execution_end" && event.isError) {
+                emitUpdate();
             }
-        });
-        currentResult.exitCode = exitCode;
-        if (wasAborted)
-            throw new Error("Subagent was aborted");
+        }
+        // Drain the stream result (already consumed by iteration, but ensure cleanup)
+        try {
+            await stream.result();
+        }
+        catch {
+            // Stream result error — already handled by message events
+        }
+        currentResult.exitCode = hadError ? 1 : 0;
+        if (signal?.aborted) {
+            currentResult.exitCode = 1;
+            currentResult.stopReason = "aborted";
+            currentResult.errorMessage = "Subagent was aborted";
+        }
         return currentResult;
     }
-    finally {
-        if (tmpPromptPath)
-            try {
-                fs.unlinkSync(tmpPromptPath);
-            }
-            catch {
-                /* ignore */
-            }
-        if (tmpPromptDir)
-            try {
-                fs.rmdirSync(tmpPromptDir);
-            }
-            catch {
-                /* ignore */
-            }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        currentResult.exitCode = 1;
+        currentResult.stopReason = "error";
+        currentResult.errorMessage = errorMsg;
+        currentResult.stderr = errorMsg;
+        return currentResult;
     }
 }
 // ---------------------------------------------------------------------------
@@ -443,7 +458,7 @@ export default function subagentExtension(pi) {
                             }
                         }
                         : undefined;
-                    const result = await runSingleAgent(ctx.cwd, agents, step.agent, taskWithContext, step.cwd, i + 1, signal, chainUpdate, makeDetails("chain"));
+                    const result = await runSingleAgent(ctx.cwd, agents, step.agent, taskWithContext, step.cwd, i + 1, signal, chainUpdate, makeDetails("chain"), pi, ctx);
                     results.push(result);
                     const isError = result.exitCode !== 0 ||
                         result.stopReason === "error" ||
@@ -521,7 +536,7 @@ export default function subagentExtension(pi) {
                             allResults[index] = partial.details.results[0];
                             emitParallelUpdate();
                         }
-                    }, makeDetails("parallel"));
+                    }, makeDetails("parallel"), pi, ctx);
                     allResults[index] = result;
                     emitParallelUpdate();
                     return result;
@@ -544,7 +559,7 @@ export default function subagentExtension(pi) {
             }
             // ── Single mode ─────────────────────────────────────────────
             if (params.agent && params.task) {
-                const result = await runSingleAgent(ctx.cwd, agents, params.agent, params.task, params.cwd, undefined, signal, onUpdate, makeDetails("single"));
+                const result = await runSingleAgent(ctx.cwd, agents, params.agent, params.task, params.cwd, undefined, signal, onUpdate, makeDetails("single"), pi, ctx);
                 const isError = result.exitCode !== 0 ||
                     result.stopReason === "error" ||
                     result.stopReason === "aborted";

package/dist/commands/serve.js

@@ -181,9 +181,6 @@ export async function runServe(opts = {}) {
         backendUrl,
         machineJwt: registration.record.machineJwt,
         bridgeFactory: opts.bridgeFactory,
-        titleLlmCall: opts.titleLlmCall,
-        disableAutoTitle: opts.disableAutoTitle,
-        publishMetaEvent: deferredPublishMetaEvent,
     });
     if (!silent) {
         const action = registration.reused ? "Reusing" : "Registered";

package/dist/designer/data/systems/renault/DESIGN.md

@@ -25,7 +25,7 @@ Typography is unified under NouvelR — a proprietary geometric sans-serif desig
 ## 2. Color Palette & Roles
 
 ### Primary
-- **Renault Yellow** (`#EFDF00`): The brand's signature Pantone — a vivid, saturated yellow used for super-primary CTAs and the highest-priority action buttons. Appears as `--CtaLink-background-color` on `.is-cta-super-primary` class. Carries the energy of the diamond logo
+- **Renault Yellow** (`#EFDF00`): The brand's signature Pantone — a vivid, saturated yellow used for super-primary CTAs and the highest-priority action buttons. Appears as `--CtaButton-background-color` on `.is-cta-super-primary` class. Carries the energy of the diamond logo
 - **Absolute Black** (`#000000`): Primary button background, heading text on light surfaces, and the dominant dark section surface. The structural anchor of the entire interface
 - **Pure White** (`#FFFFFF`): Primary surface for editorial content, inverted button backgrounds, hero text color, and the dominant light-mode canvas (--rt-color-white)