@evandu/super-pi 0.1.130 → 0.1.132

package/dist/server/inline-thinking.d.ts

@@ -0,0 +1,90 @@
+/**
+ * THE REASONING A MODEL PUTS INSIDE ITS OWN ANSWER.
+ *
+ * Some models do not have a reasoning channel. They answer in one stream of text and put their
+ * thinking in it, marked up with `<think>…</think>` tags - MiniMax's M2 series is the one this
+ * file exists for, and every gateway that proxies it behaves the same way. The tags arrive as
+ * ordinary text, so nothing downstream can tell them from an answer.
+ *
+ * WHY THIS IS SUPER PI'S PROBLEM AND NOT THE USER'S. Pi's OpenAI-compatible adapter only treats
+ * `reasoning_content`, `reasoning`, `reasoning_text` and `reasoning_details` as reasoning; it
+ * never parses tags out of `content`. A provider that inlines its thinking therefore hands Pi one
+ * long text block, Pi hands Super Pi one long text block, and Super Pi would draw the reasoning as
+ * part of the answer - in the reader's face, unlabelled, with the tags still in it. The obvious
+ * "fix" is to tell the user to go and set a provider-specific switch in Pi's `models.json`, which
+ * is a private API of a program Super Pi ships, for a quirk of one vendor. A user who never
+ * hears of it sees a broken transcript and has no way to know why.
+ *
+ * SO THE SPLIT HAPPENS HERE, ON SUPER PI'S OWN SIDE, FOR EVERY PROVIDER. Whatever the endpoint
+ * does with its reasoning, the transcript reads the same way: the reasoning goes into a thinking
+ * block, the answer goes into the answer, and the tags are never shown to anyone.
+ *
+ * THE ORDER IS THE WHOLE TRICK. A tag can straddle two deltas - the model writes `</thi` and then
+ * `nk>` in the next one - so the splitter holds back the tail that might be the start of a tag
+ * until the next delta settles it. And a delta can hold an answer, a thought and another answer,
+ * so the splitter returns SEGMENTS IN ORDER rather than "the text" and "the thinking": the caller
+ * has to be able to put the answer that came before a thought after it, and has to be able to say
+ * where that thought began.
+ *
+ * THE RULES, because each of them has a case that would otherwise be a bug:
+ *
+ *   - A PROPERLY CLOSED region is reasoning. It leaves the answer and enters the thinking block.
+ *   - AN UNCLOSED region is reasoning too. The model said it was thinking and then the turn
+ *     ended - an abort, a truncation, a provider that stopped mid-thought. The reasoning goes
+ *     into the block, and the answer keeps whatever came before the tag. Nothing is thrown away
+ *     either way: the fold is expandable, so the words are still there to be read.
+ *   - A CLOSING TAG WITH NOTHING OPEN is dropped. The model wrote it by mistake, and showing it
+ *     would be showing a fragment of markup as if it were content.
+ *   - TEXT IS NEVER LOST. A `<` that turns out not to begin a tag is held for one delta and then
+ *     released as text, so a comparison like `a < b` survives intact.
+ */
+/**
+ * One piece of a turn's text, in the order the model wrote it.
+ *
+ * `thinking-end` is a segment of its own because the end of a reasoning region is a FACT the
+ * browser needs and not text: it is what closes the "正在思考" indicator and what tells the
+ * transcript that the next fold is a new one.
+ */
+export type InlineThinkingSegment = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "thinking";
+    text: string;
+} | {
+    kind: "thinking-end";
+};
+/**
+ * Splits a model's text into the answer and the reasoning the model wrote inside it.
+ *
+ * ONE SPLITTER PER TURN. The state it keeps - the held-back tail and whether the stream is
+ * inside a reasoning region - belongs to a turn and to nothing else, so a splitter is created
+ * when a turn starts and dropped when it ends.
+ */
+export declare class InlineThinkingSplitter {
+    /** The tail that might be the start of a tag, held until the next delta settles it. */
+    private held;
+    /** True while the stream is inside a reasoning region. */
+    private inside;
+    /**
+     * Feeds one delta in and gets back the segments it produced, in order.
+     *
+     * A delta that carries nothing but text produces one text segment. A delta that opens a
+     * reasoning region produces the text before it, then the reasoning, then the end of the
+     * reasoning when the closing tag arrives - and the text after it, if there is any.
+     */
+    push(delta: string): InlineThinkingSegment[];
+    /**
+     * Closes the turn: whatever is still held is released, and a reasoning region that never
+     * closed is finished as one.
+     */
+    flush(): InlineThinkingSegment[];
+}
+/**
+ * The answer inside a model's text, with the reasoning taken out of it.
+ *
+ * For the paths that want a STRING rather than a stream of segments: the title generator, the
+ * tool LLM, a sub-agent's result. A title with a `<think>` prefix in it is not a title, and a
+ * sub-agent's card whose summary starts with markup reads as broken.
+ */
+export declare function stripInlineThinking(text: string): string;

