@evandu/super-pi 0.1.133 → 0.1.136

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

@@ -1,5 +1,4 @@
 import { assertModelAllowed } from "../model-filter.js";
-import { deleteConversationUploads } from "../upload.js";
 /**
  * Service managing workspaces: creation, rename, cascade deletion, and defaults configuration.
  */
@@ -10,16 +9,14 @@ export class WorkspaceService {
     catalogService;
     runService;
     extensionUiService;
-    uploadsDir;
     agentsDir;
-    constructor(store, runtime, broadcaster, catalogService, runService, extensionUiService, uploadsDir, agentsDir) {
+    constructor(store, runtime, broadcaster, catalogService, runService, extensionUiService, agentsDir) {
         this.store = store;
         this.runtime = runtime;
         this.broadcaster = broadcaster;
         this.catalogService = catalogService;
         this.runService = runService;
         this.extensionUiService = extensionUiService;
-        this.uploadsDir = uploadsDir;
         this.agentsDir = agentsDir;
     }
     setAgentsDir(dir) {
@@ -41,21 +38,25 @@ export class WorkspaceService {
         this.broadcaster.broadcastState();
     }
     /**
-     * Deletes a workspace and cascades cleanup to active runs, subagent runs,
-     * uploaded files, and stored conversations.
+     * Takes a workspace out of the sidebar. NOTHING IS DELETED.
+     *
+     * The conversations under it, the uploads attached to them and the workspace's own defaults all
+     * stay on disk: removing a workspace from the list is a soft unmount, and adding the same
+     * folder back brings the whole history with it. What does stop is the WORK: a turn that was still
+     * running cannot keep a model session alive behind a workspace the user can no longer see, and a
+     * pending question would wait for an answer the sidebar can no longer reach.
      */
     async deleteWorkspace(workspaceId) {
         const snapshot = this.store.snapshot();
-        const doomed = snapshot.conversations.filter((c) => c.workspaceId === workspaceId);
-        for (const c of doomed) {
+        const affected = snapshot.conversations.filter((c) => c.workspaceId === workspaceId);
+        for (const c of affected) {
             this.extensionUiService.cancelPendingUi(c.id, "aborted");
             if (this.runService.isRunning(c.id)) {
                 await this.runService.stopRun(c.id);
             }
             this.runService.stopConversationSubagents(c.id);
         }
-        const doomedIds = await this.store.deleteWorkspace(workspaceId);
-        await Promise.all(doomedIds.map((id) => deleteConversationUploads(this.uploadsDir, id)));
+        await this.store.deleteWorkspace(workspaceId);
         this.broadcaster.broadcastState();
     }
     /**

package/dist/server/failure-text.d.ts

@@ -0,0 +1,18 @@
+/**
+ * THE TEXT OF A FAILURE.
+ *
+ * A server failure reaches the browser as a sentence, and the reader is entitled to know what
+ * actually went wrong. The trouble is that what was thrown is not always an `Error`: it can be a
+ * string, a plain object, a rejected promise with no reason at all. The old code answered
+ * `command failed` in those cases - the one sentence that says nothing about anything - so a real
+ * cause that had reached the server was replaced by a sentence with no cause in it.
+ *
+ * This module is the one place that decides what a thrown value turns into. It never invents
+ * text: an `Error` gives its message, a string gives itself, an object gives its `message` or its
+ * JSON, and a value that carries no information at all gives an EMPTY STRING - which the client
+ * reads as "no reason was given", and says so out loud instead of pretending.
+ */
+/** The failure as a person should read it. Empty when the thrown value carries no information. */
+export declare function describeThrown(error: unknown): string;
+/** The failure with its stack, for the log file. */
+export declare function describeThrownWithStack(error: unknown): string;

package/dist/server/failure-text.js

@@ -0,0 +1,44 @@
+/**
+ * THE TEXT OF A FAILURE.
+ *
+ * A server failure reaches the browser as a sentence, and the reader is entitled to know what
+ * actually went wrong. The trouble is that what was thrown is not always an `Error`: it can be a
+ * string, a plain object, a rejected promise with no reason at all. The old code answered
+ * `command failed` in those cases - the one sentence that says nothing about anything - so a real
+ * cause that had reached the server was replaced by a sentence with no cause in it.
+ *
+ * This module is the one place that decides what a thrown value turns into. It never invents
+ * text: an `Error` gives its message, a string gives itself, an object gives its `message` or its
+ * JSON, and a value that carries no information at all gives an EMPTY STRING - which the client
+ * reads as "no reason was given", and says so out loud instead of pretending.
+ */
+/** The failure as a person should read it. Empty when the thrown value carries no information. */
+export function describeThrown(error) {
+    if (error instanceof Error)
+        return error.message || error.name;
+    if (typeof error === "string")
+        return error;
+    if (error === null || error === undefined)
+        return "";
+    if (typeof error === "object") {
+        const message = error.message;
+        if (typeof message === "string" && message.trim())
+            return message;
+        try {
+            const text = JSON.stringify(error);
+            if (text && text !== "{}")
+                return text;
+        }
+        catch {
+            // Circular or otherwise unserializable: there is nothing better to say than "no reason".
+        }
+        return "";
+    }
+    return String(error);
+}
+/** The failure with its stack, for the log file. */
+export function describeThrownWithStack(error) {
+    if (error instanceof Error && error.stack)
+        return error.stack;
+    return describeThrown(error);
+}

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.js

@@ -6,6 +6,7 @@ import { homedir, networkInterfaces } from "node:os";
 import { basename, dirname, extname, join, relative, resolve } from "node:path";
 import { describe as describeFilesError, fileMeta, listDirectory, MAX_FILE_BYTES, readWorkspaceFile, resolveInsideRoot, toRelative, writeWorkspaceFile, } from "./files.js";
 import { findUploadFile, MAX_UPLOAD_BODY_BYTES, saveUpload } from "./upload.js";
+import { describeThrown } from "./failure-text.js";
 import { checkDiskVersion } from "./version.js";
 import { gitBlame, gitDiff, gitLog, gitMutate, gitStatus } from "./git.js";
 import { computeFileDiff } from "./file-diff.js";
@@ -282,7 +283,7 @@ export function createHttpServer(options) {
                 return;
             }
             catch (error) {
-                json(400, { error: error instanceof Error ? error.message : "tool export failed" });
+                json(400, { error: describeThrown(error) || "导出工具失败，没有拿到失败原因。" });
                 return;
             }
         }
@@ -360,7 +361,7 @@ export function createHttpServer(options) {
                 return;
             }
             catch (error) {
-                json(400, { error: error instanceof Error ? error.message : "tool request failed" });
+                json(400, { error: describeThrown(error) || "工具请求失败，没有拿到失败原因。" });
                 return;
             }
         }
@@ -422,7 +423,7 @@ export function createHttpServer(options) {
                     toolApi(202, run);
                 }
                 catch (error) {
-                    toolApi(400, { error: error instanceof Error ? error.message : "tool run failed" });
+                    toolApi(400, { error: describeThrown(error) || "工具运行失败，没有拿到失败原因。" });
                 }
                 return;
             }
@@ -513,7 +514,7 @@ export function createHttpServer(options) {
                         toolApi(202, context.toolLlm.start({ toolId: id, prompt: body.prompt ?? "", system: body.system, timeoutMs: body.timeoutMs }));
                     }
                     catch (error) {
-                        toolApi(400, { error: error instanceof Error ? error.message : "model call failed" });
+                        toolApi(400, { error: describeThrown(error) || "模型调用失败，没有拿到失败原因。" });
                     }
                     return;
                 }
