@evandu/super-pi 0.1.135 → 0.1.136

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();
@@ -138,7 +145,9 @@ export class ActiveMemory {
                     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 +158,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 +167,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 +316,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);

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/model-filter.d.ts

@@ -6,8 +6,18 @@ export declare function applicableRules(rules: ModelFilterRule[] | undefined, wo
 export declare function assertModelAllowed(rules: ModelFilterRule[] | undefined, workspace: Workspace, model: ModelSelection | undefined): void;
 export declare function conversationWorkspace(state: AppState, conversationId: string): Workspace;
 /** Resolve Pi's actual global default when no model was selected; never guess a permitted replacement. */
-export declare function validateConversationModel(store: {
-    snapshot(): AppState;
-}, runtime: {
+/**
+ * THE STORE READS THIS NEEDS, AND NOTHING ELSE.
+ *
+ * The check wants two things: the rules, and the workspace the conversation is in. Both now have a
+ * narrow reader on the store (`modelFilterRules()` / `workspaceForConversation()`), so this path
+ * clones NOTHING - it used to deep-clone the whole application three times over, on the way to
+ * sending a message.
+ */
+export interface ModelFilterStore {
+    modelFilterRules(): import("./types.js").ModelFilterRule[];
+    workspaceForConversation(conversationId: string): Workspace | undefined;
+}
+export declare function validateConversationModel(store: ModelFilterStore, runtime: {
     catalog(selection?: ModelSelection): Promise<import("./types.js").ModelCatalog>;
 }, conversationId: string, selection?: ModelSelection): Promise<void>;

package/dist/server/model-filter.js

@@ -29,18 +29,20 @@ export function conversationWorkspace(state, conversationId) {
         throw new Error("会话所属工作区不存在");
     return workspace;
 }
-/** Resolve Pi's actual global default when no model was selected; never guess a permitted replacement. */
 export async function validateConversationModel(store, runtime, conversationId, selection) {
-    const state = store.snapshot();
-    const workspace = conversationWorkspace(state, conversationId);
-    if (!applicableRules(state.modelFilterRules, workspace).length)
+    const workspace = store.workspaceForConversation(conversationId);
+    if (!workspace)
+        throw new Error("会话所属工作区不存在");
+    if (!applicableRules(store.modelFilterRules(), workspace).length)
         return;
     const startedAt = performance.now();
     if (process.env.SUPER_PI_TRACE_LATENCY === "1")
         console.warn(`[super-pi latency] conversation=${conversationId} phase=model.validate.begin selection=${selection ? `${selection.provider}/${selection.modelId}` : "default"}`);
     const catalog = await runtime.catalog();
     const model = selection ? catalog.models.find(item => item.provider === selection.provider && item.modelId === selection.modelId) ?? selection : catalog.defaultModel;
-    assertModelAllowed(store.snapshot().modelFilterRules, conversationWorkspace(store.snapshot(), conversationId), model);
+    // READ AGAIN, NOT CACHED: the catalog fetch above is an await, and a rule edited during it must
+    // still be enforced for this message. The narrow readers make that re-read cheap.
+    assertModelAllowed(store.modelFilterRules(), store.workspaceForConversation(conversationId), model);
     if (process.env.SUPER_PI_TRACE_LATENCY === "1")
         console.warn(`[super-pi latency] conversation=${conversationId} phase=model.validate.end elapsedMs=${Math.round(performance.now() - startedAt)}`);
 }

package/dist/server/store.d.ts

@@ -96,6 +96,28 @@ export declare class Store {
     static open(filePath: string): Promise<Store>;
     /** Opens an injected repository, retaining domain reconciliation here. */
     static openRepository(repository: AppStateRepository): Promise<Store>;
+    /**
+     * THE MODEL FILTER RULES, WITHOUT CLONING THE STATE TO READ THEM.
+     *
+     * `snapshot()` deep-clones the WHOLE application - every workspace, every conversation, every
+     * message of every conversation - and the model filter check needs ONE small array. Reading that
+     * array through a full clone is the difference between a few hundred bytes and the entire
+     * transcript of the app, on the path that runs every time a message is sent.
+     *
+     * So the rules get their own narrow reader. It returns a COPY of the array (the caller may keep
+     * it, and the store's own state must not change under it), and the individual rules are treated
+     * as read-only - which is what the filter does with them.
+     */
+    modelFilterRules(): import("./types.js").ModelFilterRule[];
+    /**
+     * THE WORKSPACE A CONVERSATION BELONGS TO, WITHOUT CLONING THE STATE TO FIND ONE ROW.
+     *
+     * The same argument as the rules above: the filter needs to know WHICH workspace the conversation
+     * is in (the rules are per workspace), and the only way to know that today is to clone everything
+     * and look. This returns a shallow copy of the one workspace - cheap, and detached enough that a
+     * caller cannot reach into the store's state through it.
+     */
+    workspaceForConversation(conversationId: string): Workspace | undefined;
     setModelFilterRules(rules: import("./types.js").ModelFilterRule[]): Promise<void>;
     /**
      * Sets (or clears) the app-wide default model.

package/dist/server/store.js

@@ -689,6 +689,34 @@ export class Store {
             return new Store(repository, { workspaces: [], conversations: [], subagentRuns: [], backgroundTasks: [] });
         }
     }
+    /**
+     * THE MODEL FILTER RULES, WITHOUT CLONING THE STATE TO READ THEM.
+     *
+     * `snapshot()` deep-clones the WHOLE application - every workspace, every conversation, every
+     * message of every conversation - and the model filter check needs ONE small array. Reading that
+     * array through a full clone is the difference between a few hundred bytes and the entire
+     * transcript of the app, on the path that runs every time a message is sent.
+     *
+     * So the rules get their own narrow reader. It returns a COPY of the array (the caller may keep
+     * it, and the store's own state must not change under it), and the individual rules are treated
+     * as read-only - which is what the filter does with them.
+     */
+    modelFilterRules() {
+        return this.state.modelFilterRules ? [...this.state.modelFilterRules] : [];
+    }
+    /**
+     * THE WORKSPACE A CONVERSATION BELONGS TO, WITHOUT CLONING THE STATE TO FIND ONE ROW.
+     *
+     * The same argument as the rules above: the filter needs to know WHICH workspace the conversation
+     * is in (the rules are per workspace), and the only way to know that today is to clone everything
+     * and look. This returns a shallow copy of the one workspace - cheap, and detached enough that a
+     * caller cannot reach into the store's state through it.
+     */
+    workspaceForConversation(conversationId) {
+        const conversation = this.state.conversations.find((item) => item.id === conversationId);
+        const workspace = this.state.workspaces.find((item) => item.id === conversation?.workspaceId);
+        return workspace ? { ...workspace } : undefined;
+    }
     async setModelFilterRules(rules) {
         if (!Array.isArray(rules) || rules.some(rule => !rule || typeof rule.id !== "string" || typeof rule.workspacePattern !== "string" || typeof rule.modelPattern !== "string" || (rule.label !== undefined && typeof rule.label !== "string")))
             throw new Error("模型过滤规则格式不合法");

package/dist/server/subagents.js

@@ -421,8 +421,16 @@ export class SubagentSupervisor {
                     }
                     if (!record)
                         break;
-                    if (record.type === "response" && record.id === "prompt" && record.success === false)
-                        throw new Error(`Pi rejected the sub-agent task: ${record.error ?? "no reason given"}`);
+                    // THE RECEIPT FOR OUR OWN PROMPT IS A KNOWN RECORD, NOT AN UNKNOWN ONE. Pi answers every
+                    // command with `type:"response"`, so the successful receipt for the prompt we just wrote is
+                    // part of the protocol - and treating it as unrecognised made every ordinary sub-agent run
+                    // log a false alarm ("unhandled child record response - consumed without action"). A FAILED
+                    // receipt is the run's failure and is thrown; a successful one is simply consumed.
+                    if (record.type === "response" && record.id === "prompt") {
+                        if (record.success === false)
+                            throw new Error(`Pi rejected the sub-agent task: ${record.error ?? "no reason given"}`);
+                        continue;
+                    }
                     if (record.type === "message_update") {
                         const event = record.assistantMessageEvent;
                         // `text_delta` is the only inner event that is output. `start` and `done` are the boundaries

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.135",
+  "version": "0.1.136",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -76,6 +76,7 @@
     "scripts/workspace-cwd.test.mjs",
     "scripts/subagents.test.mjs",
     "scripts/subagent-noise.test.mjs",
+    "scripts/subagent-response-receipt.test.mjs",
     "scripts/subagent-runs.test.mjs",
     "scripts/conversation-reconcile.test.mjs",
     "scripts/subagent-dispatch.test.mjs",
@@ -110,6 +111,7 @@
     "scripts/todo-tool.test.mjs",
     "scripts/tool-calls.test.mjs",
     "scripts/files-api.test.mjs",
+    "scripts/files-eol-roundtrip.test.mjs",
     "scripts/files-missing-path.test.mjs",
     "scripts/file-changes.test.mjs",
     "scripts/file-index.test.mjs",
@@ -138,6 +140,7 @@
     "scripts/provider-pi-reads.test.mjs",
     "scripts/session-extension-credentials.test.mjs",
     "scripts/active-memory.test.mjs",
+    "scripts/active-memory-index-content.test.mjs",
     "scripts/knowledge-base.test.mjs",
     "scripts/knowledge-import-path.test.mjs",
     "scripts/knowledge-import-identity.test.mjs",
@@ -164,6 +167,7 @@
     "scripts/document-write-overwrite.test.mjs",
     "scripts/feishu.test.mjs",
     "scripts/scheduled-tasks.test.mjs",
+    "scripts/scheduled-task-model-clear.test.mjs",
     "scripts/scheduled-task-scope.test.mjs",
     "scripts/scheduled-task-tool.test.mjs",
     "scripts/run-state-sync.test.mjs",
@@ -182,6 +186,7 @@
     "scripts/conversation-reconcile-browser.test.mjs",
     "scripts/visual-defects-browser.test.mjs",
     "scripts/session-state-animation-browser.test.mjs",
+    "scripts/session-state-delivery-browser.test.mjs",
     "scripts/agent-vis-card-browser.test.mjs",
     "scripts/queue-dock.test.mjs",
     "scripts/scheduled-tasks-browser.test.mjs",