package/dist/server/inline-thinking.js

@@ -0,0 +1,181 @@
+/**
+ * THE REASONING A MODEL PUTS INSIDE ITS OWN ANSWER.
+ *
+ * Some models do not have a reasoning channel. They answer in one stream of text and put their
+ * thinking in it, marked up with `<think>…</think>` tags - MiniMax's M2 series is the one this
+ * file exists for, and every gateway that proxies it behaves the same way. The tags arrive as
+ * ordinary text, so nothing downstream can tell them from an answer.
+ *
+ * WHY THIS IS SUPER PI'S PROBLEM AND NOT THE USER'S. Pi's OpenAI-compatible adapter only treats
+ * `reasoning_content`, `reasoning`, `reasoning_text` and `reasoning_details` as reasoning; it
+ * never parses tags out of `content`. A provider that inlines its thinking therefore hands Pi one
+ * long text block, Pi hands Super Pi one long text block, and Super Pi would draw the reasoning as
+ * part of the answer - in the reader's face, unlabelled, with the tags still in it. The obvious
+ * "fix" is to tell the user to go and set a provider-specific switch in Pi's `models.json`, which
+ * is a private API of a program Super Pi ships, for a quirk of one vendor. A user who never
+ * hears of it sees a broken transcript and has no way to know why.
+ *
+ * SO THE SPLIT HAPPENS HERE, ON SUPER PI'S OWN SIDE, FOR EVERY PROVIDER. Whatever the endpoint
+ * does with its reasoning, the transcript reads the same way: the reasoning goes into a thinking
+ * block, the answer goes into the answer, and the tags are never shown to anyone.
+ *
+ * THE ORDER IS THE WHOLE TRICK. A tag can straddle two deltas - the model writes `</thi` and then
+ * `nk>` in the next one - so the splitter holds back the tail that might be the start of a tag
+ * until the next delta settles it. And a delta can hold an answer, a thought and another answer,
+ * so the splitter returns SEGMENTS IN ORDER rather than "the text" and "the thinking": the caller
+ * has to be able to put the answer that came before a thought after it, and has to be able to say
+ * where that thought began.
+ *
+ * THE RULES, because each of them has a case that would otherwise be a bug:
+ *
+ *   - A PROPERLY CLOSED region is reasoning. It leaves the answer and enters the thinking block.
+ *   - AN UNCLOSED region is reasoning too. The model said it was thinking and then the turn
+ *     ended - an abort, a truncation, a provider that stopped mid-thought. The reasoning goes
+ *     into the block, and the answer keeps whatever came before the tag. Nothing is thrown away
+ *     either way: the fold is expandable, so the words are still there to be read.
+ *   - A CLOSING TAG WITH NOTHING OPEN is dropped. The model wrote it by mistake, and showing it
+ *     would be showing a fragment of markup as if it were content.
+ *   - TEXT IS NEVER LOST. A `<` that turns out not to begin a tag is held for one delta and then
+ *     released as text, so a comparison like `a < b` survives intact.
+ */
+/** The tag that opens a reasoning region. */
+const OPEN_TAG = "<think>";
+/** The tag that closes one. */
+const CLOSE_TAG = "</think>";
+/** Appends a piece of text, skipping the empty ones: an empty segment is not an event. */
+function append(segments, kind, text) {
+    if (text)
+        segments.push({ kind, text });
+}
+/**
+ * How much of the tail of `text` could be the beginning of `tag`.
+ *
+ * The whole tag is not a candidate - a complete tag would have been found by `indexOf` - so this
+ * returns the length of the longest PROPER prefix of the tag that the tail ends with. It is what
+ * makes `<thi` wait for the next delta instead of being published as text and then having to be
+ * taken back.
+ */
+function partialTagLength(text, tag) {
+    const max = Math.min(tag.length - 1, text.length);
+    for (let length = max; length > 0; length -= 1) {
+        if (text.endsWith(tag.slice(0, length)))
+            return length;
+    }
+    return 0;
+}
+/**
+ * Splits a model's text into the answer and the reasoning the model wrote inside it.
+ *
+ * ONE SPLITTER PER TURN. The state it keeps - the held-back tail and whether the stream is
+ * inside a reasoning region - belongs to a turn and to nothing else, so a splitter is created
+ * when a turn starts and dropped when it ends.
+ */
+export class InlineThinkingSplitter {
+    /** The tail that might be the start of a tag, held until the next delta settles it. */
+    held = "";
+    /** True while the stream is inside a reasoning region. */
+    inside = false;
+    /**
+     * Feeds one delta in and gets back the segments it produced, in order.
+     *
+     * A delta that carries nothing but text produces one text segment. A delta that opens a
+     * reasoning region produces the text before it, then the reasoning, then the end of the
+     * reasoning when the closing tag arrives - and the text after it, if there is any.
+     */
+    push(delta) {
+        const segments = [];
+        if (!delta)
+            return segments;
+        const buffer = this.held + delta;
+        this.held = "";
+        let index = 0;
+        while (index < buffer.length) {
+            if (this.inside) {
+                const close = buffer.indexOf(CLOSE_TAG, index);
+                if (close === -1) {
+                    // No closing tag yet. Everything that cannot be the start of one is reasoning, and the
+                    // rest waits for the next delta.
+                    const keep = partialTagLength(buffer.slice(index), CLOSE_TAG);
+                    append(segments, "thinking", buffer.slice(index, buffer.length - keep));
+                    this.held = buffer.slice(buffer.length - keep);
+                    break;
+                }
+                append(segments, "thinking", buffer.slice(index, close));
+                index = close + CLOSE_TAG.length;
+                this.inside = false;
+                segments.push({ kind: "thinking-end" });
+                continue;
+            }
+            const open = buffer.indexOf(OPEN_TAG, index);
+            const close = buffer.indexOf(CLOSE_TAG, index);
+            if (open === -1 && close === -1) {
+                // BOTH TAGS CAN START HERE, SO BOTH TAILS ARE HELD. The tail is held so that a tag the
+                // tokenizer cut in half is still recognized as a tag; which tag it might be is exactly the
+                // question, and outside a reasoning region it can be EITHER one: a stray `</think>` is markup
+                // the model wrote by mistake and must be dropped, exactly like a `<think>` that opens a
+                // region. Holding only the OPEN prefix published the CLOSE prefix as text at once, so the
+                // same stray tag was dropped when it arrived whole and survived in the answer when the
+                // tokenizer cut it - `["答案</thi", "nk>还是答案"]` read as `答案</think>还是答案`
+                // (measured by scripts/inline-thinking-close-tag.test.mjs, ledger TEST-021). The longer of
+                // the two prefixes is held; a tail that turns out to be neither is released as text on the
+                // next delta, which is the "text is never lost" rule.
+                const rest = buffer.slice(index);
+                const keep = Math.max(partialTagLength(rest, OPEN_TAG), partialTagLength(rest, CLOSE_TAG));
+                append(segments, "text", rest.slice(0, rest.length - keep));
+                this.held = rest.slice(rest.length - keep);
+                break;
+            }
+            if (open !== -1 && (close === -1 || open < close)) {
+                append(segments, "text", buffer.slice(index, open));
+                index = open + OPEN_TAG.length;
+                this.inside = true;
+                continue;
+            }
+            // A CLOSING TAG WITH NOTHING OPEN. Dropped: it is markup the model wrote by mistake, and a
+            // reader would take it for content. The text BEFORE it is ordinary text and is kept - the tag
+            // is dropped, not everything up to it.
+            append(segments, "text", buffer.slice(index, close));
+            index = close + CLOSE_TAG.length;
+        }
+        return segments;
+    }
+    /**
+     * Closes the turn: whatever is still held is released, and a reasoning region that never
+     * closed is finished as one.
+     */
+    flush() {
+        const segments = [];
+        if (this.inside) {
+            if (this.held)
+                segments.push({ kind: "thinking", text: this.held });
+            this.held = "";
+            this.inside = false;
+            segments.push({ kind: "thinking-end" });
+            return segments;
+        }
+        if (this.held) {
+            segments.push({ kind: "text", text: this.held });
+            this.held = "";
+        }
+        return segments;
+    }
+}
+/**
+ * The answer inside a model's text, with the reasoning taken out of it.
+ *
+ * For the paths that want a STRING rather than a stream of segments: the title generator, the
+ * tool LLM, a sub-agent's result. A title with a `<think>` prefix in it is not a title, and a
+ * sub-agent's card whose summary starts with markup reads as broken.
+ */
+export function stripInlineThinking(text) {
+    if (!text)
+        return "";
+    const splitter = new InlineThinkingSplitter();
+    const segments = [...splitter.push(text), ...splitter.flush()];
+    let answer = "";
+    for (const segment of segments) {
+        if (segment.kind === "text")
+            answer += segment.text;
+    }
+    return answer;
+}

