@aexol/spectral 0.6.1 → 0.6.3

package/dist/commands/serve.js

@@ -38,7 +38,7 @@ import { fileURLToPath } from "node:url";
 import { getConfigDir } from "../config.js";
 import { requireLogin } from "../preflight.js";
 import { RelayClient } from "../relay/client.js";
-import { detachAllSubscribers, handleCancelTurn, handleClientMessage, handleRestRequest, handleSubscribe, } from "../relay/dispatcher.js";
+import { detachAllSubscribers, handleAutoResearchFrame, handleCancelTurn, handleClientMessage, handleRestRequest, handleSubscribe, } from "../relay/dispatcher.js";
 import { ensureMachineRegistered } from "../relay/registration.js";
 import { SessionStreamManager } from "../server/session-stream.js";
 import { gracefulShutdown } from "../server/shutdown.js";
@@ -260,6 +260,15 @@ export async function runServe(opts = {}) {
             handleCancelTurn(frame, { manager });
             return;
         }
+        if (frame.kind === "auto_research") {
+            handleAutoResearchFrame(frame, {
+                store,
+                manager,
+                relay,
+                cwd,
+            });
+            return;
+        }
         // Other frames (error, machine_disconnected addressed to us, etc.)
         // are ignored at this layer. Future batches may surface them in
         // structured logs.

package/dist/relay/auto-research.js

