@evandu/super-pi 0.1.135 → 0.1.137

package/dist/server/active-memory.js

@@ -9,6 +9,13 @@ export class ActiveMemory {
     inverted = new Map();
     indexedWorkspaces = new Set();
     indexedMessages = new Set();
+    /**
+     * messageId -> which workspace's index holds it and under which terms. This is the reverse side of
+     * `inverted`, and it is what makes removal surgical: a revert knows exactly which messages it cut
+     * (the store's `plan.removedMessageIds`), so exactly those postings can be dropped - the rest of the
+     * workspace stays indexed instead of paying a full rebuild on the next search.
+     */
+    termsByMessage = new Map();
     notes;
     capabilities = new Map();
     reviews = new Map();
@@ -132,13 +139,19 @@ export class ActiveMemory {
         if (this.indexedWorkspaces.has(workspaceId))
             return;
         const index = new Map();
-        for (const conversation of this.store.snapshot().conversations.filter(c => c.workspaceId === workspaceId))
+        const store = this.store;
+        const conversations = store.conversationsForWorkspace
+            ? store.conversationsForWorkspace(workspaceId)
+            : store.snapshot().conversations.filter(c => c.workspaceId === workspaceId);
+        for (const conversation of conversations)
             for (const message of conversation.messages) {
                 if (message.role !== "user" && message.role !== "assistant")
                     continue;
                 const value = { conversationId: conversation.id, title: conversation.title, messageId: message.id, role: message.role, content: message.content };
                 this.indexedMessages.add(message.id);
-                for (const word of message.content.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu) ?? []) {
+                const terms = message.content.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu) ?? [];
+                this.termsByMessage.set(message.id, { workspaceId, terms });
+                for (const word of terms) {
                     let bucket = index.get(word);
                     if (!bucket)
                         index.set(word, bucket = new Map());
@@ -149,7 +162,7 @@ export class ActiveMemory {
         this.indexedWorkspaces.add(workspaceId);
     }
     /**
-     * Drops a workspace's search index so the next search rebuilds it from the store.
+     * Drops exactly the given messages from the search index, leaving the rest of the workspace indexed.
      *
      * WHY THIS EXISTS. `ensureIndex` builds once per workspace and `addToIndex` only ever adds, so the
      * index outlives the messages it indexed: a revert removes messages from the store while the index
@@ -158,17 +171,54 @@ export class ActiveMemory {
      * history" after a revert every file-level assertion proved had really truncated. The store is the
      * source of truth; the index is a cache of it, and a cache that survives an event that invalidated
      * its source is wrong by definition.
+     *
+     * WHY SURGICAL. The caller (revert) knows precisely which message ids the store dropped, and this
+     * method trusts that list rather than re-deriving it: the ids not in `termsByMessage` were never
+     * indexed (no search had built the index, or a role the index skips), so a no-op for them is
+     * correct, and the next search - if the index was never built - builds from the post-revert store
+     * anyway. Dropping the whole workspace index instead would force the next search to rebuild every
+     * surviving conversation's entries for no reason, and the recall gap in between would answer
+     * searches with nothing at all.
      */
-    invalidateSearchIndex(workspaceId) {
-        this.indexedWorkspaces.delete(workspaceId);
-        this.inverted.delete(workspaceId);
+    removeFromIndex(messageIds) {
+        for (const messageId of messageIds) {
+            const entry = this.termsByMessage.get(messageId);
+            if (!entry)
+                continue;
+            const terms = this.inverted.get(entry.workspaceId);
+            if (terms) {
+                for (const term of entry.terms) {
+                    const bucket = terms.get(term);
+                    if (!bucket)
+                        continue;
+                    bucket.delete(messageId);
+                    if (!bucket.size)
+                        terms.delete(term);
+                }
+            }
+            this.termsByMessage.delete(messageId);
+            this.indexedMessages.delete(messageId);
+        }
     }
     addToIndex(conversation, message) {
         if (!this.indexedWorkspaces.has(conversation.workspaceId) || (message.role !== "user" && message.role !== "assistant"))
             return;
         let terms = this.inverted.get(conversation.workspaceId);
         const value = { conversationId: conversation.id, title: conversation.title, messageId: message.id, role: message.role, content: message.content };
-        for (const term of message.content.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu) ?? []) {
+        const messageTerms = message.content.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu) ?? [];
+        // A REFRESH MUST ALSO FORGET THE OLD TERMS. The buckets map a term to the message that contains
+        // it, and a term that only the OLD content had would keep pointing at this message with a stale
+        // copy - so a search for a word the model has since dropped would still hand the reader the old
+        // text. The terms this message had are remembered exactly so they can be dropped here.
+        const previous = this.termsByMessage.get(message.id);
+        if (previous)
+            for (const term of previous.terms) {
+                const bucket = terms.get(term);
+                if (bucket)
+                    bucket.delete(message.id);
+            }
+        this.termsByMessage.set(message.id, { workspaceId: conversation.workspaceId, terms: messageTerms });
+        for (const term of messageTerms) {
             let bucket = terms.get(term);
             if (!bucket)
                 terms.set(term, bucket = new Map());
@@ -270,6 +320,21 @@ export class ActiveMemory {
         this.cancel(id); }
     async waitForIdle() { await Promise.allSettled([...this.workspaceReviews.values()]); await this.serial; }
     async completed(conversation) {
+        // REFRESH THIS TURN'S MESSAGES, DO NOT JUST FILL IN THE UNSEEN ONES.
+        //
+        // The index is a CACHE of the store's content, and an assistant message's content changes while
+        // the model is still writing it: the entry was built from the empty placeholder the turn opened
+        // with, so it holds the answer BEFORE the answer. "I have seen this message" is not "I have seen
+        // its final content" - treating the two as the same froze this turn's answer in the index, and a
+        // frozen answer is an answer that can never be recalled (measured by
+        // scripts/active-memory-index-content.test.mjs: the recall came back `undefined`).
+        //
+        // Only THIS TURN's messages are refreshed - the ones after the last user message. The rest of the
+        // transcript was indexed when it was final, and re-tokenizing a whole conversation on every turn
+        // end is exactly the cost this file is about.
+        const lastUserIndex = conversation.messages.map((message) => message.role).lastIndexOf("user");
+        for (const message of lastUserIndex >= 0 ? conversation.messages.slice(lastUserIndex + 1) : conversation.messages)
+            this.addToIndex(conversation, message);
         for (const message of conversation.messages)
             if (!this.indexedMessages.has(message.id))
                 this.addToIndex(conversation, message);
@@ -301,7 +366,10 @@ export class ActiveMemory {
             const settings = await this.configuration();
             if (!settings.enabled || !settings.reviewInterval)
                 return;
-            const workspace = this.store.snapshot().workspaces.find(w => w.id === snapshot.workspaceId);
+            const store = this.store;
+            const workspace = store.workspace
+                ? store.workspace(snapshot.workspaceId)
+                : store.snapshot().workspaces.find(w => w.id === snapshot.workspaceId);
             if (!workspace)
                 return;
             const agent = await this.runtime.agentFor?.(snapshot);

package/dist/server/application/catalog-service.js

@@ -1,4 +1,4 @@
-import { assertModelAllowed, conversationWorkspace } from "../model-filter.js";
+import { assertModelAllowed } from "../model-filter.js";
 import { readAgents, resolveAgentDirectories } from "../agents.js";
 import { loadPromptTemplateSummaries } from "../pi-session.js";
 function summarize(agent) {
@@ -75,10 +75,12 @@ export class CatalogService {
         const catalog = await this.runtime.catalog(selection);
         if (!conversationId || !this.store)
             return catalog;
-        const state = this.store.snapshot();
-        const workspace = conversationWorkspace(state, conversationId);
+        const workspace = this.store.workspaceForConversation(conversationId);
+        if (!workspace)
+            throw new Error("会话所属工作区不存在");
+        const rules = this.store.modelFilterRules();
         return { ...catalog, models: catalog.models.filter(model => { try {
-                assertModelAllowed(state.modelFilterRules, workspace, model);
+                assertModelAllowed(rules, workspace, model);
                 return true;
             }
             catch {
@@ -108,7 +110,7 @@ export class CatalogService {
             throw new Error("Store unavailable");
         await this.store.setModelFilterRules(rules);
         this.broadcaster.broadcastState();
-        for (const conversation of this.store.snapshot().conversations) {
+        for (const conversation of this.store.catalogConversationTargets()) {
             if (!conversation.archivedAt) {
                 try {
                     await this.broadcastCatalog(conversation.model, conversation.id);
@@ -182,7 +184,7 @@ export class CatalogService {
         const cached = this.promptCatalogs.get(workspaceId);
         if (cached && cached.expiresAt > Date.now())
             return cached.catalog;
-        const workspace = this.store?.snapshot().workspaces.find((item) => item.id === workspaceId);
+        const workspace = this.store?.workspace(workspaceId);
         if (!workspace)
             return { source: "unavailable", prompts: [], workspaceId, fetchedAt: new Date().toISOString(), error: "workspace not found" };
         try {

package/dist/server/application/conversation-service.js

@@ -359,8 +359,10 @@ export class ConversationService {
         // The recall index is a cache of the store's messages, and the store just lost several: left alone it
         // keeps answering the memory extension's searches with the withdrawn turns, so the model is told about
         // history the person reverted away even though the transcript, Pi's file and the memory store all
-        // agree it is gone. Invalidate it and the next search rebuilds from what actually survived.
-        this.memory?.invalidateSearchIndex(workspaceId);
+        // agree it is gone. The store's plan says exactly which message ids were dropped, so exactly those
+        // postings leave the index - the surviving conversations of this workspace stay indexed and the next
+        // search pays no rebuild.
+        this.memory?.removeFromIndex(applied.removedMessageIds);
         console.log(`Super Pi: reverted conversation ${conversationId} to ${applied.boundaryIndex + 1} message(s): ` +
             `${plan.removedMessageIds.length} message(s) and ${applied.doomedRunIds.length} sub-agent run(s) dropped from state.json; ` +
             `Pi's file ${outcome.sessionFile} kept ${outcome.linesKept} line(s) and lost ${outcome.entriesDropped}; ` +

package/dist/server/application/scheduled-task-service.d.ts

@@ -147,6 +147,13 @@ export declare class ScheduledTaskService {
      * one that has to use it. A failure here is the task's failure - a model that Pi no longer offers
      * cannot be silently ignored, because the run would then happen on some other model and the panel
      * would say it succeeded.
+     *
+     * AND WHEN THERE IS NO OVERRIDE, THE DEFAULTS BEHIND IT GO ON THE CONVERSATION TOO. Clearing the
+     * override in the panel means 「跟着工作区默认走」, and the only way to honour that on a conversation
+     * that already ran with the override is to PUT THE DEFAULT BACK. The conversation's model is a
+     * copy-at-birth value (AGENTS.md: 建会话时把默认值盖到会话字段上，之后永不回查工作区), so "do
+     * nothing when there is no override" keeps the WITHDRAWN override pinned for good - and the panel
+     * says the run succeeded on a model the user just took away.
      */
     private applyConfiguration;
     /** Writes down how the run went, and tells the panel. */

package/dist/server/application/scheduled-task-service.js

@@ -302,14 +302,23 @@ export class ScheduledTaskService {
      * one that has to use it. A failure here is the task's failure - a model that Pi no longer offers
      * cannot be silently ignored, because the run would then happen on some other model and the panel
      * would say it succeeded.
+     *
+     * AND WHEN THERE IS NO OVERRIDE, THE DEFAULTS BEHIND IT GO ON THE CONVERSATION TOO. Clearing the
+     * override in the panel means 「跟着工作区默认走」, and the only way to honour that on a conversation
+     * that already ran with the override is to PUT THE DEFAULT BACK. The conversation's model is a
+     * copy-at-birth value (AGENTS.md: 建会话时把默认值盖到会话字段上，之后永不回查工作区), so "do
+     * nothing when there is no override" keeps the WITHDRAWN override pinned for good - and the panel
+     * says the run succeeded on a model the user just took away.
      */
     async applyConfiguration(task, conversationId) {
-        if (task.model) {
-            await this.conversationService.setModel(conversationId, task.model.provider, task.model.modelId);
-        }
-        if (task.agentId) {
-            await this.conversationService.setAgent(conversationId, task.agentId);
+        const state = this.store.snapshot();
+        const workspace = state.workspaces.find((item) => item.id === task.workspaceId);
+        const model = task.model ?? workspace?.defaultModel ?? state.defaultModel;
+        if (model) {
+            await this.conversationService.setModel(conversationId, model.provider, model.modelId);
         }
+        const agentId = task.agentId ?? workspace?.defaultAgentId ?? null;
+        await this.conversationService.setAgent(conversationId, agentId);
     }
     /** Writes down how the run went, and tells the panel. */
     async record(task, outcome) {

package/dist/server/files.js

@@ -650,7 +650,17 @@ export async function writeWorkspaceFile(root, requested, content, baseEtag) {
             throw new FilesError(415, "拒绝写入：内容包含二进制字节（\\0）", "binary");
         const original = await readFile(target);
         const hadBom = original.length >= 3 && original[0] === 0xef && original[1] === 0xbb && original[2] === 0xbf;
-        const output = hadBom ? `\uFEFF${content}` : content;
+        // THE LINE ENDINGS THE FILE HAD, NOT THE ONES THE EDITOR NORMALIZED.
+        //
+        // CodeMirror's document is always LF (it splits lines on `/\r\n?|\n/`), so a CRLF file comes back
+        // from the editor as LF text - and writing that back is how one edited character turns into a
+        // whole-file diff, on Windows, in every repository with `core.autocrlf=true`. The contract in this
+        // file already says it ("a CRLF file is saved back as CRLF instead of silently rewritten to LF");
+        // it just was not implemented HERE: the BOM's byte-level convention was honoured two lines above
+        // and the EOL's was dropped.
+        const eol = original.includes("\r\n") ? "\r\n" : "\n";
+        const body = eol === "\r\n" ? content.replace(/\r?\n/g, "\r\n") : content.replace(/\r\n/g, "\n");
+        const output = hadBom ? `\uFEFF${body}` : body;
         const temporary = await mkdtemp(`${target}.super-pi-${process.pid}-`);
         const temporaryFile = join(temporary, basename(target));
         try {

package/dist/server/http-server.d.ts

@@ -30,7 +30,4 @@ export interface HttpServerOptions {
     context: ServerContext;
     onShutdown: (reason: string) => Promise<void>;
 }
-/**
- * Creates the HTTP server providing static client assets and all `/api/*` endpoints.
- */
 export declare function createHttpServer(options: HttpServerOptions): NodeHttpServer;