openmausbot 0.1.87 → 0.1.89

package/dist-server/server/message-db.js

@@ -15,9 +15,13 @@ import { join } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { DATA_DIR } from "./config.js";
 import { peerProvenanceAuthor } from "./peer-provenance.js";
+import { MessageSearchWorker } from "./message-search-worker.js";
+import { searchMessagesInDatabase } from "./message-search-query.js";
 const DB_FILE = () => join(DATA_DIR, "messages.db");
 let handle = null;
 let handlePath = null;
+let searchWorker = null;
+let closingSearch = Promise.resolve();
 function open() {
     mkdirSync(DATA_DIR, { recursive: true, mode: 0o700 });
     const file = DB_FILE();
@@ -444,49 +448,16 @@ export function threadsReferencing(fragment) {
     return rows.map((row) => row.thread_id);
 }
 /** Case-insensitive substring search over text messages, newest first.
- * A LIKE scan, deliberately: local transcripts are megabytes at most, a
- * scan is milliseconds, and it needs no FTS extension to exist. */
+ * Keep literal substring semantics; HTTP callers run the scan off-thread. */
 export function searchMessages(query, limit = 40, threadId) {
-    const needle = query.trim().toLowerCase();
-    if (!needle)
-        return [];
-    // escape LIKE wildcards so a literal % or _ in the query stays literal
-    const pattern = `%${needle.replace(/([\\%_])/g, "\\$1")}%`;
-    // text messages by their text; activity chips by the tool name — "which
-    // bot ran that migration" is a tool-name question. The chip's name lives
-    // in the row's json; a JSON1 extract keeps this one query.
-    const scope = threadId ? "thread_id = ? AND " : "";
-    const statement = db().prepare("SELECT thread_id, id, at, role, kind, text, json_extract(json, '$.tool.name') AS tool_name, json_extract(json, '$.from.name') AS from_name FROM messages " +
-        `WHERE ${scope}((kind = 'text' AND text IS NOT NULL AND lower(text) LIKE ? ESCAPE '\\') ` +
-        "   OR (kind = 'activity' AND tool_name IS NOT NULL AND lower(tool_name) LIKE ? ESCAPE '\\')) " +
-        "ORDER BY at DESC LIMIT ?");
-    const rows = (threadId
-        ? statement.all(threadId, pattern, pattern, limit)
-        : statement.all(pattern, pattern, limit));
-    return rows.map((row) => {
-        const haystack = row.kind === "activity" ? (row.tool_name ?? "") : (row.text ?? "");
-        const hitAt = Math.max(0, haystack.toLowerCase().indexOf(needle));
-        const start = Math.max(0, hitAt - 60);
-        const end = Math.min(haystack.length, hitAt + needle.length + 90);
-        const head = start > 0 ? "…" : "";
-        const body = haystack.slice(start, end).replace(/\s+/g, " ").trim();
-        const snippet = head + body + (end < haystack.length ? "…" : "");
-        // whitespace folding can shift the offset; find the match again inside
-        const folded = needle.replace(/\s+/g, " ");
-        const matchStart = snippet.toLowerCase().indexOf(folded);
-        return {
-            threadId: row.thread_id,
-            messageId: row.id,
-            at: row.at,
-            role: row.role,
-            kind: row.kind,
-            snippet,
-            matchStart: matchStart < 0 ? head.length : matchStart,
-            // A defensive fallback must not mark arbitrary snippet text as the hit.
-            matchLength: matchStart < 0 ? 0 : folded.length,
-            ...(row.from_name ? { from: row.from_name } : {}),
-        };
-    });
+    return searchMessagesInDatabase(db(), query, limit, threadId);
+}
+export function searchMessagesAsync(query, limit = 40, threadId) {
+    if (!query.trim())
+        return Promise.resolve([]);
+    db(); // The owner initializes/migrates the schema before any read-only scan.
+    searchWorker ??= new MessageSearchWorker(DB_FILE());
+    return searchWorker.search(query, limit, threadId);
 }
 /** Who wrote a user-role line that reads as the user's. The structural
  * field wins; rows stored before it existed still open with the note. */
@@ -675,8 +646,17 @@ export function recallMemory(query, botId, limit = 12) {
         .all(match, botId, limit);
     return rows.map((row) => ({ file: row.path, at: row.mtime_ms, snippet: row.snippet.replace(/\s+/g, " ").trim() }));
 }
+/** Await before maintenance replaces the database or shutdown releases its lease. */
+export async function closeMessageSearch() {
+    const worker = searchWorker;
+    searchWorker = null;
+    if (worker)
+        closingSearch = Promise.all([closingSearch, worker.close()]).then(() => { });
+    await closingSearch;
+}
 /** Test/shutdown hook — closes the handle so a wiped DATA_DIR starts clean. */
 export function closeMessageDb() {
+    void closeMessageSearch();
     try {
         handle?.close();
     }

package/dist-server/server/message-file.js

@@ -313,7 +313,7 @@ function containedBy(root, candidate) {
     const suffix = relative(root, candidate);
     return suffix === "" || (suffix !== ".." && !suffix.startsWith(`..${sep}`) && !isAbsolute(suffix));
 }
-function mimeFor(path) {
+export function mimeFor(path) {
     switch (extname(path).toLowerCase()) {
         case ".md": return "text/markdown; charset=utf-8";
         case ".txt": return "text/plain; charset=utf-8";
@@ -331,6 +331,14 @@ function mimeFor(path) {
         case ".m4v": return "video/x-m4v";
         case ".webm": return "video/webm";
         case ".mov": return "video/quicktime";
+        case ".mp3": return "audio/mpeg";
+        case ".m4a": return "audio/mp4";
+        case ".aac": return "audio/aac";
+        case ".wav": return "audio/wav";
+        case ".ogg":
+        case ".oga": return "audio/ogg";
+        case ".opus": return "audio/opus";
+        case ".flac": return "audio/flac";
         case ".doc": return "application/msword";
         case ".docx": return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
         case ".xls": return "application/vnd.ms-excel";

package/dist-server/server/message-search-query.js

@@ -0,0 +1,43 @@
+/** Shared query and snippet logic; the worker never calls the write-side open(). */
+export function searchMessagesInDatabase(database, query, limit = 40, threadId) {
+    const needle = query.trim().toLowerCase();
+    if (!needle)
+        return [];
+    // escape LIKE wildcards so a literal % or _ in the query stays literal
+    const pattern = `%${needle.replace(/([\\%_])/g, "\\$1")}%`;
+    // text messages by their text; activity chips by the tool name — "which
+    // bot ran that migration" is a tool-name question. The chip's name lives
+    // in the row's json; a JSON1 extract keeps this one query.
+    const scope = threadId ? "thread_id = ? AND " : "";
+    const statement = database.prepare("SELECT thread_id, id, at, role, kind, text, json_extract(json, '$.tool.name') AS tool_name, json_extract(json, '$.from.name') AS from_name FROM messages " +
+        `WHERE ${scope}((kind = 'text' AND text IS NOT NULL AND lower(text) LIKE ? ESCAPE '\\') ` +
+        "   OR (kind = 'activity' AND tool_name IS NOT NULL AND lower(tool_name) LIKE ? ESCAPE '\\')) " +
+        "ORDER BY at DESC LIMIT ?");
+    const rows = (threadId
+        ? statement.all(threadId, pattern, pattern, limit)
+        : statement.all(pattern, pattern, limit));
+    return rows.map((row) => {
+        const haystack = row.kind === "activity" ? (row.tool_name ?? "") : (row.text ?? "");
+        const hitAt = Math.max(0, haystack.toLowerCase().indexOf(needle));
+        const start = Math.max(0, hitAt - 60);
+        const end = Math.min(haystack.length, hitAt + needle.length + 90);
+        const head = start > 0 ? "…" : "";
+        const body = haystack.slice(start, end).replace(/\s+/g, " ").trim();
+        const snippet = head + body + (end < haystack.length ? "…" : "");
+        // whitespace folding can shift the offset; find the match again inside
+        const folded = needle.replace(/\s+/g, " ");
+        const matchStart = snippet.toLowerCase().indexOf(folded);
+        return {
+            threadId: row.thread_id,
+            messageId: row.id,
+            at: row.at,
+            role: row.role,
+            kind: row.kind,
+            snippet,
+            matchStart: matchStart < 0 ? head.length : matchStart,
+            // A defensive fallback must not mark arbitrary snippet text as the hit.
+            matchLength: matchStart < 0 ? 0 : folded.length,
+            ...(row.from_name ? { from: row.from_name } : {}),
+        };
+    });
+}

package/dist-server/server/message-search-worker.js

@@ -0,0 +1,80 @@
+import { existsSync } from "node:fs";
+import { Worker } from "node:worker_threads";
+export class SearchUnavailable extends Error {
+    status = 503;
+}
+/** One read-only worker, not a worker per keystroke. Bound outstanding scans
+ * so a burst of searches cannot build an unbounded queue behind the database. */
+export class MessageSearchWorker {
+    worker;
+    stopping = Promise.resolve();
+    sequence = 0;
+    pending = new Map();
+    file;
+    timeoutMs;
+    constructor(file, timeoutMs = 30_000) {
+        this.file = file;
+        this.timeoutMs = timeoutMs;
+    }
+    search(query, limit, threadId) {
+        if (this.pending.size >= 8)
+            return Promise.reject(new SearchUnavailable("Search is busy. Try again shortly."));
+        if (!this.worker) {
+            const source = new URL("./message-search.worker.ts", import.meta.url);
+            const worker = new Worker(existsSync(source) ? source : new URL("./message-search.worker.js", import.meta.url), {
+                workerData: { file: this.file },
+                // Do not inherit test loaders or inspector ports into the worker.
+                execArgv: [],
+            });
+            this.worker = worker;
+            worker.on("message", (reply) => {
+                if (this.worker !== worker)
+                    return;
+                const request = this.pending.get(reply.id);
+                if (!request)
+                    return;
+                clearTimeout(request.timer);
+                this.pending.delete(reply.id);
+                if (reply.failed)
+                    request.reject(new SearchUnavailable("Search could not finish. Try again shortly."));
+                else
+                    request.resolve(reply.hits ?? []);
+                if (!this.pending.size)
+                    worker.unref();
+            });
+            worker.on("error", () => {
+                if (this.worker === worker)
+                    void this.close();
+            });
+            worker.on("exit", () => {
+                if (this.worker === worker)
+                    void this.close();
+            });
+        }
+        const worker = this.worker;
+        worker.ref();
+        const id = ++this.sequence;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { void this.close(); }, this.timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            try {
+                worker.postMessage({ id, query, limit, threadId });
+            }
+            catch {
+                void this.close();
+            }
+        });
+    }
+    async close() {
+        const worker = this.worker;
+        this.worker = undefined;
+        for (const request of this.pending.values()) {
+            clearTimeout(request.timer);
+            request.reject(new SearchUnavailable("Search was interrupted. Try again shortly."));
+        }
+        this.pending.clear();
+        if (worker)
+            this.stopping = Promise.all([this.stopping, worker.terminate()]).then(() => { });
+        await this.stopping;
+    }
+}

package/dist-server/server/message-search.worker.js

@@ -0,0 +1,21 @@
+import { DatabaseSync } from "node:sqlite";
+import { parentPort, workerData } from "node:worker_threads";
+import { searchMessagesInDatabase } from "./message-search-query.js";
+// Each request reads the latest committed WAL state. Closing after the scan
+// avoids keeping an old database inode open across a workspace restore.
+parentPort.on("message", (request) => {
+    let db;
+    try {
+        db = new DatabaseSync(workerData.file, { readOnly: true });
+        const hits = searchMessagesInDatabase(db, request.query, request.limit, request.threadId);
+        parentPort.postMessage({ id: request.id, hits });
+    }
+    catch {
+        // Database errors can contain private paths or query text. The server
+        // returns a generic retryable error, never a synchronous fallback scan.
+        parentPort.postMessage({ id: request.id, failed: true });
+    }
+    finally {
+        db?.close();
+    }
+});

package/dist-server/server/model-requests.js

@@ -0,0 +1,248 @@
+import { harnessCapabilityLines } from "./harness-capabilities.js";
+import { newId } from "./contracts.js";
+import { redactSecretsInText } from "./redact.js";
+const MAX_REASON = 500;
+const STALE = "This bot's default model changed after this card was prepared. Ask the bot to review it and propose again.";
+const NO_SUCH_BOT = "That bot no longer exists";
+export class ModelRequestError extends Error {
+    status;
+    constructor(message, status = 400) {
+        super(message);
+        this.name = "ModelRequestError";
+        this.status = status;
+    }
+}
+const sameSelection = (a, b) => a.instanceId === b.instanceId && a.model === b.model && a.effort === b.effort && a.variant === b.variant;
+function reasonText(value) {
+    if (typeof value !== "string")
+        throw new ModelRequestError("reason is required");
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new ModelRequestError("reason is required");
+    if (trimmed.length > MAX_REASON)
+        throw new ModelRequestError("reason must be 500 characters or fewer");
+    return redactSecretsInText(trimmed);
+}
+/** Structural check only — the injected validateModel hook owns catalog and
+ * approval-compatibility checks with the live registry, at propose and again
+ * at confirm. */
+function parseSelection(input) {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+        throw new ModelRequestError("model_selection must be an object with instanceId and model");
+    }
+    const value = input;
+    if (typeof value.instanceId !== "string" || !value.instanceId.trim()) {
+        throw new ModelRequestError("model_selection.instanceId is required");
+    }
+    if (typeof value.model !== "string" || !value.model.trim()) {
+        throw new ModelRequestError("model_selection.model is required");
+    }
+    const selection = { instanceId: value.instanceId.trim(), model: value.model.trim() };
+    if (value.effort !== undefined) {
+        if (typeof value.effort !== "string" || !value.effort.trim())
+            throw new ModelRequestError("model_selection.effort must be a level name");
+        selection.effort = value.effort;
+    }
+    if (value.variant !== undefined) {
+        if (typeof value.variant !== "string" || !value.variant.trim())
+            throw new ModelRequestError("model_selection.variant must be a variant id");
+        selection.variant = value.variant;
+    }
+    return selection;
+}
+export function modelCardCopy(args) {
+    const title = args.crossBot
+        ? "Change @" + args.targetName + "'s default engine/model?"
+        : "Change " + args.targetName + "'s default engine/model?";
+    const lines = args.crossBot
+        ? ["Whose default model: @" + args.targetName, "Why: " + args.reason]
+        : ["Why: " + args.reason];
+    lines.push("Default engine/model: " + JSON.stringify(args.before) + " → " + JSON.stringify(args.selection));
+    lines.push(...args.capabilityLines);
+    // The same consent line the team-setup card shows for a model change:
+    // the default moves, saved thread selections do not.
+    lines.push("Default models apply to groups and new threads. Every existing thread keeps its current model and permissions.");
+    lines.push("Nothing runs.");
+    return { title, summary: title + " · default engine/model", detail: lines.join("\n") };
+}
+export class ModelRequestService {
+    store;
+    now;
+    canPersist;
+    autoApply;
+    validateTarget;
+    validateModel;
+    driverCapabilities;
+    constructor(options) {
+        this.store = options.store;
+        this.now = options.now ?? Date.now;
+        this.canPersist = options.canPersist;
+        this.autoApply = options.autoApply;
+        this.validateTarget = options.validateTarget;
+        this.validateModel = options.validateModel;
+        this.driverCapabilities = options.driverCapabilities;
+    }
+    propose(args) {
+        return this.prepare(args);
+    }
+    submit(args) {
+        const proposal = this.prepare(args, true);
+        return { ...proposal, state: proposal.result ? "applied" : "pending" };
+    }
+    prepare(args, submitted = false) {
+        const reason = reasonText(args.reason);
+        const selection = parseSelection(args.selection);
+        const targetBotId = args.targetBotId?.trim() || args.botId;
+        const target = this.store.bot(targetBotId);
+        if (!target)
+            throw new ModelRequestError(NO_SUCH_BOT, 404);
+        const crossBot = targetBotId !== args.botId;
+        if (crossBot && this.validateTarget) {
+            const refusal = this.validateTarget(args.botId, targetBotId);
+            if (refusal)
+                throw new ModelRequestError(refusal, 403);
+        }
+        if (sameSelection(selection, target.modelSelection))
+            throw new ModelRequestError("Nothing would change");
+        if (this.validateModel) {
+            const refusal = this.validateModel(selection, target);
+            if (refusal)
+                throw new ModelRequestError(refusal, 400);
+        }
+        const requestId = newId();
+        const targetName = redactSecretsInText(target.name);
+        const before = structuredClone(target.modelSelection);
+        const capabilityLines = this.driverCapabilities
+            ? harnessCapabilityLines(this.driverCapabilities(before.instanceId), this.driverCapabilities(selection.instanceId))
+            : [];
+        const payload = {
+            version: 1,
+            requestId,
+            botId: args.botId,
+            threadId: args.threadId,
+            targetBotId,
+            targetName,
+            createdAt: this.now(),
+            reason,
+            selection,
+            before,
+        };
+        const copy = modelCardCopy({ targetName, crossBot, before, selection, reason, capabilityLines });
+        const persistence = this.canPersist?.(args.botId, args.threadId);
+        if (persistence && !persistence.ok)
+            throw new ModelRequestError(persistence.error, persistence.status);
+        const automatic = submitted && this.autoApply?.(args.botId, args.threadId) === true;
+        const messageInput = {
+            role: "bot",
+            kind: "options",
+            card: {
+                title: copy.title,
+                subtitle: copy.detail,
+                options: automatic ? [] : ["Confirm", "Cancel"],
+                ...(automatic ? { dismissed: true } : {}),
+                requestId,
+                tool: "update_model",
+                modelRequest: payload,
+            },
+        };
+        if (args.from)
+            messageInput.from = args.from;
+        const message = this.store.appendMessage(args.threadId, messageInput);
+        const proposal = { requestId, messageId: message.id, title: copy.title, summary: copy.summary, detail: copy.detail };
+        if (!automatic)
+            return proposal;
+        const result = this.resolve({ botId: args.botId, threadId: args.threadId, requestId, behavior: "allow" });
+        if (result.state === "applied")
+            return { ...proposal, result };
+        throw new ModelRequestError(result.state === "invalid" ? result.error : "The model change could not be applied", result.state === "invalid" ? result.status : 409);
+    }
+    /** Claims a model card even after it was settled, so a duplicate click
+     * never re-applies an already-applied change. */
+    resolve(args) {
+        const message = this.store
+            .messagesFor(args.threadId)
+            .find((candidate) => candidate.card?.requestId === args.requestId && candidate.card.modelRequest);
+        const card = message?.card;
+        const payload = card?.modelRequest;
+        if (!message || !card || !payload)
+            return { claimed: false, state: "not_found" };
+        if (payload.requestId !== card.requestId) {
+            return { claimed: true, state: "invalid", error: "This model request does not match its card", status: 409 };
+        }
+        if (args.behavior !== "allow" && args.behavior !== "deny") {
+            return { claimed: true, state: "invalid", error: "Model confirmations must be confirmed or cancelled", status: 400 };
+        }
+        if (payload.botId !== args.botId || payload.threadId !== args.threadId) {
+            return { claimed: true, state: "invalid", error: "This model request belongs to another conversation", status: 403 };
+        }
+        if (card.answered)
+            return { claimed: true, state: "already_settled", behavior: card.answered };
+        // Cross-bot cards re-check authority on every allow, before any settle
+        // path can run: a proposer who lost Chief rights must not confirm, even
+        // when the requested selection is already live. Card level, not inside
+        // the try, so the crash-recovery catch cannot recast a refusal as an
+        // applied change.
+        if (args.behavior === "allow" && payload.targetBotId !== payload.botId && this.validateTarget) {
+            const refusal = this.validateTarget(payload.botId, payload.targetBotId);
+            if (refusal)
+                return { claimed: true, state: "invalid", error: refusal, status: 404 };
+        }
+        try {
+            const target = this.store.bot(payload.targetBotId);
+            if (!target)
+                throw new ModelRequestError(NO_SUCH_BOT, 404);
+            if (args.behavior === "deny") {
+                this.store.patchMessage(args.threadId, message.id, { card: { ...card, answered: "deny", held: undefined } });
+                return { claimed: true, state: "denied" };
+            }
+            // Idempotent close: if the exact requested selection is already the
+            // default (a crash after apply, or the same change arriving twice),
+            // settle the card without mutating anything again.
+            if (sameSelection(payload.selection, target.modelSelection)) {
+                const settled = this.store.patchMessage(args.threadId, message.id, {
+                    card: { ...card, answered: "allow", held: undefined, modelRequest: { ...payload, appliedAt: payload.appliedAt ?? this.now() } },
+                });
+                if (!settled)
+                    throw new ModelRequestError("This model confirmation card is no longer available", 409);
+                return { claimed: true, state: "already_settled", behavior: "allow" };
+            }
+            if (!sameSelection(payload.before, target.modelSelection)) {
+                throw new ModelRequestError(STALE, 409);
+            }
+            if (this.validateModel) {
+                const refusal = this.validateModel(payload.selection, target);
+                if (refusal)
+                    throw new ModelRequestError(refusal, 409);
+            }
+            if (!this.store.applyModelDefault(target.id, payload.selection))
+                throw new ModelRequestError(NO_SUCH_BOT, 404);
+            const appliedAt = this.now();
+            const settled = this.store.patchMessage(args.threadId, message.id, {
+                card: { ...card, answered: "allow", held: undefined, modelRequest: { ...payload, appliedAt } },
+            });
+            if (!settled)
+                throw new ModelRequestError("This model confirmation card is no longer available", 409);
+            return { claimed: true, state: "applied", targetBotId: target.id };
+        }
+        catch (error) {
+            const status = error instanceof ModelRequestError ? error.status : 400;
+            const detail = error instanceof Error ? error.message : String(error);
+            const applied = sameSelection(payload.selection, this.store.bot(payload.targetBotId)?.modelSelection ?? payload.before);
+            const notice = card.dismissed && card.options.length === 0
+                ? "Default model saved. Recording the operation receipt could not finish; the change will not be applied again."
+                : "Default model saved. Confirm again to finish recording this decision; the change will not be applied again.";
+            try {
+                this.store.patchMessage(args.threadId, message.id, {
+                    card: { ...card, held: applied ? notice : redactSecretsInText(detail).slice(0, 500) },
+                });
+            }
+            catch { /* The idempotent close above still permits a safe retry. */ }
+            if (applied)
+                return {
+                    claimed: true, state: "applied", targetBotId: payload.targetBotId,
+                    settlementPending: true, message: notice,
+                };
+            return { claimed: true, state: "invalid", error: detail, status };
+        }
+    }
+}

package/dist-server/server/options-card.js

@@ -0,0 +1,21 @@
+import { parseOptionsCardInput, WATCHER_OPTIONS_CARD_BOT_ID, } from "../shared/options-card.js";
+/**
+ * Persist one passive, legacy options card. It deliberately has no requestId
+ * or tool field: clicking it replies to the conversation, but grants no tool
+ * approval and performs no external action.
+ */
+export function createOptionsCard(args) {
+    if (args.bot.id !== WATCHER_OPTIONS_CARD_BOT_ID) {
+        return { ok: false, status: 403, error: "create_options_card is not enabled for this bot." };
+    }
+    const parsed = parseOptionsCardInput(args.input);
+    if (!parsed.ok)
+        return { ok: false, status: 400, error: parsed.error };
+    const message = args.store.appendMessage(args.threadId, {
+        role: "bot",
+        kind: "options",
+        from: { botId: args.bot.id, name: args.bot.name, color: args.bot.color },
+        card: parsed.value,
+    });
+    return { ok: true, messageId: message.id };
+}

package/dist-server/server/org-library.js

@@ -258,6 +258,14 @@ export class OrgLibrary {
     get organization() {
         return this.library ? { ...this.library.catalog.organization } : null;
     }
+    /** Every install's status, from this library's own state (what it last
+     * rebuilt, added or withdrew, saved or not), for New bot's presets
+     * (presets.ts presetOffered). Every install is listed, whichever
+     * organization it came from and with no organization signed in, as the
+     * statuses have always been read. Reads no file and no skill state. */
+    installStatuses() {
+        return new Map(Object.entries(this.state.installs).map(([installId, install]) => [installId, install.status]));
+    }
     // ── the relay (Electron main → runtime) ───────────────────────────────
     /** `openmausbot:managed-library`: swap the catalog and return at once; the
      * reconcile and the report run afterwards (the relay times out at 15 s).
@@ -340,6 +348,10 @@ export class OrgLibrary {
                 value.sections.push(sectionKey(bot.section));
                 value.meta ??= stamp;
             }
+            // A bot made from an install's preset (presets.ts) is the person's own,
+            // like a copy: its stamped skills never count as the install's records.
+            if (stamp?.presetKey)
+                continue;
             for (const skill of this.deps.skills.stamps(bot.id))
                 entry(skill.stamp.installId).skills += 1;
         }
@@ -598,7 +610,9 @@ export class OrgLibrary {
             }
         }
         // A bot made from one of the install's presets (presets.ts) got the
-        // preset's skills under the release's organization source, unstamped.
+        // preset's skills under the release's organization source. They carry
+        // the install's stamp too (`via: "preset"`, reached above); the source
+        // also reaches one made before presets stamped their skills.
         for (const bot of this.deps.store.bots) {
             const made = bot.installedPackage;
             if (made?.source !== "org" || made.installId !== installId || !made.presetKey || !made.ref)

package/dist-server/server/peer-delivery.js

@@ -0,0 +1,60 @@
+// Delivery receipts for bot-to-bot messages: what actually happened to a
+// send the moment the coordination/delegation tool returned, one receipt
+// per recipient. The outcomes are the bot-facing half of the same honesty
+// discipline SteerOutcome applies to steering — a tri-state that can always
+// be answered truthfully, where an indeterminate send reads "queued", never
+// "delivered":
+//
+//   queued   — accepted into a durable lane; the recipient's turn has not
+//              started, so nothing has been delivered yet
+//   injected — the recipient's turn started with this message (it may still
+//              be running, or it may have run and failed)
+//   failed   — not delivered; the detail says why
+//
+// The rule that overrides every other consideration: never report delivery
+// that did not happen. A failed live hand-off may stay buffered for a later
+// drain, but its receipt stays failed.
+import { peerName } from "./peer-roster.js";
+// Detail lines are built from harness error text that can carry
+// peer- or provider-authored content, so they get the same flatten-and-clip
+// discipline as a roster entry (peer-roster.ts) rather than trust the
+// sender of the failure. Written as a scan for the same reason the linter
+// refuses a control-character literal.
+const DETAIL_MAX = 200;
+const oneLine = (value) => {
+    let flattened = "";
+    for (let i = 0; i < value.length; i += 1) {
+        const code = value.charCodeAt(i);
+        const breaksOut = code < 0x20 || (code >= 0x7f && code <= 0x9f) || code === 0x2028 || code === 0x2029;
+        flattened += breaksOut ? " " : value[i];
+    }
+    return flattened.replace(/\s+/g, " ").trim();
+};
+const clip = (value) => {
+    const flat = oneLine(value);
+    return flat.length > DETAIL_MAX ? `${flat.slice(0, DETAIL_MAX - 1)}…` : flat;
+};
+/** Build a receipt with the detail flattened onto one clipped line. */
+export function peerDeliveryReceipt(receipt) {
+    return {
+        botId: receipt.botId,
+        ...(receipt.botName ? { botName: receipt.botName } : {}),
+        outcome: receipt.outcome,
+        detail: clip(receipt.detail) || "no detail recorded",
+        ...(receipt.taskId ? { taskId: receipt.taskId } : {}),
+        ...(receipt.requestId ? { requestId: receipt.requestId } : {}),
+    };
+}
+const named = (receipt) => peerName(receipt.botName ?? "") || peerName(receipt.botId) || "teammate";
+/** Render receipts as the tool-result prose a sender reads. One receipt
+ * becomes a single "Delivery to …" line; several become a fenced list with
+ * one line per recipient, in the order the caller addressed them. An empty
+ * list renders nothing, so callers can append unconditionally. */
+export function renderPeerDeliveryReceipts(receipts) {
+    if (!receipts.length)
+        return "";
+    const line = (receipt) => `${named(receipt)}: ${receipt.outcome} — ${receipt.detail}`;
+    if (receipts.length === 1)
+        return `Delivery to ${line(receipts[0])}`;
+    return ["Delivery receipts:", ...receipts.map(receipt => `- ${line(receipt)}`)].join("\n");
+}