package/dist/server/knowledge.d.ts

@@ -82,6 +82,8 @@ export type KnowledgeRuntime = {
 export declare function parseRanking(output: string): number[] | null;
 /** Duplicated as a literal in `agents/super-pi-knowledge/index.ts`, the way `TASK_TOOL_NAME` is. */
 export declare const KNOWLEDGE_TOOL_NAME = "knowledge_search";
+/** The import half of the same extension. Duplicated as a literal there, for the same reason. */
+export declare const KNOWLEDGE_IMPORT_TOOL_NAME = "knowledge_import";
 /**
  * Index terms for one string: CJK bigrams plus Latin words.
  *
@@ -152,17 +154,6 @@ export declare class KnowledgeBase {
     private load;
     private invalidate;
     list(workspaceId: string): Promise<Array<Omit<KnowledgeDocument, "text">>>;
-    /**
-     * Whether this workspace has any document at all, which is what decides whether the turn mounts the
-     * extension.
-     *
-     * WHY A DIRECTORY LISTING AND NOT `list()`. This runs once per turn, before every spawn. `list()`
-     * would read and parse every document's full text to answer a yes/no question, so a workspace with
-     * a dozen real documents would pay for parsing all of them on every message - including the
-     * catalogue fetch the extension makes the moment it loads. `readdir` answers the same question for
-     * the price of one directory entry, and a name is all this needs.
-     */
-    hasDocuments(workspaceId: string): Promise<boolean>;
     /**
      * Adds a document, either from a workspace file or from pasted text.
      *
@@ -171,6 +162,10 @@ export declare class KnowledgeBase {
      * newer version that diverges from the one the workspace serves. The path therefore goes through
      * the same `resolveInsideRoot` guard the file editor uses, so symlink and `..` escapes are refused
      * by construction instead of by a check someone has to remember.
+     *
+     * WHO CALLS THIS. The settings window (manage, action "add") AND, since the import tool exists,
+     * the primary agent mid-turn on the user's say-so - through the same guard, the same whitelist and
+     * the same caps, so an agent import can never do more than a person's import could.
      */
     add(workspaceId: string, body: {
         path?: string;
@@ -213,27 +208,42 @@ export declare class KnowledgeBase {
      */
     private rerank;
     /**
-     * Mints a read-only token for one turn. The agent can retrieve, never write: everything a person
-     * puts in a knowledge base is theirs to curate from the settings window.
+     * Mints a token for one turn. The agent can retrieve and IMPORT (a document the user just asked it
+     * to add rides through the same `add` guard the settings window uses), but never remove: curation
+     * that deletes a person's documents stays a settings-window act.
      */
     issue(conversationId: string): string;
     release(token: string): void;
     private identity;
-    /** The agent-facing endpoint: a title catalogue and a search. Nothing that writes. */
+    /**
+     * The agent-facing endpoint: a title catalogue, a search, and an import. The import is the SAME
+     * `add` the settings window calls - path guard, format whitelist, size caps, dedupe - so an agent
+     * cannot do anything a person could not, and the one thing it cannot do is `remove`.
+     */
     tool(token: string, body: {
         kind?: string;
         query?: string;
         limit?: number;
+        path?: string;
+        title?: string;
+        text?: string;
     }, signal?: AbortSignal): Promise<{
         documents: {
             title: string;
             source: string;
             characters: number;
         }[];
+        imported?: undefined;
+        hits?: undefined;
+        reranked?: undefined;
+    } | {
+        documents?: undefined;
+        imported: Omit<KnowledgeDocument, "text">;
         hits?: undefined;
         reranked?: undefined;
     } | {
         documents?: undefined;
+        imported?: undefined;
         hits: KnowledgeHit[];
         reranked: boolean;
     }>;

package/dist/server/knowledge.js

@@ -1,7 +1,8 @@
 import { createHash, randomUUID } from "node:crypto";
 import { mkdir, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
-import { basename, extname, join } from "node:path";
+import { basename, extname, join, relative, sep } from "node:path";
 import { looksBinary, resolveInsideRoot } from "./files.js";
+import { documentFormatOf, DocumentError, extractText } from "./documents.js";
 /** 1 MB. Big enough for a design doc or a spec, small enough that chunking stays instant. */
 export const MAX_DOCUMENT_BYTES = 1024 * 1024;
 /** A pasted document rides inside a JSON body, so the request cap leaves room for escaping overhead. */
@@ -53,6 +54,8 @@ const HEADING = /^#{1,6}\s+(.*\S)\s*$/;
 const PASTED_SOURCE = "pasted";
 /** Duplicated as a literal in `agents/super-pi-knowledge/index.ts`, the way `TASK_TOOL_NAME` is. */
 export const KNOWLEDGE_TOOL_NAME = "knowledge_search";
+/** The import half of the same extension. Duplicated as a literal there, for the same reason. */
+export const KNOWLEDGE_IMPORT_TOOL_NAME = "knowledge_import";
 /** Extensions a document may be imported from. Mirrors `files.TEXT_EXTENSIONS`, minus the source languages. */
 const IMPORTABLE = new Set([
     ".md", ".markdown", ".mdx", ".txt", ".text", ".log", ".rst", ".org",
@@ -369,30 +372,6 @@ export class KnowledgeBase {
         const documents = (await this.readAll(workspaceId)).map(document => this.summarise(document));
         return documents.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     }
-    /**
-     * Whether this workspace has any document at all, which is what decides whether the turn mounts the
-     * extension.
-     *
-     * WHY A DIRECTORY LISTING AND NOT `list()`. This runs once per turn, before every spawn. `list()`
-     * would read and parse every document's full text to answer a yes/no question, so a workspace with
-     * a dozen real documents would pay for parsing all of them on every message - including the
-     * catalogue fetch the extension makes the moment it loads. `readdir` answers the same question for
-     * the price of one directory entry, and a name is all this needs.
-     */
-    async hasDocuments(workspaceId) {
-        if (!this.enabled())
-            return false;
-        if (!this.store.snapshot().workspaces.some(workspace => workspace.id === workspaceId))
-            return false;
-        try {
-            return (await readdir(this.folder(workspaceId))).some(name => name.endsWith(".json"));
-        }
-        catch (error) {
-            if (error.code === "ENOENT")
-                return false;
-            throw error;
-        }
-    }
     /**
      * Adds a document, either from a workspace file or from pasted text.
      *
@@ -401,6 +380,10 @@ export class KnowledgeBase {
      * newer version that diverges from the one the workspace serves. The path therefore goes through
      * the same `resolveInsideRoot` guard the file editor uses, so symlink and `..` escapes are refused
      * by construction instead of by a check someone has to remember.
+     *
+     * WHO CALLS THIS. The settings window (manage, action "add") AND, since the import tool exists,
+     * the primary agent mid-turn on the user's say-so - through the same guard, the same whitelist and
+     * the same caps, so an agent import can never do more than a person's import could.
      */
     async add(workspaceId, body) {
         this.requireWorkspace(workspaceId);
@@ -417,17 +400,50 @@ export class KnowledgeBase {
             if (!info.isFile())
                 throw new Error("只能导入文件");
             format = extname(absolute).toLocaleLowerCase();
-            if (!IMPORTABLE.has(format))
+            const documentFormat = documentFormatOf(format);
+            if (!IMPORTABLE.has(format) && !documentFormat) {
                 throw new Error(`不支持的文件类型 ${format || "(无扩展名)"}；请先转换为 Markdown 或纯文本`);
+            }
             if (info.size > MAX_DOCUMENT_BYTES)
                 throw new Error(`文件过大：${info.size} 字节超过 ${MAX_DOCUMENT_BYTES} 的上限`);
-            const buffer = await readFile(absolute);
-            if (looksBinary(buffer.subarray(0, 4096)))
-                throw new Error("看起来是二进制文件，无法索引");
-            text = buffer.toString("utf8");
-            source = body.path.trim();
+            // THE DOCUMENT'S IDENTITY IS THE FILE, NOT THE SPELLING OF ITS PATH. `resolveInsideRoot` has
+            // already resolved the caller's path to a canonical one, so the identity is derived from THAT -
+            // the workspace-relative path - instead of from whatever string the caller typed. Taking the raw
+            // string made `./notes.md` and `notes.md` two different documents: re-importing the same file
+            // under another spelling added a second document, and the REPLACED version stayed in the index
+            // where the agent could still cite it (measured by
+            // scripts/knowledge-import-identity.test.mjs, ledger TEST-027). The contract says a file whose
+            // content changed is an update, keeping its id, and only one document per file may exist.
+            source = relative(workspace.path, absolute).split(sep).join("/");
             if (!title)
                 title = basename(absolute);
+            if (documentFormat) {
+                // A DOCUMENT IS PARSED, NOT DECODED. The bytes on disk are a container - a PDF's or a
+                // docx's - and what goes into the knowledge base is the TEXT they contain. The format
+                // recorded on the document stays the SOURCE format (`.pdf`), because that is what the next
+                // re-import of this path has to parse it as: the extracted text is not a PDF, and treating
+                // it as one would make an update fail to parse at all.
+                //
+                // A DOCUMENT THAT COULD NOT BE READ IS A REFUSAL, NOT AN EMPTY DOCUMENT. The parser's own
+                // reasons are already written for a person - a scan with no text layer, an encrypted file,
+                // a missing package - and they are passed through unchanged, because a person who is told
+                // "读取失败" learns nothing about what to do next.
+                try {
+                    const extracted = await extractText(absolute, documentFormat);
+                    text = extracted.text;
+                }
+                catch (error) {
+                    if (error instanceof DocumentError)
+                        throw new Error(error.message);
+                    throw error;
+                }
+            }
+            else {
+                const buffer = await readFile(absolute);
+                if (looksBinary(buffer.subarray(0, 4096)))
+                    throw new Error("看起来是二进制文件，无法索引");
+                text = buffer.toString("utf8");
+            }
         }
         const trimmed = text.trim();
         if (!trimmed)
@@ -677,8 +693,9 @@ export class KnowledgeBase {
         }
     }
     /**
-     * Mints a read-only token for one turn. The agent can retrieve, never write: everything a person
-     * puts in a knowledge base is theirs to curate from the settings window.
+     * Mints a token for one turn. The agent can retrieve and IMPORT (a document the user just asked it
+     * to add rides through the same `add` guard the settings window uses), but never remove: curation
+     * that deletes a person's documents stays a settings-window act.
      */
     issue(conversationId) {
         const conversation = this.store.snapshot().conversations.find(item => item.id === conversationId);
@@ -697,13 +714,19 @@ export class KnowledgeBase {
             throw new Error("知识库授权已失效");
         return identity;
     }
-    /** The agent-facing endpoint: a title catalogue and a search. Nothing that writes. */
+    /**
+     * The agent-facing endpoint: a title catalogue, a search, and an import. The import is the SAME
+     * `add` the settings window calls - path guard, format whitelist, size caps, dedupe - so an agent
+     * cannot do anything a person could not, and the one thing it cannot do is `remove`.
+     */
     async tool(token, body, signal) {
         const identity = this.identity(token);
         if (!this.enabled())
             throw new Error("知识库已关闭");
         if (body.kind === "catalogue")
             return { documents: (await this.list(identity.workspaceId)).map(document => ({ title: document.title, source: document.source, characters: document.characters })) };
+        if (body.kind === "import")
+            return { imported: await this.add(identity.workspaceId, { path: body.path, title: body.title, text: body.text }) };
         if (body.kind !== "search")
             throw new Error("未知知识库操作");
         // The reranker needs the conversation it is ranking FOR: that is whose model answers, whose

package/dist/server/persistence/app-state-repository.d.ts

@@ -10,7 +10,19 @@ export type StateTransaction = {
     run: SubagentRun;
 } | {
     kind: "collections.replace";
-    values: Partial<Pick<AppState, "workflows" | "backgroundTasks">>;
+    values: Partial<Pick<AppState, "workflows" | "backgroundTasks" | "scheduledTasks">>;
+}
+/**
+ * Removes one collection row entirely.
+ *
+ * It exists because "this collection is empty" is stored as the ABSENCE of the key, not as an empty
+ * array: a fresh install must not claim the user considered a schedule and found none. A repository
+ * whose `collections.replace` can only write rows therefore cannot express "there are none" - it can
+ * only write `[]`, which is a different claim.
+ */
+ | {
+    kind: "collections.remove";
+    name: "workflows" | "backgroundTasks" | "scheduledTasks";
 } | {
     kind: "conversation.metadata";
     conversationId: string;

package/dist/server/persistence/sqlite-state-repository.js

@@ -118,6 +118,9 @@ export class SqliteStateRepository {
                 for (const [name, value] of Object.entries(transaction.values))
                     write.run(name, JSON.stringify(value));
             }
+            else if (transaction.kind === "collections.remove") {
+                this.db.prepare("DELETE FROM collections WHERE name=?").run(transaction.name);
+            }
             else if (transaction.kind === "conversation.messages") {
                 // A DIFF, NOT A REWRITE. This used to DELETE the conversation's rows and re-INSERT every
                 // message - stringified twice, once per table - on every single send, under

package/dist/server/pi-session-pool.js

@@ -22,7 +22,7 @@
  */
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { createPiSession, sameFingerprint, superPiExtensionPaths, } from "./pi-session.js";
+import { createPiSession, sameFingerprint, superPiExtensionPaths, superPiSkillPaths, } from "./pi-session.js";
 /** How long an idle session survives before it is evicted. */
 const IDLE_EVICTION_MS = 10 * 60_000;
 /**
@@ -170,6 +170,7 @@ export class PiSessionPool {
             sessionId: request.conversationId,
             sessionDir: this.sessionDir,
             extensionPaths: superPiExtensionPaths(this.repositoryRoot),
+            skillPaths: superPiSkillPaths(this.repositoryRoot),
             extensionEnv: request.extensionEnv,
             ...(request.systemPromptFile ? { systemPromptFile: request.systemPromptFile } : {}),
             ...(request.systemPromptMode ? { systemPromptMode: request.systemPromptMode } : {}),

package/dist/server/pi-session.d.ts

@@ -343,6 +343,8 @@ export interface SessionCreation {
     sessionDir: string;
     /** Super Pi's extensions to mount, as absolute paths. */
     extensionPaths: string[];
+    /** Super Pi's built-in skills to expose beside the user's and workspace's skills. */
+    skillPaths?: string[];
     /** The environment those extensions read when they are loaded. */
     extensionEnv: Record<string, string>;
     /** The agent's system prompt file, or undefined for Pi's own defaults. */
@@ -420,3 +422,5 @@ export interface PromptTemplateSummary {
 }
 export declare function loadPromptTemplateSummaries(cwd: string): Promise<PromptTemplateSummary[]>;
 export declare function superPiExtensionPaths(repositoryRoot: string): string[];
+/** Skills shipped by Super Pi itself. Paths are explicit so installed and development layouts agree. */
+export declare function superPiSkillPaths(repositoryRoot: string): string[];

package/dist/server/pi-session.js

@@ -269,6 +269,7 @@ export async function createPiSession(creation) {
             cwd: creation.cwd,
             agentDir,
             ...(creation.extensionPaths.length ? { additionalExtensionPaths: creation.extensionPaths } : {}),
+            ...(creation.skillPaths?.length ? { additionalSkillPaths: creation.skillPaths } : {}),
             ...(creation.systemPromptFile && creation.systemPromptMode === "replace"
                 ? { systemPrompt: creation.systemPromptFile }
                 : creation.systemPromptFile
@@ -413,6 +414,19 @@ export function superPiExtensionPaths(repositoryRoot) {
         join(repositoryRoot, "agents", "super-pi-task", "index.ts"),
         join(repositoryRoot, "agents", "super-pi-memory", "index.ts"),
         join(repositoryRoot, "agents", "super-pi-knowledge", "index.ts"),
+        join(repositoryRoot, "agents", "super-pi-web", "index.ts"),
+        // The document tools. They are mounted for every session, and the extension itself decides
+        // whether to register anything: with no endpoint in its environment it returns without
+        // registering a tool, so a runtime without a document endpoint mounts nothing harmful.
+        join(repositoryRoot, "agents", "super-pi-documents", "index.ts"),
+        // The Feishu tools, mounted for every session on the same terms: the extension registers
+        // nothing without an endpoint in its environment.
+        join(repositoryRoot, "agents", "super-pi-feishu", "index.ts"),
     ];
     return paths.filter((path) => existsSync(path));
 }
+/** Skills shipped by Super Pi itself. Paths are explicit so installed and development layouts agree. */
+export function superPiSkillPaths(repositoryRoot) {
+    const paths = [join(repositoryRoot, "skills", "presentation")];
+    return paths.filter((path) => existsSync(join(path, "SKILL.md")));
+}