@@ -1039,6 +1040,16 @@ export function createHttpServer(options) {
                     return;
                 }
                 if (request.method === "POST") {
+                    // A GIT WRITE IS A WRITE, AND IT GETS THE SAME GATE AS EVERY OTHER WRITE. `gitMutate` can
+                    // stage, DISCARD (`git restore -- <path>`, which throws away uncommitted work), commit,
+                    // pull and PUSH - so an endpoint that skips the address predicate hands a public caller the
+                    // keys to somebody's repository. The server listens on 0.0.0.0 by default and the global
+                    // access token is OPTIONAL (`isAuthorized` passes everyone when there is none), so this
+                    // predicate IS the boundary for every other write endpoint in this file (ledger TEST-042).
+                    if (!isLocalOrPrivateAddress(remote)) {
+                        json(403, { error: "Git 写操作只允许来自本机或局域网的请求。" });
+                        return;
+                    }
                     let raw = "";
                     for await (const chunk of request)
                         raw += chunk;
@@ -1417,7 +1428,7 @@ export function createHttpServer(options) {
                 response.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify(result));
             }
             catch (error) {
-                response.writeHead(400, { "content-type": "application/json" }).end(JSON.stringify({ error: error instanceof Error ? error.message : "question failed" }));
+                response.writeHead(400, { "content-type": "application/json" }).end(JSON.stringify({ error: describeThrown(error) || "问答失败，没有拿到失败原因。" }));
             }
             return;
         }

