@aexol/spectral 0.7.0 → 0.7.3

package/dist/server/pi-bridge.js

@@ -49,12 +49,14 @@
  *  instance is reused across `prompt()` calls).
  */
 import { createJiti } from "@mariozechner/jiti";
-import { AuthStorage, createAgentSession, DefaultResourceLoader, ModelRegistry, SessionManager, } from "@mariozechner/pi-coding-agent";
+import { AuthStorage, createAgentSession, DefaultResourceLoader, ModelRegistry, SessionManager, } from "../pi/coding-agent/index.js";
 import { randomUUID } from "node:crypto";
-import { existsSync } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { existsSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import aexolMcpExtension from "../extensions/aexol-mcp.js";
+import subagentExt from "../agent/index.js";
+import designerExtension from "../designer/index.js";
 import observationalMemory from "../memory/index.js";
 import { Runtime } from "../memory/runtime.js";
 import { OBSERVATIONAL_MEMORY_CONTEXT_CUSTOM_TYPE, OBSERVATIONAL_MEMORY_SNAPSHOT_CUSTOM_TYPE, } from "../memory/types.js";
@@ -73,6 +75,37 @@ import { fetchAllowedModels as defaultFetchAllowedModels, } from "../relay/model
 const SPECTRAL_PROXY_ANTHROPIC = "spectral-proxy-anthropic";
 const SPECTRAL_PROXY_OPENAI = "spectral-proxy-openai";
 const SPECTRAL_PROXY_USER_MODEL = "spectral-proxy-user-model";
+/**
+ * Walk ancestor directories from `cwd` up to the filesystem root, collecting
+ * any existing skill directories at the given relative paths (e.g.
+ * `.opencode/skills` or `.aexol/skills`).
+ *
+ * Directories are returned in order from the deepest ancestor to `cwd` so
+ * project-local skills override ancestor-level ones when there are name
+ * collisions (pi's skill loader keeps the first found).
+ */
+function collectAncestorSkillDirs(cwd, relativePaths) {
+    const found = [];
+    let dir = resolve(cwd);
+    while (true) {
+        for (const rel of relativePaths) {
+            const candidate = join(dir, rel);
+            try {
+                if (existsSync(candidate) && statSync(candidate).isDirectory()) {
+                    found.push(candidate);
+                }
+            }
+            catch {
+                // skip permission errors etc.
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return found;
+}
 /**
  * Concatenate text from an `AssistantMessage.content` array. Returns the
  * empty string when no text blocks are present (tool-only turns) or when
@@ -356,7 +389,7 @@ export class PiBridge {
     async start() {
         if (this.disposed)
             throw new Error("PiBridge already disposed");
-        const extensionFactories = [aexolMcpExtension, async (pi) => { observationalMemory(pi); }];
+        const extensionFactories = [aexolMcpExtension, async (pi) => { subagentExt(pi); }, async (pi) => { designerExtension(pi); }, async (pi) => { observationalMemory(pi); }];
         // Load pi-mcp-adapter via jiti so tsc never crawls its .ts files in
         // node_modules. The static `import` was causing tsc to type-check
         // pi-mcp-adapter's source and fail the build on its type errors.
@@ -380,15 +413,22 @@ export class PiBridge {
         // ResourceLoader with extensions wired in via factories.
         // Each factory's signature `(pi: ExtensionAPI) => Promise<void>` matches
         // the ExtensionFactory type exactly, so we can pass them directly.
+        //
+        // Skill discovery: pi's defaults scan ~/.pi/agent/skills/ (user),
+        // .pi/skills/ (project via CONFIG_DIR_NAME), and .agents/skills/
+        // (ancestor-walked). We additionally walk ancestors for
+        // .opencode/skills and .aexol/skills so OpenCode/Codex/Aexol skills
+        // work out of the box.
+        const extraSkillPaths = collectAncestorSkillDirs(this.opts.cwd, [".opencode/skills", ".aexol/skills"]);
         const resourceLoader = new DefaultResourceLoader({
             cwd: this.opts.cwd,
             agentDir: this.opts.agentDir ?? `${process.env.HOME ?? ""}/.pi/agent`,
             extensionFactories,
-            // Skip on-disk extension/skill discovery so the server is self-contained.
             noExtensions: false,
-            noSkills: true,
+            noSkills: false,
             noPromptTemplates: true,
             noThemes: true,
+            additionalSkillPaths: extraSkillPaths,
         });
         await resourceLoader.reload();
         // In-memory session: SQLite is our source of truth.
@@ -1029,6 +1069,27 @@ export class PiBridge {
                 return;
             }
             case "tool_execution_start": {
+                // Emit subagent_start for subagent tool invocations (Option B frontend panels).
+                if (ev.toolName === "subagent") {
+                    const args = ev.args;
+                    const mode = args?.chain?.length > 0 ? "chain"
+                        : args?.tasks?.length > 0 ? "parallel"
+                            : "single";
+                    const se = {
+                        type: "subagent_start",
+                        toolCallId: ev.toolCallId,
+                        mode,
+                        agent: typeof args?.agent === "string" ? args.agent : undefined,
+                        task: typeof args?.task === "string" ? args.task : undefined,
+                        taskCount: mode === "chain"
+                            ? args?.chain?.length
+                            : mode === "parallel"
+                                ? args?.tasks?.length
+                                : undefined,
+                        totalSteps: mode === "chain" ? args?.chain?.length : undefined,
+                    };
+                    this.emitAndBuffer(se);
+                }
                 this.emitAndBuffer({
                     type: "tool_call",
                     messageId: this.pending?.messageId ?? "",
@@ -1038,7 +1099,96 @@ export class PiBridge {
                 });
                 return;
             }
+            case "tool_execution_update": {
+                // Emit subagent_progress for subagent tool updates.
+                if (ev.toolName === "subagent") {
+                    const partialResult = ev.partialResult;
+                    const details = partialResult?.details;
+                    if (details?.results) {
+                        const mode = (details.mode ?? "single");
+                        const total = details.results.length;
+                        const done = details.results.filter(r => r.exitCode !== undefined && r.exitCode !== -1).length;
+                        const running = total - done;
+                        const currentAgent = details.results.find(r => r.exitCode === -1 || r.exitCode === undefined)?.agent;
+                        const se = {
+                            type: "subagent_progress",
+                            toolCallId: ev.toolCallId,
+                            mode,
+                            completedCount: done,
+                            totalCount: total,
+                            currentStep: mode === "chain" ? details.results[details.results.length - 1]?.step : undefined,
+                            currentAgent,
+                            message: mode === "parallel"
+                                ? `Parallel: ${done}/${total} done, ${running} running`
+                                : mode === "chain"
+                                    ? `Chain: step ${details.results.length}/${total}`
+                                    : `Running ${currentAgent ?? "subagent"}...`,
+                        };
+                        try {
+                            this.opts.emit(se);
+                        }
+                        catch { /* best-effort */ }
+                    }
+                }
+                return;
+            }
             case "tool_execution_end": {
+                // Emit subagent_end for subagent tool completions.
+                if (ev.toolName === "subagent") {
+                    const result = ev.result;
+                    const details = result?.details;
+                    if (details?.results && details.results.length > 0) {
+                        const mode = (details.mode ?? "single");
+                        const getOutput = (msgs) => {
+                            if (!msgs)
+                                return "(no output)";
+                            for (let i = msgs.length - 1; i >= 0; i--) {
+                                if (msgs[i].role === "assistant") {
+                                    for (const part of msgs[i].content) {
+                                        if (part.type === "text" && part.text)
+                                            return part.text;
+                                    }
+                                }
+                            }
+                            return "(no output)";
+                        };
+                        const results = details.results.map(r => ({
+                            agent: r.agent,
+                            agentSource: r.agentSource ?? "unknown",
+                            task: r.task,
+                            exitCode: r.exitCode,
+                            output: getOutput(r.messages),
+                            model: r.model,
+                            errorMessage: r.errorMessage,
+                            stopReason: r.stopReason,
+                            step: r.step,
+                            usage: {
+                                inputTokens: r.usage?.input ?? 0,
+                                outputTokens: r.usage?.output ?? 0,
+                                cacheReadTokens: r.usage?.cacheRead ?? 0,
+                                cacheWriteTokens: r.usage?.cacheWrite ?? 0,
+                                cost: r.usage?.cost ?? 0,
+                                turns: r.usage?.turns ?? 0,
+                            },
+                        }));
+                        const totalUsage = results.reduce((acc, r) => ({
+                            inputTokens: acc.inputTokens + r.usage.inputTokens,
+                            outputTokens: acc.outputTokens + r.usage.outputTokens,
+                            cacheReadTokens: acc.cacheReadTokens + r.usage.cacheReadTokens,
+                            cacheWriteTokens: acc.cacheWriteTokens + r.usage.cacheWriteTokens,
+                            cost: acc.cost + r.usage.cost,
+                            turns: acc.turns + r.usage.turns,
+                        }), { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, cost: 0, turns: 0 });
+                        const se = {
+                            type: "subagent_end",
+                            toolCallId: ev.toolCallId,
+                            mode,
+                            results,
+                            totalUsage,
+                        };
+                        this.emitAndBuffer(se);
+                    }
+                }
                 this.emitAndBuffer({
                     type: "tool_result",
                     messageId: this.pending?.messageId ?? "",

package/dist/server/session-stream.js

@@ -41,9 +41,9 @@ import { PiBridge } from "./pi-bridge.js";
 import { getMemoryState, isSourceEntry, rawTokensSinceLastBound, rawTokensSinceLastCompaction, } from "../memory/branch.js";
 import { observationPoolTokens, renderSummary } from "../memory/compaction.js";
 import { loadConfig } from "../memory/config.js";
+import { setProjectObsStore } from "../memory/project-observations-store.js";
 import { estimateStringTokens } from "../memory/tokens.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. */
 const MAX_LOOP_ITERATIONS = 100;
@@ -233,17 +233,7 @@ export class SessionStreamManager {
     machineJwt;
     bridgeFactory;
     agentDir;
-    titleLlmCall;
-    disableAutoTitle;
-    publishMetaEvent;
     streams = new Map();
-    /**
-     * Sessions for which we've already attempted (or queued) auto-title
-     * generation in this server process. Per-process is intentional: a server
-     * restart resets the set, but `isDefaultTitle()` still gates the work so a
-     * since-renamed session is never overwritten.
-     */
-    titleGenerationAttempted = new Set();
     disposed = false;
     constructor(opts) {
         this.store = opts.store;
@@ -252,9 +242,13 @@ export class SessionStreamManager {
         this.machineJwt = opts.machineJwt;
         this.bridgeFactory = opts.bridgeFactory ?? DEFAULT_BRIDGE_FACTORY;
         this.agentDir = opts.agentDir;
-        this.titleLlmCall = opts.titleLlmCall;
-        this.disableAutoTitle = opts.disableAutoTitle === true;
-        this.publishMetaEvent = opts.publishMetaEvent;
+        // Wire the project observations store singleton so the memory extension's
+        // read_project_observations tool can query cross-session observations.
+        setProjectObsStore({
+            insertProjectObservations: (pid, sid, obs, ts) => this.store.insertProjectObservations(pid, sid, obs, ts),
+            searchProjectObservations: (pid, q, limit) => this.store.searchProjectObservations(pid, q, limit),
+            getProjectByCwd: (cwd) => this.store.getProjectByCwd(cwd),
+        });
     }
     /**
      * Attach a subscriber to a session. Lazily creates the underlying pi
@@ -1130,8 +1124,30 @@ export class SessionStreamManager {
         }
         // Track compaction lifecycle so prompt() can block new messages while
         // compaction is running.
+        //
+        // Persist synthetic system messages so historic session replay (reconnect,
+        // page refresh) shows compaction events in the message timeline. These are
+        // broadcast live to connected subscribers AND persisted, so both live and
+        // historic sessions see them.
         if (event.type === "compaction_start") {
             stream.compacting = true;
+            const reasonLabel = event.reason === "manual"
+                ? "Manual compaction"
+                : event.reason === "overflow"
+                    ? "Context overflow"
+                    : "Context threshold";
+            const sysMsg = `${reasonLabel} — compacting conversation context…`;
+            try {
+                this.store.appendMessage(stream.sessionId, {
+                    role: "system",
+                    content: sysMsg,
+                    eventsJsonl: "",
+                    createdAt: Date.now(),
+                });
+            }
+            catch {
+                // best-effort; never block the stream on persistence
+            }
         }
         if (event.type === "compaction_end") {
             stream.compacting = false;
@@ -1139,6 +1155,25 @@ export class SessionStreamManager {
                 prunePersistedHistoryAfterCompaction(this.store, stream.sessionId, stream.bridge);
             }
             persistObservationalMemorySnapshot(this.store, stream.sessionId, stream.bridge);
+            const tokensMsg = typeof event.tokensBefore === "number"
+                ? ` (from ~${event.tokensBefore.toLocaleString()} tokens)`
+                : "";
+            const sysMsg = event.aborted
+                ? "Compaction aborted."
+                : event.summary
+                    ? `Compaction complete${tokensMsg}. Summary: ${event.summary}`
+                    : `Compaction complete${tokensMsg}.`;
+            try {
+                this.store.appendMessage(stream.sessionId, {
+                    role: "system",
+                    content: sysMsg,
+                    eventsJsonl: "",
+                    createdAt: Date.now(),
+                });
+            }
+            catch {
+                // best-effort
+            }
         }
         this.broadcast(stream, event);
         if (event.type === "agent_end") {
@@ -1151,11 +1186,6 @@ export class SessionStreamManager {
             stream.lastFlushedEventCount = 0;
             const finishedTurn = stream.currentTurn;
             stream.currentTurn = null;
-            // Fire-and-forget auto-title generation. Runs only once per session
-            // per server lifetime, only when the session is still wearing its
-            // default title, and never blocks the user's stream (the user's
-            // turn is already complete by the time this runs).
-            this.maybeGenerateTitle(stream, finishedTurn);
             // Autonomous iterative loop (Ralph Wiggum pattern).
             // When loopActive is set, check for completion marker, then re-send
             // the ORIGINAL prompt so the agent sees its prior changes and
@@ -1259,98 +1289,6 @@ export class SessionStreamManager {
             console.error(`[spectral] error: batch-persist flush failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
-    /**
-     * Auto-title the session if it's still wearing the default title and we
-     * haven't already attempted generation in this process. Fire-and-forget
-     * (errors are caught, logged, and swallowed) — the user's stream finished
-     * before this runs, so blocking would only delay the broadcast.
-     */
-    maybeGenerateTitle(stream, finishedTurn) {
-        if (this.disableAutoTitle)
-            return;
-        if (this.titleGenerationAttempted.has(stream.sessionId))
-            return;
-        // Check the persisted title now (manual rename takes precedence).
-        const detail = this.store.getSession(stream.sessionId);
-        if (!detail || !isDefaultTitle(detail.title))
-            return;
-        // Find the first user message + the assistant text from the just-finished
-        // turn. We deliberately read user content from SQLite (authoritative)
-        // and assistant content from the in-memory turn buffer (cheap, and
-        // matches what the user just saw).
-        const firstUser = detail.messages.find((m) => m.role === "user");
-        if (!firstUser || !firstUser.content.trim())
-            return;
-        let assistantText = finishedTurn?.assistantText ?? "";
-        if (!assistantText) {
-            // Fallback: pull the most recent assistant message from SQLite. This
-            // can happen if `agent_end` fires for a turn whose buffer was cleared
-            // by an intervening error event, or when this code path is reached
-            // via a synthetic test event.
-            const lastAssistant = [...detail.messages]
-                .reverse()
-                .find((m) => m.role === "assistant");
-            assistantText = lastAssistant?.content ?? "";
-        }
-        // Mark BEFORE awaiting so a second `agent_end` arriving while we're
-        // generating doesn't double-fire. Even if generation throws, we leave
-        // the entry in place — one-shot semantics, no retries.
-        this.titleGenerationAttempted.add(stream.sessionId);
-        void this.runTitleGeneration(stream, firstUser.content, assistantText);
-    }
-    async runTitleGeneration(stream, firstUserMessage, firstAssistantMessage) {
-        try {
-            const title = await generateSessionTitle(firstUserMessage, firstAssistantMessage, {
-                cwd: stream.cwd,
-                agentDir: this.agentDir,
-                llmCall: this.titleLlmCall,
-            });
-            if (this.disposed)
-                return;
-            if (!title)
-                return;
-            // Re-check the title hasn't been changed underneath us while we were
-            // waiting on the LLM (e.g. user manually renamed mid-generation).
-            const current = this.store.getSession(stream.sessionId);
-            if (!current || !isDefaultTitle(current.title))
-                return;
-            const updated = this.store.renameSession(stream.sessionId, title);
-            if (!updated)
-                return;
-            // Broadcast to every subscriber of this session so all open tabs
-            // update their sidebar in real time. The wire event is independent
-            // of the in-flight turn lifecycle, so it's safe to fire post-agent_end.
-            this.broadcast(stream, {
-                type: "session_renamed",
-                sessionId: stream.sessionId,
-                title: updated.title,
-            });
-            // Cross-tab fan-out hint: tabs that don't have THIS session open
-            // (and so don't have a per-session ws subscription) still want to
-            // refresh their sidebar to show the new title. Best-effort; a
-            // failed publish never undoes the rename.
-            if (this.publishMetaEvent) {
-                try {
-                    this.publishMetaEvent({
-                        type: "session_renamed",
-                        projectId: updated.projectId,
-                        sessionId: stream.sessionId,
-                    });
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    console.warn(`[spectral] warn: meta publish for auto-title failed: ${msg}`);
-                }
-            }
-        }
-        catch (err) {
-            // Defensive: generateSessionTitle already swallows LLM errors. This
-            // catches any unexpected throw from rename/broadcast so the manager
-            // is never destabilized by a background title task.
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[spectral] warn: auto-title pipeline failed: ${msg}`);
-        }
-    }
     broadcast(stream, event) {
         const dead = [];
         for (const sub of stream.subscribers) {
@@ -1378,7 +1316,10 @@ function isReplayable(event) {
         event.type === "tool_result" ||
         event.type === "message_end" ||
         event.type === "token_usage" ||
-        event.type === "error");
+        event.type === "error" ||
+        event.type === "subagent_start" ||
+        event.type === "subagent_progress" ||
+        event.type === "subagent_end");
 }
 function snapshotTurn(turn) {
     // Defensive copy of the events array so the snapshot can't be mutated by

package/dist/server/storage.js

@@ -78,6 +78,17 @@ CREATE TABLE IF NOT EXISTS session_memory_snapshots (
   covered_source_count INTEGER NOT NULL,
   updated_at INTEGER NOT NULL
 );
+
+CREATE TABLE IF NOT EXISTS project_observations (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  session_id TEXT NOT NULL,
+  content TEXT NOT NULL,
+  relevance TEXT NOT NULL CHECK (relevance IN ('low','medium','high','critical')),
+  created_at INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_project_obs_project ON project_observations(project_id, created_at DESC);
 `;
 /**
  * Synchronous binding-file reader for a project at the given filesystem path.
@@ -108,7 +119,7 @@ function applyBindingFields(project) {
     };
 }
 /** Tables we own — used by the migration drop step. */
-const KNOWN_TABLES = ["session_memory_snapshots", "messages", "sessions", "projects"];
+const KNOWN_TABLES = ["project_observations", "session_memory_snapshots", "messages", "sessions", "projects"];
 /** Best-effort parse of the `images_json` column into `ImageAttachment[]`. */
 function parseImagesJson(raw) {
     if (!raw || raw === "")
@@ -169,6 +180,10 @@ export class SessionStore {
     // Fork & Compact: flag + per-session source tracking.
     stmtSetForkCompactSource;
     stmtGetForkCompactSource;
+    // Project observations: cross-session durable memory.
+    stmtInsertProjectObs;
+    stmtSearchProjectObs;
+    stmtGetProjectByCwd;
     constructor(path) {
         this.path = path;
         // Make sure the parent directory exists. mkdirSync with recursive is a
@@ -307,6 +322,14 @@ export class SessionStore {
         this.stmtSetSessionModel = this.db.prepare(`UPDATE sessions SET model_id = ? WHERE id = ?`);
         this.stmtSetForkCompactSource = this.db.prepare(`UPDATE sessions SET fork_compact_source_id = ? WHERE id = ?`);
         this.stmtGetForkCompactSource = this.db.prepare(`SELECT fork_compact_source_id FROM sessions WHERE id = ?`);
+        this.stmtInsertProjectObs = this.db.prepare(`INSERT OR REPLACE INTO project_observations (id, project_id, session_id, content, relevance, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`);
+        this.stmtSearchProjectObs = this.db.prepare(`SELECT id, project_id, session_id, content, relevance, created_at
+       FROM project_observations
+       WHERE project_id = ? AND content LIKE ?
+       ORDER BY created_at DESC
+       LIMIT 20`);
+        this.stmtGetProjectByCwd = this.db.prepare(`SELECT id FROM projects WHERE path = ? LIMIT 1`);
     }
     /** Smoke check: returns the names of the tables in the DB. */
     listTables() {
@@ -653,6 +676,44 @@ export class SessionStore {
     clearForkCompactSource(sessionId) {
         this.stmtSetForkCompactSource.run(null, sessionId);
     }
+    // ----------------------------------------------------------------------
+    // Project observations (cross-session durable memory)
+    // ----------------------------------------------------------------------
+    /**
+     * Insert multiple project observations in a single transaction.
+     * Uses INSERT OR REPLACE so re-running after the same compaction is idempotent.
+     */
+    insertProjectObservations(projectId, sessionId, observations, createdAt) {
+        if (observations.length === 0)
+            return;
+        const tx = this.db.transaction(() => {
+            for (const obs of observations) {
+                this.stmtInsertProjectObs.run(obs.id, projectId, sessionId, obs.content, obs.relevance, createdAt);
+            }
+        });
+        tx();
+    }
+    /**
+     * Search project observations by substring match. Returns up to 20 most recent.
+     */
+    searchProjectObservations(projectId, query, limit = 20) {
+        const pattern = `%${query}%`;
+        const rows = this.stmtSearchProjectObs.all(projectId, pattern);
+        return rows.slice(0, limit).map((r) => ({
+            content: r.content,
+            relevance: r.relevance,
+            createdAt: r.created_at,
+            sessionId: r.session_id,
+        }));
+    }
+    /**
+     * Look up a project by its absolute filesystem path.
+     * Returns null when no project has been registered for the given path.
+     */
+    getProjectByCwd(cwd) {
+        const row = this.stmtGetProjectByCwd.get(cwd);
+        return row?.id ?? null;
+    }
     close() {
         if (this.closed)
             return;