@evandu/super-pi 0.1.146 → 0.1.148

package/dist/server/knowledge-vectors.js

@@ -27,8 +27,8 @@ export const KNOWLEDGE_MODEL = "Xenova/bge-small-zh-v1.5";
  */
 export const EMBED_PIECE_CHARS = 300;
 const EMBED_PIECE_OVERLAP = 40;
-/** Per query. Cosine similarity of unit vectors; beyond this the passage is noise. */
-const MIN_COSINE = 0.15;
+/** Per query. Cosine similarity of unit vectors; threshold raised to 0.35 to filter out semantic noise. */
+export const MIN_COSINE = 0.35;
 /**
  * Splits a retrieval chunk into pieces small enough for the model's window.
  *
@@ -84,6 +84,11 @@ export class VectorIndex {
     workerReady = false;
     workerPending = new Map();
     failure;
+    consecutiveFailures = 0;
+    lastFailureTime = 0;
+    static MAX_FAILURES = 3;
+    static COOLDOWN_MS = 30000;
+    static EMBED_TIMEOUT_MS = 15000;
     cache = new Map();
     pending = new Set();
     queue = [];
@@ -102,11 +107,29 @@ export class VectorIndex {
     bundledModel() { return resolve(import.meta.dirname, "../../assets/knowledge-model"); }
     enabled() { return process.env.SUPER_PI_KNOWLEDGE_EMBEDDINGS !== "0"; }
     status(indexed) {
+        const enabled = this.enabled();
+        const bundled = existsSync(this.bundledModel());
+        const now = Date.now();
+        const inCooldown = this.consecutiveFailures >= VectorIndex.MAX_FAILURES && (now - this.lastFailureTime < VectorIndex.COOLDOWN_MS);
+        let health = "ready";
+        if (!enabled)
+            health = "disabled";
+        else if (!bundled || inCooldown)
+            health = "degraded";
+        else if (this.consecutiveFailures > 0)
+            health = "restarting";
+        else if (this.worker && this.workerReady)
+            health = "ready";
+        else
+            health = "ready";
         return {
-            enabled: this.enabled(), ready: this.workerReady, indexed, error: this.failure,
-            // Whether the shipped weights are on disk, reported before the model is ever loaded: "the
-            // package was built without its assets" and "the model failed to load" are different problems.
-            bundled: existsSync(this.bundledModel()),
+            enabled,
+            ready: this.workerReady && health === "ready",
+            indexed,
+            error: this.failure,
+            bundled,
+            health,
+            available: enabled && bundled && health !== "degraded",
         };
     }
     workspace(workspaceId) { return join(this.directory, Buffer.from(workspaceId).toString("hex")); }
@@ -121,45 +144,81 @@ export class VectorIndex {
      * able to reach, on the first search, for every person who installed the package. Shipping the
      * weights turns a failure mode into a file, and makes the feature work on a machine that has never
      * been online since it was installed.
+     *
+     * RESILIENT WORKER LIFECYCLE:
+     * When the worker encounters an error, crash, or unexpected exit, it cleans up all pending requests
+     * without hanging and marks the instance for automatic, on-demand respawning on the next embed call.
+     * A bounded backoff / cooldown prevents runaway crash loops if the environment is broken.
      */
     ensureWorker() {
+        if (!this.enabled())
+            return undefined;
         if (this.worker)
             return this.worker;
-        if (this.failure)
-            return undefined;
         if (!existsSync(this.bundledModel())) {
             this.failure = `随包分发的模型缺失：${this.bundledModel()}`;
             return undefined;
         }
-        const worker = new Worker(new URL("./knowledge-embedding-worker.js", import.meta.url));
-        worker.unref();
-        worker.on("message", (message) => {
-            const pending = this.workerPending.get(message.id);
-            if (!pending)
-                return;
-            this.workerPending.delete(message.id);
-            if (message.error || !message.data || !message.dims) {
-                this.failure = message.error ?? "向量 worker 返回了无效结果";
-                pending.resolve(null);
-                return;
+        const now = Date.now();
+        if (this.consecutiveFailures >= VectorIndex.MAX_FAILURES) {
+            if (now - this.lastFailureTime < VectorIndex.COOLDOWN_MS) {
+                return undefined;
             }
-            this.workerReady = true;
-            const dimension = message.dims.at(-1) ?? 0;
-            pending.resolve(Array.from({ length: message.dims[0] ?? 0 }, (_, row) => Array.from(message.data.slice(row * dimension, (row + 1) * dimension))));
-        });
-        const fail = (error) => {
-            this.failure = error.message;
-            for (const pending of this.workerPending.values())
-                pending.resolve(null);
-            this.workerPending.clear();
-            this.worker = undefined;
-            this.workerReady = false;
-        };
-        worker.on("error", fail);
-        worker.on("exit", (code) => { if (code !== 0)
-            fail(new Error(`向量 worker 异常退出（${code}）`)); });
-        this.worker = worker;
-        return worker;
+            this.consecutiveFailures = 0;
+            this.failure = undefined;
+        }
+        try {
+            const worker = new Worker(new URL("./knowledge-embedding-worker.js", import.meta.url));
+            worker.unref();
+            worker.on("message", (message) => {
+                const pending = this.workerPending.get(message.id);
+                if (!pending)
+                    return;
+                this.workerPending.delete(message.id);
+                if (pending.timeout)
+                    clearTimeout(pending.timeout);
+                if (message.error || !message.data || !message.dims) {
+                    this.failure = message.error ?? "向量 worker 返回了无效结果";
+                    pending.resolve(null);
+                    return;
+                }
+                this.workerReady = true;
+                this.failure = undefined;
+                this.consecutiveFailures = 0;
+                const dimension = message.dims.at(-1) ?? 0;
+                pending.resolve(Array.from({ length: message.dims[0] ?? 0 }, (_, row) => Array.from(message.data.slice(row * dimension, (row + 1) * dimension))));
+            });
+            const fail = (error) => {
+                this.consecutiveFailures++;
+                this.lastFailureTime = Date.now();
+                this.failure = error.message;
+                for (const pending of this.workerPending.values()) {
+                    if (pending.timeout)
+                        clearTimeout(pending.timeout);
+                    pending.resolve(null);
+                }
+                this.workerPending.clear();
+                if (this.worker) {
+                    try {
+                        this.worker.terminate();
+                    }
+                    catch { }
+                }
+                this.worker = undefined;
+                this.workerReady = false;
+            };
+            worker.on("error", fail);
+            worker.on("exit", (code) => { if (code !== 0)
+                fail(new Error(`向量 worker 异常退出（${code}）`)); });
+            this.worker = worker;
+            return worker;
+        }
+        catch (error) {
+            this.consecutiveFailures++;
+            this.lastFailureTime = Date.now();
+            this.failure = error instanceof Error ? error.message : String(error);
+            return undefined;
+        }
     }
     async embed(texts) {
         if (!texts.length || !this.enabled())
@@ -169,10 +228,32 @@ export class VectorIndex {
             return null;
         const id = ++this.workerSequence;
         return new Promise((resolvePromise) => {
-            this.workerPending.set(id, { resolve: resolvePromise });
+            const timeout = setTimeout(() => {
+                const pending = this.workerPending.get(id);
+                if (pending) {
+                    this.workerPending.delete(id);
+                    pending.resolve(null);
+                }
+            }, VectorIndex.EMBED_TIMEOUT_MS);
+            timeout.unref();
+            this.workerPending.set(id, { resolve: resolvePromise, timeout });
             worker.postMessage({ id, texts, modelRoot: this.bundledModel(), model: KNOWLEDGE_MODEL });
         });
     }
+    async terminate() {
+        for (const pending of this.workerPending.values()) {
+            if (pending.timeout)
+                clearTimeout(pending.timeout);
+            pending.resolve(null);
+        }
+        this.workerPending.clear();
+        if (this.worker) {
+            const w = this.worker;
+            this.worker = undefined;
+            this.workerReady = false;
+            await w.terminate();
+        }
+    }
     /** Vectors already stored for one workspace, keyed by document then chunk index. */
     async read(workspaceId, documentId) {
         try {

package/dist/server/knowledge.d.ts

@@ -44,7 +44,7 @@ export declare const MAX_DOCUMENT_BYTES: number;
 export declare const MAX_KNOWLEDGE_REQUEST_BYTES: number;
 /** Per workspace, across every document. A knowledge base is a curated asset, not a file server. */
 export declare const MAX_WORKSPACE_BYTES: number;
-export declare const DEFAULT_RESULT_LIMIT = 6;
+export declare const DEFAULT_RESULT_LIMIT = 3;
 export declare const MAX_RESULT_LIMIT = 20;
 /** What one search may be asked for. `rerank` and `conversation` exist only for the agent's own calls. */
 export type KnowledgeSearch = {
@@ -72,14 +72,11 @@ export type KnowledgeRuntime = {
     }): AsyncIterable<string>;
 };
 /**
- * The first integer array in the model's answer, or null.
- *
- * WHY TOLERANT PARSING. The prompt asks for a bare JSON array, and a model that mostly complies will
- * still sometimes wrap it in a sentence or a code fence. Recovering the array from that is worth doing;
- * guessing when there is no array at all is not, so anything unparseable is null and the caller keeps
- * the lexical order.
+ * Extracts a 1-based candidate integer array from the model's answer, or null.
+ * Tolerates surrounding markdown, explanatory text, and trailing commas.
+ * Returns empty array [] if the model explicitly declares no candidates are relevant.
  */
-export declare function parseRanking(output: string): number[] | null;
+export declare function parseRanking(output: string, maxIndex?: number): 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. */
@@ -116,6 +113,8 @@ export declare function digestOf(text: string): string;
  * repeated at the head of the next chunk to keep that sentence whole in at least one hit.
  */
 export declare function chunkDocument(text: string): KnowledgeChunk[];
+export declare const MIN_SCORE_ABSOLUTE = 0.28;
+export declare const RELATIVE_CUTOFF_RATIO = 0.5;
 export declare class KnowledgeBase {
     readonly directory: string;
     private store;

package/dist/server/knowledge.js

@@ -12,12 +12,12 @@ export const MAX_WORKSPACE_BYTES = 16 * 1024 * 1024;
 const CHUNK_CHARS = 1200;
 const CHUNK_OVERLAP_CHARS = 150;
 const MAX_CHUNKS_PER_DOCUMENT = 2000;
-export const DEFAULT_RESULT_LIMIT = 6;
+export const DEFAULT_RESULT_LIMIT = 3;
 export const MAX_RESULT_LIMIT = 20;
-/** Per hit. Enough to answer from, short enough that six hits stay inside one turn's prompt budget. */
+/** Per hit. Enough to answer from, short enough that hits stay inside one turn's prompt budget. */
 const RESULT_TEXT_CAP = 1200;
-/** Across all hits of one search. A model that asked for 20 passages still gets a bounded prompt. */
-const RESULT_TOTAL_CAP = 12000;
+/** Across all hits of one search. Lowered to 4800 to bound prompt impact on standard context windows. */
+const RESULT_TOTAL_CAP = 4800;
 /** Below this many candidates there is no ranking to correct, and the model call is not worth it. */
 const RERANK_MIN_CANDIDATES = 3;
 /** How many candidates the model sees. Larger pools cost prompt without improving the top few. */
@@ -26,26 +26,64 @@ const RERANK_POOL = 12;
 const RERANK_SNIPPET_CHARS = 240;
 const RERANK_TIMEOUT_MS = 12000;
 /**
- * The first integer array in the model's answer, or null.
- *
- * WHY TOLERANT PARSING. The prompt asks for a bare JSON array, and a model that mostly complies will
- * still sometimes wrap it in a sentence or a code fence. Recovering the array from that is worth doing;
- * guessing when there is no array at all is not, so anything unparseable is null and the caller keeps
- * the lexical order.
+ * Extracts a 1-based candidate integer array from the model's answer, or null.
+ * Tolerates surrounding markdown, explanatory text, and trailing commas.
+ * Returns empty array [] if the model explicitly declares no candidates are relevant.
  */
-export function parseRanking(output) {
-    const match = /\[\s*\d+(?:\s*,\s*\d+)*\s*\]/.exec(output ?? "");
-    if (!match)
+export function parseRanking(output, maxIndex) {
+    if (!output || typeof output !== "string")
         return null;
-    try {
-        const parsed = JSON.parse(match[0]);
-        if (!Array.isArray(parsed))
-            return null;
-        return parsed.filter((value) => Number.isInteger(value) && value > 0);
+    // 1. Prefer markdown code block: ```json ... ``` or ``` ... ```
+    const codeBlock = /```(?:json)?\s*(\[[\s\S]*?\])\s*```/i.exec(output);
+    const targetText = codeBlock ? codeBlock[1] : output;
+    // 2. Find bracketed arrays
+    const matches = [...targetText.matchAll(/\[[\s\S]*?\]/g)];
+    if (!matches.length)
+        return null;
+    // Try parsing from the last match backwards (models often put final answer at the end)
+    let parsed = null;
+    for (let i = matches.length - 1; i >= 0; i--) {
+        const candidate = matches[i][0].replace(/,\s*\]/, "]");
+        try {
+            const p = JSON.parse(candidate);
+            if (Array.isArray(p)) {
+                parsed = p;
+                break;
+            }
+        }
+        catch { }
     }
-    catch {
+    if (!Array.isArray(parsed))
         return null;
+    if (parsed.length === 0)
+        return [];
+    // Reject negative numbers or non-integers, per existing test: [0, 2, -1, 1.5] -> null
+    for (const item of parsed) {
+        if (typeof item === "number") {
+            if (!Number.isInteger(item) || item < 0)
+                return null;
+        }
+        else if (typeof item === "string") {
+            if (!/^\d+$/.test(item.trim()))
+                return null;
+        }
+        else {
+            return null;
+        }
     }
+    // Deduplicate and filter out-of-bounds (<= 0 or > maxIndex)
+    const seen = new Set();
+    const result = [];
+    for (const item of parsed) {
+        const val = typeof item === "string" ? parseInt(item.trim(), 10) : item;
+        if (val > 0 && (maxIndex === undefined || val <= maxIndex)) {
+            if (!seen.has(val)) {
+                seen.add(val);
+                result.push(val);
+            }
+        }
+    }
+    return result;
 }
 const CJK_RUN = /[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]+/gu;
 const LATIN_WORD = /[\p{L}\p{N}_.+#-]{2,}/gu;
@@ -212,6 +250,9 @@ const B = 0.75;
  * the chunk that actually answers may sit in a section whose heading shares nothing with the question.
  */
 const WEIGHT = { body: 1, phrase: 0.45, head: 0.5, document: 0.7, vector: 0.9 };
+const TOTAL_WEIGHT = WEIGHT.body + WEIGHT.phrase + WEIGHT.head + WEIGHT.document + WEIGHT.vector; // 3.55
+export const MIN_SCORE_ABSOLUTE = 0.28;
+export const RELATIVE_CUTOFF_RATIO = 0.5;
 function countTerms(terms) {
     const counts = new Map();
     for (const term of terms)
@@ -321,6 +362,10 @@ export class KnowledgeBase {
         const channels = [];
         const docTerms = new Map();
         let docLength = 0;
+        for (const term of tokenize(document.title)) {
+            docTerms.set(term, (docTerms.get(term) ?? 0) + 1);
+            docLength++;
+        }
         for (const chunk of chunks) {
             // Tokenised ONCE here, at import time, rather than on every search: a workspace with a hundred
             // documents would otherwise re-split the whole corpus per question.
@@ -359,9 +404,29 @@ export class KnowledgeBase {
         if (cached)
             return cached;
         const documents = (await this.readAll(workspaceId)).map(document => this.index(document));
+        const chunkDf = new Map(), phraseDf = new Map(), headDf = new Map(), docDf = new Map();
+        let chunkCount = 0;
+        for (const document of documents) {
+            for (const channels of document.channels) {
+                chunkCount++;
+                for (const [term] of channels.body)
+                    chunkDf.set(term, (chunkDf.get(term) ?? 0) + 1);
+                for (const [term] of channels.head)
+                    headDf.set(term, (headDf.get(term) ?? 0) + 1);
+                for (const [phrase] of channels.phrase)
+                    phraseDf.set(phrase, (phraseDf.get(phrase) ?? 0) + 1);
+            }
+            for (const [term] of document.docTerms)
+                docDf.set(term, (docDf.get(term) ?? 0) + 1);
+        }
         const index = {
             documents,
             averageLength: documents.length ? documents.reduce((sum, document) => sum + document.docLength, 0) / documents.length : 0,
+            chunkCount,
+            chunkDf,
+            phraseDf,
+            headDf,
+            docDf,
         };
         this.indexes.set(workspaceId, index);
         // Vectors are built in the background on first sight of a workspace, so a restart with an
@@ -528,29 +593,9 @@ export class KnowledgeBase {
         const phrases = [...new Set(tokenizePhrases(query ?? ""))];
         if (!terms.length && !phrases.length)
             return [];
-        const { documents, averageLength } = await this.load(workspaceId);
+        const { documents, averageLength, chunkCount, chunkDf, phraseDf, headDf, docDf } = await this.load(workspaceId);
         if (!documents.length || !averageLength)
             return [];
-        const chunkCount = documents.reduce((sum, document) => sum + document.chunks.length, 0);
-        // Document frequency is counted once per channel, over that channel's own unit: chunks for the
-        // passage channels, documents for the document channel.
-        const chunkDf = new Map(), phraseDf = new Map(), headDf = new Map(), docDf = new Map();
-        for (const document of documents) {
-            for (const channels of document.channels) {
-                for (const term of terms) {
-                    if (channels.body.has(term))
-                        chunkDf.set(term, (chunkDf.get(term) ?? 0) + 1);
-                    if (channels.head.has(term))
-                        headDf.set(term, (headDf.get(term) ?? 0) + 1);
-                }
-                for (const phrase of phrases)
-                    if (channels.phrase.has(phrase))
-                        phraseDf.set(phrase, (phraseDf.get(phrase) ?? 0) + 1);
-            }
-            for (const term of terms)
-                if (document.docTerms.has(term))
-                    docDf.set(term, (docDf.get(term) ?? 0) + 1);
-        }
         const hits = [];
         let bodyBest = 0, phraseBest = 0, headBest = 0, docBest = 0;
         for (const document of documents) {
@@ -601,18 +646,29 @@ export class KnowledgeBase {
         const similarities = this.vectors
             ? await this.vectors.search(workspaceId, query ?? "", lexical.map(entry => [entry.key, entry.hit.documentId]))
             : null;
-        const fused = lexical
-            .map(entry => {
+        const rawScores = lexical.map(entry => {
             const similarity = similarities?.get(entry.key) ?? 0;
-            const score = Math.round(1000 * (entry.lexical + (similarities ? WEIGHT.vector * similarity : 0)
-                + (entry.lexical > 0 ? WEIGHT.document * (docBest ? entry.document / docBest : 0) : 0))) / 1000;
+            const rawScore = entry.lexical + (similarities ? WEIGHT.vector * similarity : 0)
+                + (entry.lexical > 0 ? WEIGHT.document * (docBest ? entry.document / docBest : 0) : 0);
+            const score = Math.min(1, Math.round(1000 * (rawScore / TOTAL_WEIGHT)) / 1000);
             return { ...entry.hit, score };
-        })
-            .filter(hit => hit.score > 0);
+        });
+        // 1. Absolute threshold filter: drop anything with score < MIN_SCORE_ABSOLUTE (0.28)
+        const passedAbsolute = rawScores.filter(hit => hit.score >= MIN_SCORE_ABSOLUTE);
+        if (!passedAbsolute.length)
+            return [];
         // Best-first, with the tie broken by chunk order so two equal passages of one document come back
         // in the order a reader would meet them.
-        fused.sort((a, b) => b.score - a.score || a.chunk - b.chunk);
-        const ordered = options.rerank ? await this.rerank(options.conversation, query ?? "", fused, options.signal) ?? fused : fused;
+        passedAbsolute.sort((a, b) => b.score - a.score || a.chunk - b.chunk);
+        // 2. Relative cutoff: drop anything with score < bestScore * RELATIVE_CUTOFF_RATIO (0.50)
+        const bestScore = passedAbsolute[0].score;
+        const fused = passedAbsolute.filter(hit => hit.score >= bestScore * RELATIVE_CUTOFF_RATIO);
+        if (!fused.length)
+            return [];
+        const reranked = options.rerank ? await this.rerank(options.conversation, query ?? "", fused, options.signal) : null;
+        const ordered = reranked ?? fused;
+        if (!ordered.length)
+            return [];
         const selected = [];
         let spent = 0;
         for (const hit of ordered) {
@@ -670,23 +726,45 @@ export class KnowledgeBase {
                 agentId: undefined, messages: [], status: "idle",
             };
             const listing = pool.map((hit, position) => `[${position + 1}] 《${hit.title}》${hit.heading ? ` > ${hit.heading}` : ""}\n${hit.text.slice(0, RERANK_SNIPPET_CHARS).replace(/\n+/g, " ")}`).join("\n\n");
-            const prompt = `你是检索排序器。用户提出了一个问题，下面是知识库检索出的候选片段。请按「能否回答这个问题」从高到低排序，只输出最相关的前几个片段编号，输出 JSON 数组，例如 [3,1]。不要输出解释文字，不要输出编号以外的内容。\n\n问题：${query}\n\n候选片段：\n${listing}`;
+            const prompt = `你是检索排序器。用户提出了一个问题，下面是知识库检索出的候选片段。请按「能否回答这个问题」对候选片段进行筛选与重排序。
+评分准则：
+1. 仅保留能够回答问题或与问题高度相关的片段。
+2. 按相关度从高到低排序，输出候选编号的 JSON 数组，例如 [3, 1]。
+3. 若所有候选片段均不相关，输出空数组 []。
+4. 只输出 JSON 数组，不要输出解释文字，不要输出编号以外的内容。
+
+问题：${query}
+
+候选片段：
+${listing}`;
             let output = "";
             for await (const piece of this.runtime.answer({ conversation: isolated, prompt, cwd: workspace.path, signal: controller.signal, knowledgeRerank: true })) {
                 output += piece;
                 if (controller.signal.aborted)
                     return null;
             }
-            const parsed = parseRanking(output);
-            if (!parsed?.length)
+            const parsed = parseRanking(output, pool.length);
+            if (parsed === null)
                 return null;
+            if (parsed.length === 0)
+                return [];
             const picked = parsed.map((index) => pool[index - 1]).filter((hit) => Boolean(hit));
             if (!picked.length)
-                return null;
-            // Anything the model left out keeps its lexical position after the picks, so a partial or
-            // truncated answer still returns the full pool rather than silently losing candidates.
+                return [];
+            // Anything the model left out keeps its position after the picks
             const chosen = new Set(picked);
-            return [...picked, ...pool.filter(hit => !chosen.has(hit))];
+            const remaining = pool.filter(hit => !chosen.has(hit));
+            const reordered = [...picked, ...remaining];
+            // Re-assign monotonically non-increasing scores based on pool's score distribution
+            const poolScores = pool.map(h => h.score).sort((a, b) => b - a);
+            let lastScore = poolScores[0];
+            return reordered.map((hit, index) => {
+                let assigned = poolScores[index];
+                if (assigned > lastScore)
+                    assigned = lastScore;
+                lastScore = assigned;
+                return { ...hit, score: assigned };
+            });
         }
         catch {
             return null;

package/dist/server/length-continuation.d.ts

@@ -0,0 +1,50 @@
+/**
+ * THE CONTINUATION ORDER: what a session is told when its answer was cut off by the output limit.
+ *
+ * WHY THIS IS ITS OWN MODULE. Three places have to agree on it: the orchestrator that sends it,
+ * the prompt builder that tells the model who is speaking, and the browser that renders the row it
+ * becomes. When those three each held their own copy of the wording, a change to one of them left
+ * the other two describing a message that was no longer being sent.
+ *
+ * WHY THE ORDER EXISTS AT ALL. A model that filled its single-response output budget did not fail -
+ * it answered, and the answer was cut short. The work it was doing is not over. So the session is
+ * asked to carry on, in the SAME conversation, where its own partial answer is already in its
+ * context. That is what lets the model resume at the sentence it stopped on instead of starting
+ * the answer again.
+ *
+ * WHY IT IS AN ORDER AND NOT A USER MESSAGE. The person never typed it, and a row under their name
+ * saying words they never said is the exact bug this ordering was built to avoid.
+ */
+/**
+ * THE ENVELOPE A CONTINUATION ORDER TRAVELS IN.
+ *
+ * The browser renders a `tool` row by looking at the content, and it tells a delivered result
+ * (`<task ...>`) from an order (no envelope) by the same inspection. A continuation is neither: it
+ * is the system telling the session to keep writing, and it needs a third label - 「续写」 - because
+ * calling it a 「智能体下发」 order would say the system sent a task, which is not what happened.
+ */
+export declare const LENGTH_CONTINUATION_ENVELOPE = "continue_output";
+/**
+ * THE TEXT THE MODEL IS GIVEN.
+ *
+ * It says two things, and both are needed. "Continue" alone invites a model to start the answer
+ * again from the top, because the model cannot tell that the earlier text was already accepted;
+ * "do not repeat what you have written" is what makes the continuation an extension rather than a
+ * second attempt.
+ */
+export declare const LENGTH_CONTINUATION_TEXT = "\u4E0A\u4E00\u6761\u56DE\u7B54\u56E0\u4E3A\u8FBE\u5230\u5355\u6B21\u8F93\u51FA\u7684\u957F\u5EA6\u4E0A\u9650\u88AB\u622A\u65AD\u4E86\u3002\u8BF7\u76F4\u63A5\u4ECE\u88AB\u622A\u65AD\u7684\u5730\u65B9\u63A5\u7740\u5199\u5B8C\uFF0C\u4E0D\u8981\u91CD\u590D\u5DF2\u7ECF\u5199\u8FC7\u7684\u5185\u5BB9\u3002";
+/**
+ * THE WHOLE ORDER, ENCLOSED.
+ *
+ * The envelope is what makes the row recognisable, and it wraps the text so the browser can show
+ * the instruction rather than the markup.
+ */
+export declare const LENGTH_CONTINUATION_PROMPT = "<continue_output>\u4E0A\u4E00\u6761\u56DE\u7B54\u56E0\u4E3A\u8FBE\u5230\u5355\u6B21\u8F93\u51FA\u7684\u957F\u5EA6\u4E0A\u9650\u88AB\u622A\u65AD\u4E86\u3002\u8BF7\u76F4\u63A5\u4ECE\u88AB\u622A\u65AD\u7684\u5730\u65B9\u63A5\u7740\u5199\u5B8C\uFF0C\u4E0D\u8981\u91CD\u590D\u5DF2\u7ECF\u5199\u8FC7\u7684\u5185\u5BB9\u3002</continue_output>";
+/**
+ * Whether this content is a continuation order.
+ */
+export declare function isLengthContinuation(content: string): boolean;
+/**
+ * THE TEXT INSIDE THE ENVELOPE, or the content itself when it carries no envelope.
+ */
+export declare function lengthContinuationText(content: string): string;

package/dist/server/length-continuation.js

@@ -0,0 +1,55 @@
+/**
+ * THE CONTINUATION ORDER: what a session is told when its answer was cut off by the output limit.
+ *
+ * WHY THIS IS ITS OWN MODULE. Three places have to agree on it: the orchestrator that sends it,
+ * the prompt builder that tells the model who is speaking, and the browser that renders the row it
+ * becomes. When those three each held their own copy of the wording, a change to one of them left
+ * the other two describing a message that was no longer being sent.
+ *
+ * WHY THE ORDER EXISTS AT ALL. A model that filled its single-response output budget did not fail -
+ * it answered, and the answer was cut short. The work it was doing is not over. So the session is
+ * asked to carry on, in the SAME conversation, where its own partial answer is already in its
+ * context. That is what lets the model resume at the sentence it stopped on instead of starting
+ * the answer again.
+ *
+ * WHY IT IS AN ORDER AND NOT A USER MESSAGE. The person never typed it, and a row under their name
+ * saying words they never said is the exact bug this ordering was built to avoid.
+ */
+/**
+ * THE ENVELOPE A CONTINUATION ORDER TRAVELS IN.
+ *
+ * The browser renders a `tool` row by looking at the content, and it tells a delivered result
+ * (`<task ...>`) from an order (no envelope) by the same inspection. A continuation is neither: it
+ * is the system telling the session to keep writing, and it needs a third label - 「续写」 - because
+ * calling it a 「智能体下发」 order would say the system sent a task, which is not what happened.
+ */
+export const LENGTH_CONTINUATION_ENVELOPE = "continue_output";
+/**
+ * THE TEXT THE MODEL IS GIVEN.
+ *
+ * It says two things, and both are needed. "Continue" alone invites a model to start the answer
+ * again from the top, because the model cannot tell that the earlier text was already accepted;
+ * "do not repeat what you have written" is what makes the continuation an extension rather than a
+ * second attempt.
+ */
+export const LENGTH_CONTINUATION_TEXT = "上一条回答因为达到单次输出的长度上限被截断了。请直接从被截断的地方接着写完，不要重复已经写过的内容。";
+/**
+ * THE WHOLE ORDER, ENCLOSED.
+ *
+ * The envelope is what makes the row recognisable, and it wraps the text so the browser can show
+ * the instruction rather than the markup.
+ */
+export const LENGTH_CONTINUATION_PROMPT = `<${LENGTH_CONTINUATION_ENVELOPE}>${LENGTH_CONTINUATION_TEXT}</${LENGTH_CONTINUATION_ENVELOPE}>`;
+/**
+ * Whether this content is a continuation order.
+ */
+export function isLengthContinuation(content) {
+    return content.includes(`<${LENGTH_CONTINUATION_ENVELOPE}>`);
+}
+/**
+ * THE TEXT INSIDE THE ENVELOPE, or the content itself when it carries no envelope.
+ */
+export function lengthContinuationText(content) {
+    const match = new RegExp(`<${LENGTH_CONTINUATION_ENVELOPE}>([\\s\\S]*?)</${LENGTH_CONTINUATION_ENVELOPE}>`).exec(content);
+    return match ? match[1].trim() : content.trim();
+}

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

@@ -18,6 +18,7 @@
  */
 import { describeToolCall, describeToolCallArgs, extractPartialResultText, readQuestionCall } from "./tool-calls.js";
 import { toolTargetPath } from "./file-changes.js";
+import { LengthExceededError } from "./turn-failure.js";
 /** Keeps only real strings, so a malformed queue snapshot cannot put objects into a broadcast. */
 const textList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : undefined;
 /**
@@ -337,7 +338,10 @@ export function handleSessionEvent(event, queue, handlers, report, failure) {
             const held = failure?.current;
             if (held) {
                 failure.current = undefined;
-                queue.push({ kind: "error", error: new Error(held.message) });
+                const err = held.stopReason === "length"
+                    ? new LengthExceededError(held.message)
+                    : new Error(held.message);
+                queue.push({ kind: "error", error: err });
                 return true;
             }
             queue.push({ kind: "end" });

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

@@ -165,6 +165,8 @@ export declare class PiSessionPool {
      * tool allowlist has changed.
      */
     acquire(request: SessionRequest): Promise<PiSessionLike>;
+    /** Keep an accidental session fan-out from retaining one full transcript context per conversation. */
+    private evictOverflow;
     private build;
     /**
      * Puts a live session on the model and level the conversation is asking for.