package/dist/server/index.js

@@ -137,7 +137,10 @@ const paths = {
 const runtime = process.env.SUPER_PI_RUNTIME === "welcome"
     ? new WelcomeRuntime()
     : new PiRpcRuntime(join(dataDir, "pi-sessions"), undefined, { dir: initialAgentDirs, promptDir: agentPromptDir }, { endpoint: taskEndpoint, execEndpoint, todoEndpoint, workflowEndpoint, questionEndpoint, toolsEndpoint, documentsEndpoint, scheduledTaskEndpoint, uploadsDir });
-const broadcaster = new WsBroadcaster(() => store.snapshot());
+// THE CLIENT GETS THE VISIBLE STATE, NOT THE WHOLE STORE. `clientState()` is `snapshot()` minus the
+// workspaces that were taken out of the sidebar - they are still in the store (that is what lets the
+// same folder be added back with its history), but they are not part of the app any more.
+const broadcaster = new WsBroadcaster(() => store.clientState());
 const memory = new ActiveMemory(join(dataDir, "memories"), store, runtime);
 process.env.SUPER_PI_MEMORY_ENDPOINT = `http://${internalHost}:${port}/api/memory/tool`;
 if (runtime instanceof PiRpcRuntime)
@@ -243,7 +246,7 @@ const nameIndexes = new Map();
 runService.setNameIndexes(nameIndexes);
 const conversationService = new ConversationService(store, runtime, subagents, broadcaster, catalogService, runService, extensionUiService, initialAgentDirs);
 conversationService.setMemory(memory);
-const workspaceService = new WorkspaceService(store, runtime, broadcaster, catalogService, runService, extensionUiService, uploadsDir, initialAgentDirs);
+const workspaceService = new WorkspaceService(store, runtime, broadcaster, catalogService, runService, extensionUiService, initialAgentDirs);
 /**
  * The terminal, constructed before `serverContext` because that object carries the two predicates
  * `/api/terminal` answers with.

package/dist/server/knowledge-embedding-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/knowledge-embedding-worker.js

@@ -0,0 +1,27 @@
+import { parentPort } from "node:worker_threads";
+let extractor;
+let loading;
+async function load(request) {
+    if (extractor)
+        return extractor;
+    loading ??= (async () => {
+        const specifier = "@huggingface/transformers";
+        const transformers = await import(specifier);
+        transformers.env.localModelPath = request.modelRoot;
+        transformers.env.allowRemoteModels = false;
+        extractor = await transformers.pipeline("feature-extraction", request.model, { dtype: "q8" });
+        return extractor;
+    })();
+    return loading;
+}
+parentPort?.on("message", async (request) => {
+    try {
+        const run = await load(request);
+        const output = await run(request.texts, { pooling: "cls", normalize: true });
+        const buffer = output.data.buffer;
+        parentPort?.postMessage({ id: request.id, data: output.data, dims: output.dims }, [buffer]);
+    }
+    catch (error) {
+        parentPort?.postMessage({ id: request.id, error: error instanceof Error ? error.message : String(error) });
+    }
+});

package/dist/server/knowledge-vectors.d.ts

@@ -59,8 +59,10 @@ export type VectorDocument = {
  */
 export declare class VectorIndex {
     private readonly directory;
-    private extractor?;
-    private loading?;
+    private worker?;
+    private workerSequence;
+    private workerReady;
+    private workerPending;
     private failure?;
     private cache;
     private pending;
@@ -91,7 +93,7 @@ export declare class VectorIndex {
      * 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.
      */
-    private load;
+    private ensureWorker;
     private embed;
     /** Vectors already stored for one workspace, keyed by document then chunk index. */
     private read;

package/dist/server/knowledge-vectors.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { mkdir, readFile, readdir, rename, unlink, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import { Worker } from "node:worker_threads";
 /**
  * The model, and the only one this feature can use.
  *
@@ -78,8 +79,10 @@ export function cosine(a, b) {
  */
 export class VectorIndex {
     directory;
-    extractor;
-    loading;
+    worker;
+    workerSequence = 0;
+    workerReady = false;
+    workerPending = new Map();
     failure;
     cache = new Map();
     pending = new Set();
@@ -100,7 +103,7 @@ export class VectorIndex {
     enabled() { return process.env.SUPER_PI_KNOWLEDGE_EMBEDDINGS !== "0"; }
     status(indexed) {
         return {
-            enabled: this.enabled(), ready: Boolean(this.extractor), indexed, error: this.failure,
+            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()),
@@ -119,57 +122,56 @@ export class VectorIndex {
      * 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.
      */
-    load() {
-        if (this.extractor)
-            return Promise.resolve(this.extractor);
+    ensureWorker() {
+        if (this.worker)
+            return this.worker;
         if (this.failure)
-            return Promise.resolve(undefined);
-        this.loading ??= (async () => {
-            try {
-                if (!existsSync(this.bundledModel()))
-                    throw new Error(`随包分发的模型缺失：${this.bundledModel()}`);
-                // THE SPECIFIER GOES THROUGH A VARIABLE, and that is deliberate. Written as a literal,
-                // `tsc` resolves it while compiling - so a machine whose optional install skipped this package
-                // could not build the server at all, which makes an "optional" dependency mandatory in the
-                // only sense that matters to a person who installed it. Node resolves the variable at RUN time
-                // instead, where its absence is already handled: the throw below is the same branch that
-                // handles a missing model.
-                const specifier = "@huggingface/transformers";
-                const { pipeline, env } = await import(specifier);
-                // The library resolves `<localModelPath>/<model id>/onnx/...`, which is why the vendored tree
-                // keeps the `Xenova/bge-small-zh-v1.5` directory rather than being flattened.
-                env.localModelPath = this.bundledModel();
-                env.allowRemoteModels = false;
-                this.extractor = await pipeline("feature-extraction", KNOWLEDGE_MODEL, { dtype: "q8" });
-                return this.extractor;
-            }
-            catch (error) {
-                this.failure = error instanceof Error ? error.message : String(error);
-                console.warn(`Super Pi: 语义检索不可用，将只用关键词检索：${this.failure}`);
-                return undefined;
-            }
-            finally {
-                this.loading = undefined;
+            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;
             }
-        })();
-        return this.loading;
+            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;
     }
     async embed(texts) {
         if (!texts.length || !this.enabled())
             return null;
-        const extractor = await this.load();
-        if (!extractor)
+        const worker = this.ensureWorker();
+        if (!worker)
             return null;
-        try {
-            const output = await extractor(texts, { pooling: "cls", normalize: true });
-            const dimension = output.dims[output.dims.length - 1];
-            return Array.from({ length: output.dims[0] }, (_, row) => Array.from(output.data.slice(row * dimension, (row + 1) * dimension)));
-        }
-        catch (error) {
-            this.failure = error instanceof Error ? error.message : String(error);
-            console.warn(`Super Pi: 生成向量失败，将只用关键词检索：${this.failure}`);
-            return null;
-        }
+        const id = ++this.workerSequence;
+        return new Promise((resolvePromise) => {
+            this.workerPending.set(id, { resolve: resolvePromise });
+            worker.postMessage({ id, texts, modelRoot: this.bundledModel(), model: KNOWLEDGE_MODEL });
+        });
     }
     /** Vectors already stored for one workspace, keyed by document then chunk index. */
     async read(workspaceId, documentId) {

package/dist/server/knowledge.d.ts

@@ -125,6 +125,7 @@ export declare class KnowledgeBase {
     private indexes;
     private serial;
     constructor(directory: string, store: Store, runtime?: KnowledgeRuntime | undefined, vectors?: VectorIndex | undefined);
+    private hasWorkspace;
     /** `SUPER_PI_KNOWLEDGE_ENABLED=0` turns the whole feature off, the same way memory turns off. */
     enabled(): boolean;
     /** The opaque workspace identity on disk, encoded. Paths never come from the model or the request. */

package/dist/server/knowledge.js

@@ -253,13 +253,17 @@ export class KnowledgeBase {
         this.runtime = runtime;
         this.vectors = vectors;
     }
+    hasWorkspace(workspaceId) {
+        const store = this.store;
+        return store.hasWorkspace ? store.hasWorkspace(workspaceId) : store.snapshot().workspaces.some(workspace => workspace.id === workspaceId);
+    }
     /** `SUPER_PI_KNOWLEDGE_ENABLED=0` turns the whole feature off, the same way memory turns off. */
     enabled() { return process.env.SUPER_PI_KNOWLEDGE_ENABLED !== "0"; }
     /** The opaque workspace identity on disk, encoded. Paths never come from the model or the request. */
     folder(workspaceId) { return join(this.directory, Buffer.from(workspaceId).toString("hex")); }
     file(workspaceId, documentId) { return join(this.folder(workspaceId), `${documentId}.json`); }
     requireWorkspace(workspaceId) {
-        if (!this.store.snapshot().workspaces.some(workspace => workspace.id === workspaceId))
+        if (!this.hasWorkspace(workspaceId))
             throw new Error("工作区不存在");
     }
     async locked(work) {
@@ -710,7 +714,7 @@ export class KnowledgeBase {
         const identity = this.capabilities.get(token);
         // The workspace is re-checked against the store, so a token minted before a workspace was deleted
         // cannot keep serving its documents afterwards.
-        if (!identity || !this.store.snapshot().workspaces.some(workspace => workspace.id === identity.workspaceId))
+        if (!identity || !this.hasWorkspace(identity.workspaceId))
             throw new Error("知识库授权已失效");
         return identity;
     }

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/persistence/sqlite-state-repository.d.ts

@@ -1,6 +1,5 @@
 import type { AppState } from "../types.js";
 import type { AppStateRepository, StateTransaction } from "./app-state-repository.js";
-/** SQLite snapshot adapter with row-level writes for streamed messages and runs. */
 export declare class SqliteStateRepository implements AppStateRepository {
     private readonly db;
     constructor(path: string);

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

@@ -1,5 +1,24 @@
 import { DatabaseSync } from "node:sqlite";
 /** SQLite snapshot adapter with row-level writes for streamed messages and runs. */
+/**
+ * THE ROW THAT SAYS "THIS CONVERSATION'S ARRAY IS EMPTY".
+ *
+ * A missing row in `message_order` used to mean two different things: "this conversation was never
+ * written incrementally" AND "this conversation's array was emptied". The loader could only read the
+ * first one, so a conversation whose LAST message was withdrawn fell back to the base snapshot - and
+ * the withdrawn message came back, carrying `delivery: "waiting"`, to be handed to the model by the
+ * next turn. A withdrawal is the last act of "take back what I have not sent yet", and it did not
+ * survive a restart (ledger TEST-041).
+ *
+ * A sentinel row says the difference. It is marked by a NEGATIVE POSITION - a real message's
+ * position is never negative - so it is never mistaken for one, and the loader reads it as "empty"
+ * rather than as "not written". (The marker is the position and NOT the id on purpose: a NUL in the
+ * id would be truncated by SQLite's TEXT handling, and the row would stop being recognisable.)
+ */
+const EMPTY_ARRAY_POSITION = -1;
+/** The id that goes with the sentinel row. It never becomes a message: the loader drops every row
+ *  whose position is negative, and this row's position IS negative. */
+const EMPTY_ARRAY_SENTINEL_ID = "empty-array";
 export class SqliteStateRepository {
     db;
     constructor(path) {
@@ -58,7 +77,12 @@ export class SqliteStateRepository {
             // was last rewritten - the placeholder an assistant message was born with, not what it streamed.
             const ordered = this.db.prepare("SELECT id,position,json FROM message_order WHERE conversation=? ORDER BY position").all(conversation.id);
             if (ordered.length) {
-                conversation.messages = ordered.map((row) => overrides.get(String(row.id)) ?? JSON.parse(String(row.json)));
+                // Rows EXIST, so this conversation was written incrementally and these rows are authoritative -
+                // including the sentinel, which says the array is empty. The sentinel is not a message and
+                // never becomes one.
+                conversation.messages = ordered
+                    .filter((row) => Number(row.position) >= 0)
+                    .map((row) => overrides.get(String(row.id)) ?? JSON.parse(String(row.json)));
             }
             else {
                 if (!Array.isArray(conversation.messages))
@@ -163,6 +187,12 @@ export class SqliteStateRepository {
                         upsertMessage.run(conversationId, message.id, json);
                         insertOrdered.run(conversationId, message.id, position, json);
                     });
+                    // An EMPTY ARRAY MUST BE WRITTEN DOWN, or "no rows" will read as "never written" and the
+                    // loader will fall back to the base snapshot - which still holds the message the person
+                    // just withdrew (ledger TEST-041).
+                    if (transaction.messages.length === 0) {
+                        insertOrdered.run(conversationId, EMPTY_ARRAY_SENTINEL_ID, EMPTY_ARRAY_POSITION, "[]");
+                    }
                 }
                 else {
                     const nextIds = new Set(transaction.messages.map((message) => message.id));
@@ -185,6 +215,12 @@ export class SqliteStateRepository {
                         if (positions.get(message.id) !== position)
                             upsertOrder.run(conversationId, message.id, position, json);
                     });
+                    // The LAST MESSAGE GONE leaves the order table with no rows, and no rows read as "never
+                    // written" - so the loader would fall back to the base snapshot and hand the withdrawn
+                    // message back to the model. The sentinel says the array is empty (ledger TEST-041).
+                    if (transaction.messages.length === 0) {
+                        upsertOrder.run(conversationId, EMPTY_ARRAY_SENTINEL_ID, EMPTY_ARRAY_POSITION, "[]");
+                    }
                 }
                 // The stamp is WRITTEN, not cleared. Opening a turn moves `updatedAt`, and this is the only write
                 // that can record it; clearing the overlay instead would leave the reopened conversation reporting

package/dist/server/providers.d.ts

@@ -284,3 +284,16 @@ export declare function fetchRemoteModels(input: {
     apiKey?: string;
     api?: string;
 }): Promise<DiscoveredModel[]>;
+/**
+ * THE ANSWER, READ.
+ *
+ * Split out of `fetchRemoteModels` so that the part worth asserting - what a provider's answer MEANS -
+ * can be tested without a network in between. A remote provider answers in three shapes (a bare array,
+ * `{data: [...]}` for OpenAI, `{models: [...]}` for Ollama), and each entry names itself with `id`,
+ * `name` or `model`; what the panel shows next to it - whether the model reasons, whether it takes
+ * images - is inferred from the name, because that is all most providers tell us.
+ *
+ * `fetchRemoteModels` is the transport; this is the reading. Keeping them apart means the reading can
+ * be pinned exactly, and a slow machine can never turn a parsing question into a timeout.
+ */
+export declare function parseRemoteModels(payload: unknown): DiscoveredModel[];