@@ -0,0 +1,498 @@
+/**
+ * Auto-research handler — spawns an isolated pi subprocess to analyze a
+ * project and generate custom extensions.
+ *
+ * Flow:
+ *   1. Resolve project path from the SQLite store
+ *   2. Load the auto-research agent definition (system prompt + model)
+ *   3. Write system prompt to a temp file (--append-system-prompt)
+ *   4. Spawn pi with --mode json -p --no-session --model <model> --append-system-prompt <tmp>
+ *   5. Pass the user task as a positional argument ("Task: ...")
+ *   6. Parse pi's JSON-line output: watch for message_end events on assistant
+ *      messages, extract the text, and interpret it as auto-research events
+ *      (progress / extension_generated / done / error)
+ *   7. Stream progress via the relay to the browser
+ *   8. On completion, emit `auto_research_complete` with generated extensions
+ *
+ * This mirrors the subagent extension's spawn pattern (agent/index.ts) so
+ * pi receives the task and system prompt in the same format it expects.
+ */
+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 { parseFrontmatter } from "@mariozechner/pi-coding-agent";
+/**
+ * Locate the auto-research agent definition markdown file.
+ * Searches project-level first, then user-level.
+ */
+function findAgentDef(projectPath) {
+    const candidates = [
+        path.join(projectPath, ".pi", "agents", "auto-research.md"),
+        path.join(os.homedir(), ".pi", "agent", "agents", "auto-research.md"),
+    ];
+    for (const filePath of candidates) {
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const { frontmatter, body } = parseFrontmatter(content);
+            if (body.trim().length === 0)
+                continue;
+            return {
+                model: frontmatter.model ?? "claude-sonnet-4-5",
+                systemPrompt: body,
+            };
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Detect the pi/spectral binary for spawning subprocesses.
+ * Mirrors the logic in `agent/index.ts#getPiInvocation`.
+ */
+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 };
+    }
+    return { command: "pi", args: subagentArgs };
+}
+/**
+ * Send a ServerEvent to the browser via the relay on the auto-research session.
+ */
+function sendEvent(deps, sessionId, event) {
+    deps.relay.send({
+        kind: "ws_event",
+        sessionId,
+        event,
+    });
+}
+/**
+ * Safely kill a child process. Best-effort — errors are silently swallowed.
+ */
+function killProcess(child) {
+    try {
+        if (!child.killed && child.exitCode === null) {
+            child.kill("SIGTERM");
+            setTimeout(() => {
+                try {
+                    if (!child.killed && child.exitCode === null) {
+                        child.kill("SIGKILL");
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }, 2000);
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+// ---------------------------------------------------------------------------
+// Phase mapping
+// ---------------------------------------------------------------------------
+const VALID_PHASES = new Set([
+    "context_collecting",
+    "context_analyzing",
+    "extension_generating",
+    "extension_validating",
+]);
+function mapPhase(agentPhase) {
+    if (VALID_PHASES.has(agentPhase)) {
+        return agentPhase;
+    }
+    return "context_analyzing";
+}
+// ---------------------------------------------------------------------------
+// Handler
+// ---------------------------------------------------------------------------
+const AR_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes — generous for LLM-based analysis
+/**
+ * Execute auto-research for a project.
+ *
+ * Caller (dispatcher) is fire-and-forget — this function is `void` and
+ * all errors are surfaced as `auto_research_error` events on the wire
+ * rather than thrown.
+ */
+export function handleAutoResearch(input, deps) {
+    const { projectId, sessionId } = input;
+    const { store } = deps;
+    const logger = deps.logger ?? console;
+    // 1. Resolve the project from the store.
+    const project = store.getProject(projectId);
+    if (!project) {
+        sendEvent(deps, sessionId, {
+            type: "auto_research_error",
+            projectId,
+            message: `Project not found: ${projectId}`,
+        });
+        return;
+    }
+    const projectPath = project.path;
+    // 2. Load the auto-research agent definition.
+    const agentDef = findAgentDef(projectPath);
+    if (!agentDef) {
+        sendEvent(deps, sessionId, {
+            type: "auto_research_error",
+            projectId,
+            message: "Auto-research agent definition not found. " +
+                "Create .pi/agents/auto-research.md in the project or ~/.pi/agent/agents/auto-research.md.",
+        });
+        return;
+    }
+    // 3. Emit start event
+    sendEvent(deps, sessionId, {
+        type: "auto_research_start",
+        projectId,
+    });
+    // 4. Write the system prompt to a temp file so pi can load it via
+    //    --append-system-prompt (mirrors the subagent extension pattern).
+    let tmpDir = null;
+    let tmpPromptPath = null;
+    try {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "spectral-auto-research-"));
+        tmpPromptPath = path.join(tmpDir, "system-prompt.md");
+        fs.writeFileSync(tmpPromptPath, agentDef.systemPrompt, { encoding: "utf-8", mode: 0o600 });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        sendEvent(deps, sessionId, {
+            type: "auto_research_error",
+            projectId,
+            message: `Failed to write system prompt temp file: ${msg}`,
+        });
+        if (tmpDir) {
+            try {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch { /* ignore */ }
+        }
+        return;
+    }
+    // 5. Build the user task. This becomes a positional argument to pi,
+    //    matching how the subagent extension passes tasks.
+    const task = buildUserTask(projectPath, project.name);
+    // 6. Build spawn arguments (mirroring agent/index.ts subprocess spawn).
+    const args = [
+        "--mode", "json",
+        "-p",
+        "--no-session",
+        "--model", agentDef.model,
+        "--append-system-prompt", tmpPromptPath,
+    ];
+    // Add tools if defined in the agent definition. The auto-research agent
+    // uses read/grep/find/ls/bash/write/edit — its frontmatter should declare
+    // them so pi allows those tools.
+    // We don't extract tools from frontmatter currently because parseFrontmatter
+    // returns a generic Record. For now, auto-research always uses the default
+    // tool set (pi's full tool set is available by default in -p mode).
+    // TODO: when agent def frontmatter parsing is unified with agents.ts, also
+    //       pass --tools here.
+    // The user task is the last positional argument — pi treats it as the
+    // initial prompt in -p mode.
+    args.push(`Task: ${task}`);
+    // 7. Spawn pi subprocess.
+    const invocation = getPiInvocation(args);
+    let child;
+    try {
+        child = spawn(invocation.command, invocation.args, {
+            cwd: projectPath,
+            stdio: ["ignore", "pipe", "pipe"], // stdin ignored — task is positional
+            env: { ...process.env },
+            shell: false,
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        sendEvent(deps, sessionId, {
+            type: "auto_research_error",
+            projectId,
+            message: `Failed to spawn pi subprocess: ${msg}`,
+        });
+        cleanupTemp(tmpDir);
+        return;
+    }
+    // 8. Set up timeout
+    const timeout = setTimeout(() => {
+        killProcess(child);
+        sendEvent(deps, sessionId, {
+            type: "auto_research_error",
+            projectId,
+            message: "Auto-research timed out after 5 minutes",
+        });
+        cleanupTemp(tmpDir);
+    }, AR_TIMEOUT_MS);
+    // 9. Collect stdout and parse pi's JSON-line output format.
+    //    pi in --mode json emits one JSON line per event:
+    //      {"type":"message_start",...}
+    //      {"type":"text_delta","content":"..."}
+    //      {"type":"message_end","message":{"role":"assistant","content":[{"type":"text","text":"..."}]}}
+    //      {"type":"agent_end",...}
+    //
+    //    The auto-research agent's output is inside assistant message_end
+    //    events. We extract the text and try to parse it as auto-research
+    //    event JSON (progress, extension_generated, done, error).
+    let stdoutBuffer = "";
+    const discoveredExtensions = [];
+    let stderrBuffer = "";
+    child.stdout?.on("data", (chunk) => {
+        stdoutBuffer += chunk.toString("utf-8");
+        // Process complete lines
+        const lines = stdoutBuffer.split("\n");
+        stdoutBuffer = lines.pop() ?? "";
+        for (const rawLine of lines) {
+            const line = rawLine.trim();
+            if (!line)
+                continue;
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                // Non-JSON output — ignore.
+                continue;
+            }
+            // Only process message_end events from the assistant.
+            if (event.type !== "message_end" || !event.message)
+                continue;
+            if (event.message.role !== "assistant")
+                continue;
+            const content = event.message.content;
+            if (!content || !Array.isArray(content) || content.length === 0)
+                continue;
+            // Extract text blocks from the assistant message
+            for (const block of content) {
+                if (block.type !== "text" || typeof block.text !== "string")
+                    continue;
+                // Try to parse the assistant's text output as one or more JSON
+                // auto-research events. The agent may output multiple JSON objects
+                // in a single assistant message (separated by newlines or
+                // concatenated). We try parsing the full text first, then fall
+                // back to line-by-line.
+                const text = block.text.trim();
+                // First, try treating the entire text block as a single event
+                let parsed = null;
+                try {
+                    parsed = JSON.parse(text);
+                }
+                catch {
+                    // Not a single JSON object — try line-by-line
+                }
+                if (parsed && parsed.type) {
+                    processArEvent(parsed, discoveredExtensions, projectId, sessionId, deps);
+                }
+                else {
+                    // Try each line individually (the agent may emit multi-line
+                    // JSON event output, e.g. one event per line).
+                    for (const subLine of text.split("\n")) {
+                        const trimmed = subLine.trim();
+                        if (!trimmed)
+                            continue;
+                        try {
+                            const eventLine = JSON.parse(trimmed);
+                            if (eventLine && eventLine.type) {
+                                processArEvent(eventLine, discoveredExtensions, projectId, sessionId, deps);
+                            }
+                        }
+                        catch {
+                            // skip non-JSON lines
+                        }
+                    }
+                }
+            }
+        }
+    });
+    child.stderr?.on("data", (chunk) => {
+        stderrBuffer += chunk.toString("utf-8");
+    });
+    // 10. Handle process exit
+    child.on("close", (code) => {
+        clearTimeout(timeout);
+        // Process any remaining buffered stdout (drain the buffer)
+        if (stdoutBuffer.trim()) {
+            try {
+                const event = JSON.parse(stdoutBuffer.trim());
+                if (event.type === "message_end" && event.message?.role === "assistant") {
+                    const content = event.message?.content;
+                    if (Array.isArray(content)) {
+                        for (const block of content) {
+                            if (block.type === "text" && typeof block.text === "string") {
+                                for (const subLine of block.text.split("\n")) {
+                                    const trimmed = subLine.trim();
+                                    if (!trimmed)
+                                        continue;
+                                    try {
+                                        const ar = JSON.parse(trimmed);
+                                        if (ar && ar.type) {
+                                            processArEvent(ar, discoveredExtensions, projectId, sessionId, deps);
+                                        }
+                                    }
+                                    catch {
+                                        /* skip */
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        if (code !== 0 && discoveredExtensions.length === 0) {
+            // Subprocess exited with error and no extensions were generated
+            const errDetail = stderrBuffer
+                ? ` (stderr: ${stderrBuffer.slice(0, 500)})`
+                : "";
+            sendEvent(deps, sessionId, {
+                type: "auto_research_error",
+                projectId,
+                message: `Auto-research subprocess exited with code ${code}${errDetail}`,
+            });
+            cleanupTemp(tmpDir);
+            return;
+        }
+        // Emit completion with any discovered extensions (even partial — the
+        // UI can show what was generated before the process died).
+        sendEvent(deps, sessionId, {
+            type: "auto_research_complete",
+            projectId,
+            extensions: discoveredExtensions,
+        });
+        // Log any stderr for debugging
+        if (stderrBuffer) {
+            logger.error?.(`[auto-research] subprocess stderr (code=${code}): ${stderrBuffer.slice(0, 1000)}`);
+        }
+        cleanupTemp(tmpDir);
+    });
+    child.on("error", (err) => {
+        clearTimeout(timeout);
+        sendEvent(deps, sessionId, {
+            type: "auto_research_error",
+            projectId,
+            message: `Auto-research subprocess error: ${err.message}`,
+        });
+        cleanupTemp(tmpDir);
+    });
+}
+// ---------------------------------------------------------------------------
+// Event processor
+// ---------------------------------------------------------------------------
+function processArEvent(parsed, extensions, projectId, sessionId, deps) {
+    const t = parsed.type;
+    if (t === "progress") {
+        const p = parsed;
+        const wirePhase = mapPhase(p.phase);
+        sendEvent(deps, sessionId, {
+            type: "auto_research_progress",
+            projectId,
+            phase: wirePhase,
+            message: p.message,
+        });
+    }
+    else if (t === "extension_generated") {
+        const eg = parsed;
+        extensions.push({
+            name: eg.name,
+            path: eg.path,
+            description: eg.description,
+            usesLLM: eg.usesLLM,
+            fileCount: eg.fileCount,
+        });
+        // Also emit as a progress update so the UI shows real-time activity
+        sendEvent(deps, sessionId, {
+            type: "auto_research_progress",
+            projectId,
+            phase: "extension_generating",
+            message: `Generated: ${eg.name}`,
+        });
+    }
+    else if (t === "done") {
+        const d = parsed;
+        for (const ext of d.extensions) {
+            extensions.push(ext);
+        }
+    }
+    else if (t === "error") {
+        const e = parsed;
+        sendEvent(deps, sessionId, {
+            type: "auto_research_progress",
+            projectId,
+            phase: "extension_validating",
+            message: `Error: ${e.message}`,
+        });
+    }
+    // Unknown event types are silently ignored for forward compatibility
+}
+// ---------------------------------------------------------------------------
+// Task builder
+// ---------------------------------------------------------------------------
+/**
+ * Build the user task prompt sent as positional argument to pi.
+ * The system prompt (from the agent definition) provides the detailed
+ * instructions; this is just the project-specific context.
+ */
+function buildUserTask(projectPath, projectName) {
+    return [
+        `Analyze the project at "${projectPath}" named "${projectName}" to determine`,
+        `what custom pi coding agent extensions would accelerate development.`,
+        ``,
+        `Follow your system prompt instructions for the full process:`,
+        `1. Context collection — scan the project structure`,
+        `2. Analysis — identify patterns and automation opportunities`,
+        `3. Extension generation — create .ts extension files`,
+        `4. Validation — verify the extensions are correct`,
+        ``,
+        `Important: Read the template library at .pi/agents/auto-research-templates.md`,
+        `if it exists, for ready-to-adapt extension templates.`,
+    ].join("\n");
+}
+// ---------------------------------------------------------------------------
+// Temp file cleanup
+// ---------------------------------------------------------------------------
+function cleanupTemp(tmpDir) {
+    if (!tmpDir)
+        return;
+    try {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+    catch {
+        // best-effort cleanup
+    }
+}

package/dist/relay/dispatcher.js

@@ -41,8 +41,9 @@
 import { BadRequestError, NotFoundError } from "../server/handlers/errors.js";
 import { handlePathAutocomplete } from "../server/handlers/paths-autocomplete.js";
 import { handleCreateProject, handleDeleteProject, handleListProjects, handleListSessionsByProject, handleUpdateProject, } from "../server/handlers/projects.js";
-import { handleCompactSession, handleCreateSession, handleDeleteSession, handleForkSession, handleGetSessionDetail, handleGetSessionMemoryStatus, handleUpdateSession, } from "../server/handlers/sessions.js";
+import { handleCompactSession, handleCreateSession, handleDeleteSession, handleForkSession, handleGetSessionDetail, handleGetSessionMemoryDetails, handleGetSessionMemoryStatus, handleUpdateSession, } from "../server/handlers/sessions.js";
 import { shutdownState } from "../server/shutdown.js";
+import { handleAutoResearch } from "./auto-research.js";
 /**
  * Inline path matcher. Returns `null` for any path/method combination we
  * don't recognise; the caller turns that into a `404 Unknown route`.
@@ -103,13 +104,15 @@ export function matchRoute(method, path) {
             return { route: "delete_session", id };
         return null;
     }
-    // /api/sessions/:id/memory and /api/sessions/:id/compact
-    const sessionActionMatch = /^\/api\/sessions\/([^/]+)\/(memory|compact)$/.exec(cleanPath);
+    // /api/sessions/:id/memory/details and /api/sessions/:id/memory and /api/sessions/:id/compact
+    const sessionActionMatch = /^\/api\/sessions\/([^/]+)\/(memory(?:\/details)?|compact)$/.exec(cleanPath);
     if (sessionActionMatch) {
         const id = decodeURIComponent(sessionActionMatch[1]);
         const action = sessionActionMatch[2];
         if (action === "memory" && method === "GET")
             return { route: "get_session_memory", id };
+        if (action === "memory/details" && method === "GET")
+            return { route: "get_session_memory_details", id };
         if (action === "compact" && method === "POST")
             return { route: "compact_session", id };
         return null;
@@ -269,6 +272,8 @@ async function dispatchRoute(match, body, deps) {
             return handleGetSessionDetail(store, id);
         case "get_session_memory":
             return handleGetSessionMemoryStatus(store, manager, id);
+        case "get_session_memory_details":
+            return handleGetSessionMemoryDetails(store, manager, id);
         case "update_session": {
             const session = handleUpdateSession(store, id, asObject(body));
             safePublish(publishMetaEvent, logger, {
@@ -627,3 +632,22 @@ export function detachAllSubscribers(manager, subscribers) {
     }
     subscribers.clear();
 }
+/**
+ * Dispatch an `auto_research` frame. Spawns an isolated pi subprocess that:
+ *   1. Collects project context (files, existing extensions, git state)
+ *   2. Analyzes the project using an LLM (via subagent)
+ *   3. Generates extension `.ts` files under `.pi/extensions/auto-research/`
+ *   4. Hot-reloads pi so new extensions take effect immediately
+ *
+ * Progress is streamed back as `ws_event` frames carrying
+ * `auto_research_*` ServerEvent types on the `sessionId` channel.
+ *
+ * Errors are surfaced as `auto_research_error` events; the underlying
+ * subprocess is killed on error to prevent zombie processes.
+ */
+export function handleAutoResearchFrame(frame, deps) {
+    handleAutoResearch({
+        projectId: frame.projectId,
+        sessionId: frame.sessionId,
+    }, deps);
+}

package/dist/server/handlers/sessions.js

@@ -46,6 +46,12 @@ export function handleGetSessionMemoryStatus(store, manager, id) {
         throw new NotFoundError("Session not found");
     return manager.getSessionMemoryStatus(id);
 }
+export function handleGetSessionMemoryDetails(store, manager, id) {
+    const detail = store.getSession(id);
+    if (!detail)
+        throw new NotFoundError("Session not found");
+    return manager.getSessionMemoryDetails(id);
+}
 export async function handleCompactSession(store, manager, id) {
     const detail = store.getSession(id);
     if (!detail)

package/dist/server/session-stream.js

@@ -42,7 +42,7 @@ import { getMemoryState, isSourceEntry, rawTokensSinceLastBound, rawTokensSinceL
 import { observationPoolTokens, renderSummary } from "../memory/compaction.js";
 import { loadConfig } from "../memory/config.js";
 import { estimateStringTokens } from "../memory/tokens.js";
-import { reflectionContent } from "../memory/types.js";
+import { reflectionContent, reflectionId } from "../memory/types.js";
 import { generateSessionTitle, isDefaultTitle, } from "./title-generator.js";
 const DEFAULT_BRIDGE_FACTORY = (args) => new PiBridge(args);
 /** Safety limit for autonomous loop iterations per session. */
@@ -373,6 +373,61 @@ export class SessionStreamManager {
         }
         return status;
     }
+    getSessionMemoryDetails(sessionId) {
+        const detail = this.store.getSession(sessionId);
+        if (!detail)
+            throw new Error(`Unknown sessionId: ${sessionId}`);
+        const stream = this.streams.get(sessionId);
+        const entries = stream?.bridge.getSessionBranch?.();
+        let observations = [];
+        let pendingObs = [];
+        let reflections = [];
+        let summary = null;
+        if (entries) {
+            const memoryState = getMemoryState(entries);
+            observations = memoryState.committedObs;
+            pendingObs = memoryState.pendingObs;
+            reflections = memoryState.reflections;
+            summary = renderSummary(reflections, [...observations, ...pendingObs]);
+        }
+        else {
+            const snapshot = this.store.getSessionMemorySnapshot(sessionId);
+            if (snapshot) {
+                observations = snapshot.details.observations;
+                reflections = snapshot.details.reflections;
+                summary = snapshot.summary;
+            }
+        }
+        const pendingIds = new Set(pendingObs.map((o) => o.id));
+        const wireObservations = [
+            ...observations.map((o) => ({
+                id: o.id,
+                content: o.content,
+                timestamp: o.timestamp,
+                relevance: o.relevance,
+                pending: false,
+            })),
+            ...pendingObs.map((o) => ({
+                id: o.id,
+                content: o.content,
+                timestamp: o.timestamp,
+                relevance: o.relevance,
+                pending: true,
+            })),
+        ];
+        const wireReflections = reflections.map((r) => ({
+            id: reflectionId(r) ?? "legacy",
+            content: reflectionContent(r),
+            supportingObservationIds: typeof r === "object" && "supportingObservationIds" in r
+                ? r.supportingObservationIds
+                : [],
+        }));
+        return {
+            summary,
+            observations: wireObservations,
+            reflections: wireReflections,
+        };
+    }
     async compactSession(sessionId) {
         if (this.disposed)
             throw new Error("SessionStreamManager disposed");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aexol/spectral",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Always-on coding agent for Aexol — branded pi wrapper with relay-based browser access.",
   "type": "module",
   "private": false,