@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/shared/journal-reader.js

@@ -1,407 +1,6 @@
-import * as fs from "node:fs";
-import * as parserModule from "stream-json/core/parser.js";
-// The public synchronous tokenizer is exported by 3.7.0 but omitted from its declarations.
-const jsonParser = parserModule.jsonParser;
-const endInput = Symbol.for("object-stream.none");
-/** Validate everything, assembling only selected fields. Discarded strings are never packed. */
-export class JsonProjection {
-    parse = jsonParser({ packValues: false });
-    stack = [];
-    scalar;
-    key = false;
-    keyLimit = 4096;
-    keys;
-    limits;
-    nodes = 0;
-    value;
-    select;
-    stringChunk;
-    constructor(select, stringChunk, keys = () => 4096, limits) { this.select = select; this.stringChunk = stringChunk; this.keys = keys; this.limits = limits; }
-    selected(path) {
-        const keep = this.stack.length && this.stack.at(-1).value === undefined ? false : this.select(path, this.value);
-        if (keep && this.limits && ++this.nodes > this.limits.nodes)
-            throw new RangeError("JSON projection exceeds its assembled-node budget.");
-        return keep;
-    }
-    nextPath() {
-        const parent = this.stack.at(-1);
-        if (this.limits && (this.stack.length > this.limits.depth || parent && parent.index >= this.limits.arrayLength))
-            throw new RangeError("JSON projection exceeds its depth or array-position budget.");
-        return parent ? [...parent.path, Array.isArray(parent.value) || parent.index >= 0 ? parent.index++ : parent.key] : [];
-    }
-    put(path, value) {
-        const parent = this.stack.at(-1);
-        if (!parent)
-            this.value = value;
-        else if (parent.value !== undefined)
-            Object.defineProperty(parent.value, path.at(-1), { value, enumerable: true, writable: true, configurable: true });
-    }
-    write(chunk) {
-        const output = this.parse(chunk);
-        if (typeof output === "symbol")
-            return;
-        for (const token of output.values) {
-            switch (token.name) {
-                case "startKey": {
-                    const parent = this.stack.at(-1);
-                    this.key = true;
-                    parent.key = "";
-                    this.keyLimit = parent.value === undefined ? 0 : this.keys(parent.path, this.value);
-                    break;
-                }
-                case "endKey":
-                    this.key = false;
-                    break;
-                case "startObject":
-                case "startArray": {
-                    const path = this.nextPath(), keep = this.selected(path);
-                    const value = keep ? token.name === "startArray" ? [] : {} : undefined;
-                    if (keep)
-                        this.put(path, value);
-                    this.stack.push({ path, value, key: "", index: token.name === "startArray" ? 0 : -1 });
-                    break;
-                }
-                case "endObject":
-                case "endArray":
-                    this.stack.pop();
-                    break;
-                case "startString":
-                case "startNumber": {
-                    const path = this.nextPath(), keep = this.selected(path);
-                    this.scalar = { path, text: "", limit: keep === true ? Infinity : Number(keep) || 0, number: token.name === "startNumber" };
-                    break;
-                }
-                case "stringChunk":
-                case "numberChunk":
-                    if (this.key) {
-                        const parent = this.stack.at(-1);
-                        if (parent.value !== undefined && this.limits && parent.key.length + token.value.length > this.limits.keyLength)
-                            throw new RangeError("JSON projection exceeds its property-key budget.");
-                        if (parent.key.length < this.keyLimit)
-                            parent.key += token.value.slice(0, this.keyLimit - parent.key.length);
-                    }
-                    else if (this.scalar) {
-                        if (token.name === "stringChunk")
-                            this.stringChunk?.(this.scalar.path, token.value, this.value);
-                        if (this.scalar.text.length < this.scalar.limit)
-                            this.scalar.text += token.value.slice(0, this.scalar.limit - this.scalar.text.length);
-                    }
-                    break;
-                case "endString":
-                case "endNumber": {
-                    const scalar = this.scalar;
-                    if (scalar.limit)
-                        this.put(scalar.path, scalar.number ? Number(scalar.text) : scalar.text);
-                    this.scalar = undefined;
-                    break;
-                }
-                case "trueValue":
-                case "falseValue":
-                case "nullValue": {
-                    const path = this.nextPath();
-                    if (this.selected(path))
-                        this.put(path, token.value);
-                    break;
-                }
-            }
-        }
-    }
-    finish() { this.write(endInput); return this.value; }
-}
-/** Byte-framed JSONL. Publication framing is independent of malformed-record tolerance. */
-export class JournalFrames {
-    projection;
-    decoder = new TextDecoder("utf8", { fatal: true });
-    error;
-    nonblank = false;
-    start;
-    offset;
-    select;
-    record;
-    policy;
-    malformed;
-    stringChunk;
-    keys;
-    requireNewline;
-    limits;
-    constructor(select, record, policy = "strict", offset = 0, malformed, stringChunk, keys, requireNewline = policy === "live", limits) {
-        this.select = select;
-        this.record = record;
-        this.policy = policy;
-        this.malformed = malformed;
-        this.stringChunk = stringChunk;
-        this.keys = keys;
-        this.requireNewline = requireNewline;
-        this.limits = limits;
-        this.start = this.offset = offset;
-        this.projection = new JsonProjection(select, stringChunk, keys, limits);
-    }
-    part(bytes) {
-        if (!this.nonblank && bytes.some((byte) => ![9, 10, 13, 32].includes(byte)))
-            this.nonblank = true;
-        if (!this.error)
-            try {
-                this.projection.write(this.decoder.decode(bytes, { stream: true }));
-            }
-            catch (error) {
-                this.error = error;
-            }
-    }
-    commit(end) {
-        let record, malformed;
-        const start = this.start;
-        if (this.nonblank) {
-            let value;
-            if (!this.error)
-                try {
-                    this.projection.write(this.decoder.decode());
-                    value = this.projection.finish();
-                    if (!value || typeof value !== "object" || Array.isArray(value))
-                        throw new SyntaxError("JSONL records must be objects");
-                }
-                catch (error) {
-                    this.error = error;
-                }
-            if (this.error) {
-                if (this.policy !== "inspect")
-                    throw new SyntaxError(`Invalid JSONL record at byte ${this.start}: ${String(this.error)}`, { cause: this.error });
-                malformed = this.error;
-            }
-            else
-                record = { value: value, start, end };
-        }
-        this.start = end;
-        this.projection = new JsonProjection(this.select, this.stringChunk, this.keys, this.limits);
-        this.decoder = new TextDecoder("utf8", { fatal: true });
-        this.error = undefined;
-        this.nonblank = false;
-        if (malformed)
-            this.malformed?.(start, end, malformed);
-        else if (record)
-            this.record(record);
-    }
-    write(bytes) {
-        const offset = this.offset;
-        this.offset += bytes.length;
-        let from = 0;
-        for (let newline = bytes.indexOf(10); newline >= 0; newline = bytes.indexOf(10, from)) {
-            this.part(bytes.subarray(from, newline));
-            this.commit(offset + newline + 1);
-            from = newline + 1;
-        }
-        this.part(bytes.subarray(from));
-    }
-    finish() {
-        if (this.requireNewline) {
-            if (this.policy === "strict" && this.nonblank)
-                throw new SyntaxError(`Unpublished JSONL record at byte ${this.start}: newline required`);
-        }
-        else if (this.offset > this.start)
-            this.commit(this.offset);
-        return this.start;
-    }
-}
-export function scanJournal(file, select, record, options = {}) {
-    const fd = typeof file === "number" ? file : fs.openSync(file, "r");
-    try {
-        const end = Math.min(options.end ?? Infinity, fs.fstatSync(fd).size);
-        const frames = new JournalFrames(select, record, options.policy, options.start ?? 0, options.malformed, options.stringChunk, options.keys, options.requireNewline);
-        const buffer = Buffer.allocUnsafe(64 * 1024);
-        for (let offset = options.start ?? 0; offset < end;) {
-            const count = fs.readSync(fd, buffer, 0, Math.min(buffer.length, end - offset), offset);
-            if (!count)
-                throw new Error("Journal truncated while reading");
-            frames.write(buffer.subarray(0, count));
-            offset += count;
-        }
-        return frames.finish();
-    }
-    finally {
-        if (typeof file !== "number")
-            fs.closeSync(fd);
-    }
-}
-export function readJsonProjection(file, select) {
-    // ponytail: selected frozen schemas and acceptance values fit their consumer's
-    // heap, including arbitrary property names; discarded owner messages do not.
-    const fd = fs.openSync(file, "r"), decoder = new TextDecoder("utf8", { fatal: true }), projection = new JsonProjection(select, undefined, () => Infinity);
-    try {
-        const end = fs.fstatSync(fd).size, bytes = Buffer.allocUnsafe(64 * 1024);
-        for (let offset = 0; offset < end;) {
-            const count = fs.readSync(fd, bytes, 0, Math.min(bytes.length, end - offset), offset);
-            if (!count)
-                throw new Error("JSON file truncated while reading");
-            projection.write(decoder.decode(bytes.subarray(0, count), { stream: true }));
-            offset += count;
-        }
-        projection.write(decoder.decode());
-        const value = projection.finish();
-        if (!value || typeof value !== "object" || Array.isArray(value))
-            throw new SyntaxError("Owner records must be objects");
-        return value;
-    }
-    catch (error) {
-        throw new SyntaxError(`Invalid JSON file ${file}: ${String(error)}`, { cause: error });
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}
-/** Compact owner reads never hydrate transcript arrays or historical output strings. */
-export const ownerProjection = (path) => {
-    const resultField = path.length === 2 && path[0] === "result"
-        || path.length === 3 && path[0] === "results" && typeof path[1] === "number"
-        || path.length === 4 && path[0] === "children" && typeof path[1] === "number" && path[2] === "result";
-    if (resultField && path.at(-1) === "messages")
-        return false;
-    const preview = resultField && ["output", "finalOutput", "initialOutput", "rawOutput"].includes(String(path.at(-1)))
-        || path.length === 1 && path[0] === "summary"
-        || path.length === 3 && path[0] === "children" && typeof path[1] === "number" && path[2] === "summary";
-    return preview ? 8192 : true;
-};
-const entryFields = new Set(["type", "id", "parentId", "timestamp", "version", "cwd", "parentSession", "checkpoint", "provider", "model", "modelId", "thinkingLevel", "customType", "usage", "firstKeptEntryId", "fromId"]);
-const messageFields = new Set(["role", "provider", "model", "responseModel", "thinkingLevel", "usage", "stopReason", "errorMessage", "timestamp", "toolCallId", "toolName", "isError", "content", "command", "output", "exitCode", "cancelled"]);
-/** Metadata/previews, never unrelated custom data, image bytes or raw tool details. */
-export const nativeProjection = (path, root) => {
-    if (!path.length)
-        return true;
-    if (path[0] === "message") {
-        if (path.length === 1)
-            return true;
-        if (!messageFields.has(String(path[1])))
-            return false;
-        if (path[1] === "content") {
-            if (path.length <= 3)
-                return 2048;
-            if (path[3] === "arguments") {
-                if (path.length === 4)
-                    return true;
-                if (path.length === 5)
-                    return Object.keys(root?.message?.content?.[Number(path[2])]?.arguments ?? {}).length < 32 ? 2048 : false;
-                return path.length === 6 && path[5] === 0 ? 2048 : false;
-            }
-            return ["type", "id", "name", "text", "thinking", "mimeType", "arguments"].includes(String(path[3])) ? 2048 : false;
-        }
-        return path[1] === "usage" ? true : 4096;
-    }
-    if (path[0] === "summary" || path[0] === "content")
-        return 2048;
-    if (path[0] === "details")
-        return path.length === 1 || ["bodyText", "message", "from"].includes(String(path[1])) ? 2048 : false;
-    return entryFields.has(String(path[0])) ? 4096 : false;
-};
-export class NativeJournal {
-    records = [];
-    byId = new Map();
-    stamp;
-    end;
-    file;
-    constructor(file, policy = "inspect", requireNewline = policy === "live") {
-        this.file = file;
-        const fd = fs.openSync(file, "r");
-        try {
-            const stat = fs.fstatSync(fd, { bigint: true });
-            this.stamp = journalStamp(stat);
-            this.end = Number(stat.size);
-            let parent = null;
-            scanJournal(fd, nativeProjection, (record) => {
-                const entry = record.value;
-                if (entry.type !== "session") {
-                    // Read-only legacy v1 presentation uses stable offset IDs, without rewriting the source.
-                    entry.id ??= `legacy-${record.start}`;
-                    if (this.records[0]?.value.version === 1)
-                        entry.parentId = parent;
-                    parent = entry.id;
-                }
-                this.records.push(record);
-                this.byId.set(entry.id, record);
-            }, { policy, requireNewline, end: this.end });
-            if (journalStamp(fs.fstatSync(fd, { bigint: true })) !== this.stamp)
-                throw new Error("Journal changed while indexing; refresh history.");
-        }
-        finally {
-            fs.closeSync(fd);
-        }
-        if (this.records[0]?.value.type !== "session")
-            throw new Error("Not a readable native Pi session.");
-    }
-    branch(leaf, endedAt) {
-        if (leaf === null)
-            return [];
-        const eligible = endedAt === undefined ? this.records : this.records.filter((record) => record.value.type === "session" || Date.parse(record.value.timestamp) <= endedAt);
-        let current = leaf ? this.byId.get(leaf) : eligible.findLast((record) => record.value.type !== "session");
-        const path = [], seen = new Set(), allowed = new Set(eligible.map((record) => record.value.id));
-        while (current && current.value.type !== "session" && allowed.has(current.value.id)) {
-            if (seen.has(current.value.id))
-                throw new Error("Cyclic journal ancestry");
-            seen.add(current.value.id);
-            path.push(current);
-            current = this.byId.get(current.value.parentId);
-        }
-        return path.reverse();
-    }
-    body(record) {
-        const fd = fs.openSync(this.file, "r");
-        try {
-            if (journalStamp(fs.fstatSync(fd, { bigint: true })) !== this.stamp)
-                throw new Error("Journal changed; refresh before reading history.");
-            // ponytail: explicitly requested individual bodies must fit the consumer's heap;
-            // metadata and previews stay bounded. Use pages for large output.
-            const bytes = Buffer.alloc(record.end - record.start);
-            if (fs.readSync(fd, bytes, 0, bytes.length, record.start) !== bytes.length)
-                throw new Error("Journal truncated");
-            const body = JSON.parse(bytes.toString("utf8"));
-            if (body.type !== "session") {
-                body.id ??= record.value.id;
-                body.parentId ??= record.value.parentId;
-            }
-            return body;
-        }
-        finally {
-            fs.closeSync(fd);
-        }
-    }
-    configuration(endedAt, leaf) {
-        const result = {};
-        let model;
-        for (const { value } of this.branch(leaf, endedAt)) {
-            if (value.type === "thinking_level_change")
-                result.thinking = value.thinkingLevel;
-            if (value.type === "model_change" || value.type === "message" && value.message?.role === "assistant")
-                model = value;
-        }
-        if (model) {
-            result.model = model.type === "model_change" ? `${model.provider}/${model.modelId}` : `${model.message.provider}/${model.message.model}`;
-            result.modelRecordedAt = Date.parse(model.timestamp);
-        }
-        return result;
-    }
-}
-export function journalStamp(stat) { return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`; }
-/** Read a UTF-8 page or tail without reading its preceding output. */
-export function readOutputPage(file, options = {}) {
-    const fd = fs.openSync(file, "r");
-    try {
-        const size = fs.fstatSync(fd).size, length = options.length ?? 64 * 1024;
-        if (!Number.isSafeInteger(length) || length < 1 || length > 1024 * 1024 || options.offset !== undefined && (!Number.isSafeInteger(options.offset) || options.offset < 0))
-            throw new Error("Invalid output page");
-        const offset = Math.min(size, options.offset ?? Math.max(0, size - length));
-        const bytes = Buffer.alloc(Math.min(length, size - offset));
-        const count = fs.readSync(fd, bytes, 0, bytes.length, offset);
-        let start = 0, end = count;
-        while (start < end && (bytes[start] & 0xc0) === 0x80)
-            start++;
-        if (offset + end < size) {
-            let last = end - 1;
-            while (last >= start && (bytes[last] & 0xc0) === 0x80)
-                last--;
-            const lead = bytes[last], width = lead < 0x80 ? 1 : lead < 0xe0 ? 2 : lead < 0xf0 ? 3 : 4;
-            if (last + width > end)
-                end = last;
-        }
-        return { text: bytes.subarray(start, end).toString("utf8"), offset: offset + start, size, ...(offset + end < size ? { nextOffset: offset + end } : {}) };
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}
+// Stable public journal entry point; each module owns one storage responsibility.
+export { JsonProjection } from "./json-projection.js";
+export { JournalFrames, scanJournal, readJsonProjection, } from "./journal-frames.js";
+export { ownerProjection, nativeProjection } from "./journal-projections.js";
+export { NativeJournal, journalStamp, } from "./native-journal.js";
+export { readOutputPage } from "./output-page.js";

package/dist/shared/json-projection.js

@@ -0,0 +1,191 @@
+import { jsonParser } from "stream-json/core/parser.js";
+import { none } from "stream-chain/defs.js";
+import { isRecord } from "./unknown.js";
+function retained(keep) {
+    return keep === true || (typeof keep === "number" && keep !== 0 && !Number.isNaN(keep));
+}
+/** Validate all tokens, assembling selected values only. Skipped strings remain unpacked. */
+export class JsonProjection {
+    parse = jsonParser({ packValues: false });
+    stack = [];
+    scalar;
+    key = false;
+    keyLimit = 4096;
+    nodes = 0;
+    select;
+    stringChunk;
+    keys;
+    limits;
+    value;
+    constructor(select, stringChunk, keys = () => 4096, limits) {
+        this.select = select;
+        this.stringChunk = stringChunk;
+        this.keys = keys;
+        this.limits = limits;
+    }
+    root() {
+        return isRecord(this.value) ? this.value : undefined;
+    }
+    parent() {
+        const parent = this.stack.at(-1);
+        if (!parent) {
+            throw new SyntaxError("JSON token requires a containing object");
+        }
+        return parent;
+    }
+    selected(path) {
+        const parent = this.stack.at(-1);
+        const keep = parent && parent.value === undefined ? false : this.select(path, this.root());
+        if (retained(keep) && this.limits && ++this.nodes > this.limits.nodes) {
+            throw new RangeError("JSON projection exceeds its assembled-node budget.");
+        }
+        return keep;
+    }
+    nextPath() {
+        const parent = this.stack.at(-1);
+        if (this.limits &&
+            (this.stack.length > this.limits.depth || (parent && parent.index >= this.limits.arrayLength))) {
+            throw new RangeError("JSON projection exceeds its depth or array-position budget.");
+        }
+        if (!parent) {
+            return [];
+        }
+        return [...parent.path, parent.index >= 0 ? parent.index++ : parent.key];
+    }
+    put(path, value) {
+        const parent = this.stack.at(-1);
+        if (!parent) {
+            this.value = value;
+            return;
+        }
+        const key = path.at(-1);
+        if (parent.value !== undefined && key !== undefined) {
+            Object.defineProperty(parent.value, key, {
+                value,
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+        }
+    }
+    startContainer(array) {
+        const path = this.nextPath();
+        const keep = this.selected(path);
+        let value;
+        if (retained(keep)) {
+            value = array ? [] : {};
+            this.put(path, value);
+        }
+        this.stack.push({ path, value, key: "", index: array ? 0 : -1 });
+    }
+    startScalar(number) {
+        const path = this.nextPath();
+        const keep = this.selected(path);
+        const selectedLimit = keep === true ? Infinity : Number(keep);
+        const limit = Number.isNaN(selectedLimit) ? 0 : selectedLimit;
+        this.scalar = { path, text: "", limit, number };
+    }
+    appendKey(text) {
+        const parent = this.parent();
+        if (parent.value !== undefined &&
+            this.limits &&
+            parent.key.length + text.length > this.limits.keyLength) {
+            throw new RangeError("JSON projection exceeds its property-key budget.");
+        }
+        if (parent.key.length < this.keyLimit) {
+            parent.key += text.slice(0, this.keyLimit - parent.key.length);
+        }
+    }
+    appendScalar(text, string) {
+        const scalar = this.scalar;
+        if (!scalar) {
+            return;
+        }
+        if (string) {
+            this.stringChunk?.(scalar.path, text, this.root());
+        }
+        if (scalar.text.length < scalar.limit) {
+            scalar.text += text.slice(0, scalar.limit - scalar.text.length);
+        }
+    }
+    finishScalar() {
+        const scalar = this.scalar;
+        if (scalar && scalar.limit !== 0) {
+            this.put(scalar.path, scalar.number ? Number(scalar.text) : scalar.text);
+        }
+        this.scalar = undefined;
+    }
+    token(token) {
+        switch (token.name) {
+            case "startKey": {
+                const parent = this.parent();
+                this.key = true;
+                parent.key = "";
+                this.keyLimit = parent.value === undefined ? 0 : this.keys(parent.path, this.root());
+                break;
+            }
+            case "endKey":
+                this.key = false;
+                break;
+            case "startObject":
+                this.startContainer(false);
+                break;
+            case "startArray":
+                this.startContainer(true);
+                break;
+            case "endObject":
+            case "endArray":
+                this.stack.pop();
+                break;
+            case "startString":
+                this.startScalar(false);
+                break;
+            case "startNumber":
+                this.startScalar(true);
+                break;
+            case "stringChunk":
+            case "numberChunk":
+                if (this.key) {
+                    this.appendKey(token.value);
+                }
+                else {
+                    this.appendScalar(token.value, token.name === "stringChunk");
+                }
+                break;
+            case "endString":
+            case "endNumber":
+                this.finishScalar();
+                break;
+            case "trueValue":
+            case "falseValue":
+            case "nullValue": {
+                const path = this.nextPath();
+                const keep = this.selected(path);
+                if (retained(keep)) {
+                    this.put(path, token.value);
+                }
+                break;
+            }
+            case "keyValue":
+            case "stringValue":
+            case "numberValue":
+            case "whitespace":
+                break; // Packing is disabled; whitespace carries no projected value.
+        }
+    }
+    write(chunk) {
+        if (typeof chunk === "symbol" && chunk !== none) {
+            throw new TypeError("Unknown JSON tokenizer sentinel");
+        }
+        const output = this.parse(typeof chunk === "symbol" ? none : chunk);
+        if (typeof output !== "symbol") {
+            for (const token of output.values) {
+                this.token(token);
+            }
+        }
+    }
+    finish() {
+        this.write(none);
+        return this.value;
+    }
+}

package/dist/shared/lazy-tools.js

@@ -4,29 +4,40 @@ const declarations = new WeakMap();
 export function activateTools(pi, names) {
     const available = pi.getAllTools();
     const active = pi.getActiveTools();
-    const added = names.filter((name) => !active.includes(name) && available.some((tool) => tool.name === name && !("namespace" in tool && tool.namespace)));
-    if (added.length)
+    const added = names.filter((name) => !active.includes(name) &&
+        available.some((tool) => tool.name === name &&
+            !("namespace" in tool && typeof tool.namespace === "string" && tool.namespace !== "")));
+    if (added.length > 0) {
         pi.setActiveTools([...active, ...new Set(added)]);
+    }
 }
 /** Official 1.0 SDK creation omits initial resume restoration; tree/reload are native. */
 export function restoreLazyTools(pi, ctx, loader, names) {
     const available = pi.getAllTools();
     // A tool-only allowlist must remain usable without its discovery entry.
-    if (!available.some((tool) => tool.name === loader && !("namespace" in tool && tool.namespace))) {
+    if (!available.some((tool) => tool.name === loader &&
+        !("namespace" in tool && typeof tool.namespace === "string" && tool.namespace !== ""))) {
         activateTools(pi, names);
         return;
     }
     const manager = ctx.sessionManager, leaf = manager.getLeafId(), count = manager.getEntryCount?.();
     let cached = declarations.get(manager);
     if (count === undefined || !cached || cached.leaf !== leaf || cached.count !== count) {
-        cached = { leaf, count, current: getCurrentSystemMessage(manager.buildSessionProjection().messages) };
+        cached = {
+            leaf,
+            count,
+            current: getCurrentSystemMessage(manager.buildSessionProjection().messages),
+        };
         declarations.set(manager, cached);
     }
     const declared = cached.current;
-    if (!declared)
+    if (!declared) {
         return;
-    const selected = declared?.toolsAdded ?? [];
-    const restored = names.filter((name) => selected.some((tool) => tool.name === name && !("namespace" in tool && tool.namespace))
-        && available.some((tool) => tool.name === name && !("namespace" in tool && tool.namespace)));
+    }
+    const selected = declared.toolsAdded ?? [];
+    const restored = names.filter((name) => selected.some((tool) => tool.name === name &&
+        !("namespace" in tool && typeof tool.namespace === "string" && tool.namespace !== "")) &&
+        available.some((tool) => tool.name === name &&
+            !("namespace" in tool && typeof tool.namespace === "string" && tool.namespace !== "")));
     activateTools(pi, restored);
 }