@botharness/core 0.1.0-alpha.1 → 1.0.0

package/dist/index.mjs

@@ -2828,6 +2828,114 @@ function handleIntersectionResults(result, left, right) {
 	result.value = merged.data;
 	return result;
 }
+const $ZodTuple = /*@__PURE__*/ $constructor("$ZodTuple", (inst, def) => {
+	$ZodType.init(inst, def);
+	const items = def.items;
+	const memo = globalConfig.memoizer;
+	memo?.attach(inst);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!Array.isArray(input)) {
+			payload.issues.push({
+				input,
+				inst,
+				expected: "tuple",
+				code: "invalid_type"
+			});
+			return payload;
+		}
+		payload.value = memo ? memo.alloc(inst, payload, [], ctx) : [];
+		const proms = [];
+		const optinStart = getTupleOptStart(items, "optin");
+		const optoutStart = getTupleOptStart(items, "optout");
+		if (!def.rest) {
+			if (input.length < optinStart) {
+				payload.issues.push({
+					code: "too_small",
+					minimum: optinStart,
+					inclusive: true,
+					input,
+					inst,
+					origin: "array"
+				});
+				return payload;
+			}
+			if (input.length > items.length) payload.issues.push({
+				code: "too_big",
+				maximum: items.length,
+				inclusive: true,
+				input,
+				inst,
+				origin: "array"
+			});
+		}
+		const itemResults = new Array(items.length);
+		const abortEarly = def.rest ? ctx?.abortEarly : void 0;
+		let itemAborted = false;
+		for (let i = 0; i < items.length; i++) {
+			const r = items[i]._zod.run({
+				value: input[i],
+				issues: []
+			}, ctx);
+			if (r instanceof Promise) proms.push(r.then((rr) => {
+				itemResults[i] = rr;
+			}));
+			else {
+				itemResults[i] = r;
+				if (abortEarly && !itemAborted && r.issues.length) itemAborted = aborted(r);
+			}
+		}
+		if (def.rest && !itemAborted) {
+			let i = items.length - 1;
+			const rest = input.slice(items.length);
+			let seen = payload.issues.length;
+			for (const el of rest) {
+				if (abortEarly && payload.issues.length !== seen) {
+					if (aborted(payload, seen)) break;
+					seen = payload.issues.length;
+				}
+				i++;
+				const result = def.rest._zod.run({
+					value: el,
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((r) => handleTupleResult(r, payload, i)));
+				else handleTupleResult(result, payload, i);
+			}
+		}
+		if (proms.length) return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items, input, optoutStart));
+		return handleTupleResults(itemResults, payload, items, input, optoutStart);
+	};
+});
+function getTupleOptStart(items, key) {
+	for (let i = items.length - 1; i >= 0; i--) if (!(key === "optin" ? items[i]._zod.optin !== void 0 : items[i]._zod.optout === "optional")) return i + 1;
+	return 0;
+}
+function handleTupleResult(result, final, index) {
+	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
+	final.value[index] = result.value;
+}
+function handleTupleResults(itemResults, final, items, input, optoutStart) {
+	for (let i = 0; i < items.length; i++) {
+		const r = itemResults[i];
+		const isPresent = i < input.length;
+		if (!isPresent && i >= optoutStart && items[i]._zod.optin === "optional") {
+			final.value.length = i;
+			break;
+		}
+		if (r.issues.length) {
+			if (!isPresent && i >= optoutStart) {
+				final.value.length = i;
+				break;
+			}
+			final.issues.push(...prefixIssues(i, r.issues));
+		}
+		final.value[i] = r.value;
+	}
+	for (let i = final.value.length - 1; i >= input.length; i--) if (items[i]._zod.optout === "optional" && final.value[i] === void 0) final.value.length = i;
+	else break;
+	return final;
+}
 const $ZodEnum = /*@__PURE__*/ $constructor("$ZodEnum", (inst, def) => {
 	$ZodType.init(inst, def);
 	const values = getEnumValues(def.entries);
@@ -4745,6 +4853,58 @@ const intersectionProcessor = (schema, ctx, json, params) => {
 	json.allOf = allOf;
 	ctx.intersections.push(allOf);
 };
+const tupleProcessor = (schema, ctx, _json, params) => {
+	const json = _json;
+	const def = schema._zod.def;
+	json.type = "array";
+	const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
+	const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
+	const prefixItems = def.items.map((x, i) => processSchema(x, ctx, {
+		...params,
+		path: [
+			...params.path,
+			prefixPath,
+			i
+		]
+	}));
+	const rest = def.rest ? processSchema(def.rest, ctx, {
+		...params,
+		path: [
+			...params.path,
+			restPath,
+			...ctx.target === "openapi-3.0" ? [def.items.length] : []
+		]
+	}) : null;
+	let minItems = def.items.length;
+	while (minItems > 0) {
+		const item = def.items[minItems - 1];
+		if (!(ctx.io === "input" ? inputOptin(item) !== void 0 : item._zod.optout === "optional")) break;
+		minItems--;
+	}
+	const maxItems = def.items.length;
+	const isClosed = !def.rest;
+	if (ctx.target === "draft-2020-12") {
+		json.prefixItems = prefixItems;
+		if (isClosed) json.items = false;
+		else if (rest) json.items = rest;
+		if (minItems > 0) json.minItems = minItems;
+		if (isClosed) json.maxItems = maxItems;
+	} else if (ctx.target === "openapi-3.0") {
+		json.items = { anyOf: prefixItems };
+		if (rest) json.items.anyOf.push(rest);
+		if (minItems > 0) json.minItems = minItems;
+		if (isClosed) json.maxItems = maxItems;
+	} else {
+		json.items = prefixItems;
+		if (isClosed) json.additionalItems = false;
+		else if (rest) json.additionalItems = rest;
+		if (minItems > 0) json.minItems = minItems;
+		if (isClosed) json.maxItems = maxItems;
+	}
+	const { minimum, maximum } = aggregateChecks(schema);
+	if (typeof minimum === "number") json.minItems = minimum;
+	if (typeof maximum === "number") json.maxItems = maximum;
+};
 const nullableProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
 	const inner = processSchema(def.innerType, ctx, params);
@@ -5546,6 +5706,39 @@ function intersection(left, right) {
 		right
 	});
 }
+const ZodTuple = /*@__PURE__*/ $constructor("ZodTuple", (inst, def) => {
+	_ensureDefaultMemoizer();
+	$ZodTuple.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => tupleProcessor(inst, ctx, json, params);
+}, {
+	rest(rest) {
+		return this.clone({
+			...this._zod.def,
+			rest
+		});
+	},
+	partial() {
+		const def = this._zod.def;
+		if (def.checks?.length) throw new Error(".partial() cannot be used on tuple schemas containing refinements");
+		return this.clone({
+			...def,
+			items: def.items.map((item) => new ZodOptional({
+				type: "optional",
+				innerType: item
+			}))
+		});
+	}
+});
+function tuple(items, _paramsOrRest, _params) {
+	const hasRest = _paramsOrRest instanceof $ZodType;
+	return new ZodTuple({
+		type: "tuple",
+		items,
+		rest: hasRest ? _paramsOrRest : null,
+		...normalizeParams(hasRest ? _params : _paramsOrRest)
+	});
+}
 const ZodEnum = /*@__PURE__*/ $constructor("ZodEnum", (inst, def) => {
 	$ZodEnum.init(inst, def);
 	ZodType.init(inst, def);
@@ -6910,7 +7103,7 @@ function createInboundMessaging(options) {
 				grantId: value.id,
 				grantRevision: value.revision,
 				defaultRevision: messagingDefaults(db, value.platform).revision,
-				receptionRevision: groupReceptionPolicy(db, value.id).revision,
+				...event.conversation.kind === "group" ? { receptionRevision: groupReceptionPolicy(db, value.id).revision } : {},
 				...value.channelBridge ? { bridgeRevision: value.channelBridge.revision } : {},
 				...!value.bridgeRoutes && value.receiveTargetChannelId ? { localChannelId: value.receiveTargetChannelId } : {}
 			};
@@ -6927,13 +7120,25 @@ function createInboundMessaging(options) {
 		if (!row) throw new MessagingError("grant-unavailable");
 		return JSON.parse(row.body);
 	};
+	const receptionChanged = () => {
+		if (closed) return;
+		try {
+			options.onReceptionChanged?.();
+		} catch {
+			options.warn?.("messaging-reception-publication-failed");
+		}
+	};
 	const stop = (id) => {
 		clearTimeout(retries.get(id)?.timer);
 		retries.delete(id);
 		const lease = leases.get(id);
 		leases.delete(id);
 		lease?.controller.abort();
-		lease?.dispose?.();
+		try {
+			lease?.dispose?.();
+		} finally {
+			if (lease) receptionChanged();
+		}
 	};
 	const targetAvailable = (value) => {
 		if (value.bridgeRoutes) return true;
@@ -6980,11 +7185,12 @@ function createInboundMessaging(options) {
 			dispose: void 0
 		};
 		leases.set(value.id, lease);
+		receptionChanged();
 		const startedAt = Date.now();
 		try {
 			const inspected = await entry.provider.inspect(value.accountRef, value.targetRef);
-			if (inspected.account.fingerprint !== value.fingerprint || inspected.target.digest !== value.targetDigest || (value.receiveScope ? inspected.target.receiveScope?.conversationId !== value.receiveScope.conversationId : !inspected.target.receiveScope)) throw new MessagingError("rebind-required");
-			transaction((db) => initializeGroupReceptionPolicy(db, value.id));
+			if (inspected.account.fingerprint !== value.fingerprint || inspected.target.digest !== value.targetDigest || (value.receiveScope ? inspected.target.receiveScope?.kind !== value.receiveScope.kind || inspected.target.receiveScope?.conversationId !== value.receiveScope.conversationId : !inspected.target.receiveScope)) throw new MessagingError("rebind-required");
+			if (value.receiveScope?.kind === "group") transaction((db) => initializeGroupReceptionPolicy(db, value.id));
 			const dispose = await entry.consume({
 				accountRef: value.accountRef,
 				fingerprint: value.fingerprint,
@@ -7006,7 +7212,25 @@ function createInboundMessaging(options) {
 					if (closed || leases.get(value.id) !== lease || providers.get(value.providerId)?.token !== entry.token || latest.revision !== value.revision || latest.revokedAt || latest.suspendedReason || options.bindingAvailable?.(latest.bindingId) === false || !options.isBotActive(value.botSlug)) throw new MessagingError("consumer-unavailable");
 					if (event.fingerprint !== value.fingerprint || event.botId !== value.accountRef) throw new MessagingError("untrusted-source");
 					if (!latest.receiveScope) return { accepted: true };
-					if (event.conversation.kind !== "group" || event.conversation.id !== value.receiveScope.conversationId) return { accepted: true };
+					if (event.conversation.kind !== latest.receiveScope.kind || event.conversation.id !== value.receiveScope.conversationId) return { accepted: true };
+					if (event.conversation.kind === "dm") {
+						if (latest.receiveTargetChannelId || latest.channelBridge || latest.bridgeRoutes) throw new MessagingError("capability-unavailable");
+						const id = transaction((db) => {
+							signal.throwIfAborted();
+							lease.controller.signal.throwIfAborted();
+							if (latest.receiveAfter && Date.parse(event.at) < Date.parse(latest.receiveAfter)) return void 0;
+							const sourceEventId = persistSource(db, latest, event);
+							const policy = options.sourcePolicy.resolveIn(db, latest.botSlug, "human-dm");
+							db.prepare(`INSERT OR IGNORE INTO inbox_admissions
+                (source_event_id, bot_slug, reason, source_policy_revision, source_policy_wake_mode,
+                 wake_policy_revision, wake_mode) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(sourceEventId, latest.botSlug, "human-dm", policy.revision, policy.wake, policy.revision, policy.wake === "immediate" ? "all" : policy.wake);
+							return sourceEventId;
+						}, ["source-event", "bot-inbox"]);
+						if (id !== void 0) setImmediate(() => {
+							if (!closed && valid(grant(value.id))) options.onAdmitted(value.botSlug, id);
+						});
+						return { accepted: true };
+					}
 					if (!event.mentionedAccount) {
 						lease.ordinaryVerified = true;
 						if (ordinaryThreadReply(event)) lease.ordinaryThreads.set(event.reply.threadId, event.reply.rootId);
@@ -7183,6 +7407,7 @@ function createInboundMessaging(options) {
 				return;
 			}
 			lease.dispose = dispose;
+			receptionChanged();
 			notifyPending(grant(value.id));
 			options.warn?.(JSON.stringify({
 				event: "messaging-inbound",
@@ -7192,7 +7417,10 @@ function createInboundMessaging(options) {
 			}));
 		} catch (error) {
 			lease.controller.abort();
-			if (leases.get(value.id) === lease) leases.delete(value.id);
+			if (leases.get(value.id) === lease) {
+				leases.delete(value.id);
+				receptionChanged();
+			}
 			const reason = error instanceof MessagingError ? error.code : "consumer-unavailable";
 			const delay = [
 				250,
@@ -7315,6 +7543,7 @@ function createInboundMessaging(options) {
 		async channelBridge(channelId, rawInput) {
 			const input = channelBridgeInput.parse(rawInput);
 			const value = grant(input.grantId);
+			if (value.platform === "weixin") throw new MessagingError("capability-unavailable");
 			const channel = database.read((db) => bridgeChannel(db, channelId, value.botSlug, true));
 			const target = input.delivery === "inbox" ? null : channelId;
 			if (target === null && channel.type !== "dm") throw new MessagingError("channel-unavailable");
@@ -7392,6 +7621,7 @@ function createInboundMessaging(options) {
 				if (providers.get(value.providerId) !== entry || inspected.account.fingerprint !== value.fingerprint || inspected.target.digest !== value.targetDigest) throw new MessagingError("rebind-required");
 				scope = inspected.target.receiveScope;
 				if (!scope) throw new MessagingError("group-required");
+				if (scope.kind === "dm" && (value.receiveTargetChannelId || value.channelBridge || value.bridgeRoutes)) throw new MessagingError("capability-unavailable");
 			}
 			const updated = database.transaction((db) => {
 				const latest = grant(id);
@@ -8034,6 +8264,7 @@ function createOutboundMessaging(options) {
 		sourcePolicy: options.sourcePolicy ?? createBotSourcePolicyStore(database),
 		isBotActive: options.isBotActive,
 		onAdmitted: options.onAdmitted ?? (() => void 0),
+		...options.onReceptionChanged ? { onReceptionChanged: options.onReceptionChanged } : {},
 		...options.onPlaced ? { onPlaced: options.onPlaced } : {},
 		...options.onShared ? { onShared: options.onShared } : {},
 		...options.warn === void 0 ? {} : { warn: options.warn }
@@ -8326,7 +8557,7 @@ function createOutboundMessaging(options) {
 			const channel = database.read((db) => humanBridgeChannel(db, channelId));
 			const snapshots = await Promise.all(channel.members.map((slug) => service.snapshot(slug)));
 			const current = database.read((db) => humanBridgeChannel(db, channelId));
-			const grants = snapshots.flatMap((snapshot, index) => current.members.includes(channel.members[index]) ? snapshot.grants : []);
+			const grants = snapshots.flatMap((snapshot, index) => current.members.includes(channel.members[index]) ? snapshot.grants.filter((grant) => grant.platform !== "weixin") : []);
 			const source = (g) => ({
 				grantId: g.id,
 				grantRevision: g.revision,
@@ -8399,7 +8630,7 @@ function createOutboundMessaging(options) {
 					reception: inbound.status(value.id),
 					canReceive,
 					canPost,
-					...current.revokedAt === void 0 && !current.suspendedReason && options.isBotActive(botSlug) ? {
+					...current.revokedAt === void 0 && !current.suspendedReason && options.isBotActive(botSlug) && current.receiveScope?.kind !== "dm" && current.platform !== "weixin" ? {
 						groupPolicy: inbound.policy(botSlug, value.id),
 						threadPolicies: inbound.threads(botSlug, value.id),
 						ordinaryDelivery: inbound.ordinaryDelivery(value.id)
@@ -8758,7 +8989,8 @@ const inboundSchema = object({
 	channel: _enum([
 		"feishu",
 		"slack",
-		"discord"
+		"discord",
+		"weixin"
 	]),
 	botId: identifier,
 	fingerprint: string().regex(/^[a-f0-9]{64}$/),
@@ -8822,6 +9054,8 @@ function providerFailure(error) {
 		"bot-not-connected",
 		"bad-request",
 		"stale-route",
+		"source-not-found",
+		"reply-permission-denied",
 		"consumer-unavailable",
 		"file-upload-failed",
 		"file-provider-rejected"
@@ -8856,6 +9090,9 @@ function createDshImProvider(value, platform = "feishu") {
 		...platform === "feishu" && target.kind === "group" && typeof target.route.chatId === "string" || platform === "slack" && target.kind === "conversation" && typeof target.route.channelId === "string" || platform === "discord" && target.kind === "channel" && typeof target.route.channelId === "string" ? { receiveScope: {
 			kind: "group",
 			conversationId: String(platform === "feishu" ? target.route.chatId : target.route.channelId)
+		} } : platform === "weixin" && target.kind === "user" && typeof target.route.toUserId === "string" ? { receiveScope: {
+			kind: "dm",
+			conversationId: target.route.toUserId
 		} } : {}
 	}));
 	return {
@@ -8983,12 +9220,18 @@ function createDshImProvider(value, platform = "feishu") {
 						const receipt = object({
 							version: literal(1),
 							messageId: identifier,
-							conversationId: identifier
+							conversationId: identifier,
+							identityKind: literal("client-acknowledgement").optional()
 						}).strict().safeParse(result.receipt);
-						if (!receipt.success || receipt.data.conversationId !== input.route.conversationId) throw new MessagingProviderError("provider-result-unknown", "unknown");
+						if (!receipt.success || receipt.data.conversationId !== input.route.conversationId || (platform === "weixin" ? receipt.data.identityKind !== "client-acknowledgement" : receipt.data.identityKind !== void 0)) throw new MessagingProviderError("provider-result-unknown", "unknown");
 						return {
 							accepted: true,
-							receipt: receipt.data
+							receipt: {
+								version: 1,
+								messageId: receipt.data.messageId,
+								conversationId: receipt.data.conversationId,
+								...receipt.data.identityKind ? { identityKind: receipt.data.identityKind } : {}
+							}
 						};
 					}
 					return { accepted: true };
@@ -17383,20 +17626,78 @@ function isModelPreset(value) {
 	const preset = value;
 	return typeof preset["id"] === "string" && typeof preset["name"] === "string" && Number.isSafeInteger(preset["revision"]) && typeof preset["createdAt"] === "string" && isModelRoute(preset["orchestrator"]) && isModelRoute(preset["assignmentDefault"]) && (preset["assignmentModels"] === void 0 || isAssignmentModelsForDefault(preset["assignmentDefault"], preset["assignmentModels"]));
 }
-function createModelPresetStore(rootDir, now = () => /* @__PURE__ */ new Date()) {
-	const file = join(rootDir, "model-presets.json");
-	const read = () => {
-		let body;
+function presetRecord(preset) {
+	const route = (value) => ({
+		provider: value.provider,
+		model: value.model,
+		...value.reasoningEffort === void 0 ? {} : { reasoningEffort: value.reasoningEffort }
+	});
+	return {
+		id: preset.id,
+		name: preset.name,
+		revision: preset.revision,
+		createdAt: preset.createdAt,
+		orchestrator: route(preset.orchestrator),
+		assignmentDefault: route(preset.assignmentDefault),
+		...preset.assignmentModels === void 0 ? {} : { assignmentModels: preset.assignmentModels.map((option) => ({
+			provider: option.provider,
+			model: option.model,
+			allowedEfforts: [...option.allowedEfforts],
+			defaultEffort: option.defaultEffort
+		})) }
+	};
+}
+function createModelPresetStore(options) {
+	const now = options.now ?? (() => /* @__PURE__ */ new Date());
+	const reportImport = (event) => {
 		try {
-			body = readFileSync(file, "utf8");
+			options.onImport?.(event);
+		} catch {}
+	};
+	const port = attachOperationalModule(options.database, "model-presets");
+	const read = () => port.read((database) => {
+		return database.prepare("SELECT body FROM model_presets ORDER BY rowid").all().map((row) => {
+			const parsed = JSON.parse(String(row["body"]));
+			if (!isModelPreset(parsed)) throw new Error("Invalid Model Preset record");
+			return parsed;
+		});
+	});
+	const write = (preset) => {
+		port.transaction((database) => {
+			database.prepare(`INSERT INTO model_presets (id, body) VALUES (?, ?)
+        ON CONFLICT (id) DO UPDATE SET body = excluded.body`).run(preset.id, JSON.stringify(presetRecord(preset)));
+		}, ["model-presets"]);
+	};
+	if (options.database.mode === "ready" && !port.read((database) => database.prepare("SELECT singleton FROM model_presets_import WHERE singleton = 1").get())) {
+		const startedAt = performance.now();
+		try {
+			let legacy;
+			try {
+				legacy = JSON.parse(readFileSync(join(options.rootDir, "model-presets.json"), "utf8"));
+			} catch (error) {
+				if (error.code !== "ENOENT") throw new Error("Invalid Model Preset import source");
+				legacy = [];
+			}
+			if (!Array.isArray(legacy) || !legacy.every(isModelPreset) || legacy.some((preset) => !preset.id.trim() || !preset.name.trim() || preset.revision < 1) || new Set(legacy.map((preset) => preset.id)).size !== legacy.length || new Set(legacy.map((preset) => preset.name.toLowerCase())).size !== legacy.length) throw new Error("Invalid Model Preset import source");
+			port.transaction((database) => {
+				if (database.prepare("SELECT id FROM model_presets LIMIT 1").get()) throw new Error("Model Preset target is populated without an import marker");
+				const insert = database.prepare("INSERT INTO model_presets (id, body) VALUES (?, ?)");
+				for (const preset of legacy) insert.run(preset.id, JSON.stringify(presetRecord(preset)));
+				database.prepare("INSERT INTO model_presets_import (singleton, imported_at) VALUES (1, ?)").run(now().toISOString());
+			}, ["model-presets"]);
+			reportImport({
+				phase: "complete",
+				count: legacy.length,
+				durationMs: performance.now() - startedAt
+			});
 		} catch (error) {
-			if (error.code === "ENOENT") return [];
+			reportImport({
+				phase: "failed",
+				durationMs: performance.now() - startedAt
+			});
 			throw error;
 		}
-		const parsed = JSON.parse(body);
-		if (!Array.isArray(parsed) || !parsed.every(isModelPreset)) throw new Error("Invalid Model Preset store");
-		return parsed;
-	};
+	}
 	return {
 		list: read,
 		get: (id) => read().find((preset) => preset.id === id),
@@ -17404,8 +17705,7 @@ function createModelPresetStore(rootDir, now = () => /* @__PURE__ */ new Date())
 			if (input.assignmentModels !== void 0) validateAssignmentModels(input.assignmentDefault, input.assignmentModels);
 			const name = input.name.trim();
 			if (name.length === 0 || name.length > 100) throw new Error("Model Preset name is required");
-			const presets = read();
-			if (presets.some((preset) => preset.name.toLowerCase() === name.toLowerCase())) throw new Error("Model Preset name already exists");
+			if (read().some((preset) => preset.name.toLowerCase() === name.toLowerCase())) throw new Error("Model Preset name already exists");
 			const preset = {
 				id: randomUUID(),
 				name,
@@ -17418,8 +17718,7 @@ function createModelPresetStore(rootDir, now = () => /* @__PURE__ */ new Date())
 				})) },
 				createdAt: now().toISOString()
 			};
-			mkdirSync(dirname(file), { recursive: true });
-			atomicWriteFile(file, `${JSON.stringify([...presets, preset], null, 2)}\n`);
+			write(preset);
 			return preset;
 		},
 		update(id, input) {
@@ -17444,8 +17743,7 @@ function createModelPresetStore(rootDir, now = () => /* @__PURE__ */ new Date())
 					allowedEfforts: [...option.allowedEfforts]
 				})) }
 			};
-			presets[index] = updated;
-			atomicWriteFile(file, `${JSON.stringify(presets, null, 2)}\n`);
+			write(updated);
 			return updated;
 		}
 	};
@@ -19324,33 +19622,50 @@ function nextGlobalState(state, patch) {
 	if (topOrder !== void 0) next.topOrder = [...topOrder];
 	return next;
 }
+const arrangementRecord = object({
+	state: rosterDomainState,
+	sections: array(tuple([string().min(1), rosterSectionRecord]))
+});
+function validateArrangement(value) {
+	const parsed = arrangementRecord.parse(value);
+	const sectionIds = /* @__PURE__ */ new Set();
+	const membership = /* @__PURE__ */ new Set();
+	for (const [id, section] of parsed.sections) {
+		if (sectionIds.has(id)) throw new Error("Duplicate roster section");
+		sectionIds.add(id);
+		for (const channelId of section.channelIds) {
+			if (channelId.length === 0 || membership.has(channelId)) throw new Error("Invalid roster membership");
+			membership.add(channelId);
+		}
+	}
+	return parsed;
+}
 var RosterStore = class {
 	options;
-	domain;
-	table;
-	global;
+	database;
+	imported = false;
+	draft;
 	opening;
 	closing = false;
 	warned = false;
 	tail = Promise.resolve();
-	constructor(options = {}) {
+	constructor(options) {
 		this.options = options;
+		this.database = attachOperationalModule(options.database, "roster");
+		if (options.database.mode === "ready") {
+			this.imported = this.database.read((database) => database.prepare("SELECT singleton FROM roster_arrangement_import WHERE singleton = 1").get() !== void 0);
+			if (this.imported) this.readData();
+		}
 	}
 	get available() {
-		return this.domain !== void 0;
+		return this.imported && !this.closing && this.options.database.mode === "ready";
 	}
 	async attach(facility) {
 		this.closing = false;
-		const opening = facility.open(rosterDomainSpec).then(async (domain) => {
-			if (this.closing) {
-				await domain.close();
-				return;
-			}
-			this.domain = domain;
-			this.table = domain.table("sections");
-			this.global = domain.global;
-			this.warned = false;
-		});
+		if (this.imported) return;
+		if (this.opening !== void 0) return this.opening;
+		if (this.options.database.mode !== "ready") throw new RosterUnavailableError();
+		const opening = this.importLegacy(facility);
 		this.opening = opening;
 		try {
 			await opening;
@@ -19358,15 +19673,36 @@ var RosterStore = class {
 			if (this.opening === opening) this.opening = void 0;
 		}
 	}
+	async importLegacy(facility) {
+		const started = performance.now();
+		let domain;
+		try {
+			domain = await facility.open(rosterDomainSpec);
+			if (this.closing) return;
+			const record = validateArrangement({
+				state: domain.global.get(),
+				sections: [...domain.table("sections").entries()]
+			});
+			this.database.transaction((database) => {
+				if (database.prepare("SELECT singleton FROM roster_arrangement WHERE singleton = 1").get() !== void 0) throw new Error("Roster target exists without an import marker");
+				database.prepare("INSERT INTO roster_arrangement(singleton, body) VALUES (1, ?)").run(JSON.stringify(record));
+				database.prepare("INSERT INTO roster_arrangement_import(singleton, imported_at) VALUES (1, ?)").run((/* @__PURE__ */ new Date()).toISOString());
+			});
+			this.imported = true;
+			this.warned = false;
+			this.notifyCommitted();
+			this.warn(`roster-import initiator=host-startup phase=completed count=${record.sections.length} durationMs=${Math.round(performance.now() - started)}`);
+		} catch {
+			this.warn(`roster-import initiator=host-startup phase=failed durationMs=${Math.round(performance.now() - started)}`);
+			throw new RosterUnavailableError();
+		} finally {
+			if (domain !== void 0) await domain.close().catch(() => this.warn("roster-import initiator=host-startup phase=source-close-failed"));
+		}
+	}
 	async detach() {
 		this.closing = true;
-		const opening = this.opening;
-		if (opening !== void 0) await opening.catch(() => {});
-		const domain = this.domain;
-		this.domain = void 0;
-		this.table = void 0;
-		this.global = void 0;
-		if (domain !== void 0) await domain.close();
+		if (this.opening !== void 0) await this.opening.catch(() => {});
+		await this.tail;
 	}
 	snapshot() {
 		const table = this.requireTable();
@@ -19383,27 +19719,22 @@ var RosterStore = class {
 		};
 	}
 	sectionCreate(name) {
-		return this.enqueue(async () => {
+		return this.enqueue(() => {
 			const table = this.requireTable();
 			const global = this.requireGlobal();
 			const id = randomUUID();
-			await table.put(id, {
+			table.put(id, {
 				name,
 				channelIds: []
 			});
 			const state = global.get();
-			try {
-				await global.set(nextGlobalState(state, {
-					sectionOrder: [id, ...state.sectionOrder],
-					topOrder: state.topOrder === void 0 ? void 0 : [{
-						kind: "section",
-						id
-					}, ...state.topOrder]
-				}));
-			} catch (error) {
-				await table.delete(id).catch(() => {});
-				throw error;
-			}
+			global.set(nextGlobalState(state, {
+				sectionOrder: [id, ...state.sectionOrder],
+				topOrder: state.topOrder === void 0 ? void 0 : [{
+					kind: "section",
+					id
+				}, ...state.topOrder]
+			}));
 			return {
 				id,
 				name,
@@ -19412,11 +19743,11 @@ var RosterStore = class {
 		});
 	}
 	sectionRename(sectionId, name) {
-		return this.enqueue(async () => {
+		return this.enqueue(() => {
 			const table = this.requireTable();
 			const current = table.get(sectionId);
 			if (current === void 0) throw new RosterUnknownSectionError(sectionId);
-			if (current.name !== name) await table.put(sectionId, {
+			if (current.name !== name) table.put(sectionId, {
 				name,
 				channelIds: [...current.channelIds]
 			});
@@ -19428,14 +19759,14 @@ var RosterStore = class {
 		});
 	}
 	sectionRemove(sectionId) {
-		return this.enqueue(async () => {
+		return this.enqueue(() => {
 			const table = this.requireTable();
 			const global = this.requireGlobal();
 			const removed = table.get(sectionId);
-			if (!await table.delete(sectionId)) return false;
+			if (!table.delete(sectionId)) return false;
 			const state = global.get();
 			const members = removed === void 0 ? [] : [...removed.channelIds];
-			await global.set(nextGlobalState(state, {
+			global.set(nextGlobalState(state, {
 				sectionOrder: state.sectionOrder.filter((id) => id !== sectionId),
 				topOrder: state.topOrder === void 0 ? void 0 : sanitizeTopOrder(state.topOrder.flatMap((entry) => entry.kind === "section" && entry.id === sectionId ? members.map((id) => ({
 					kind: "channel",
@@ -19446,7 +19777,7 @@ var RosterStore = class {
 		});
 	}
 	channelAssign(channelId, sectionId, index) {
-		return this.enqueue(async () => {
+		return this.enqueue(() => {
 			const table = this.requireTable();
 			const global = this.requireGlobal();
 			if (sectionId !== void 0 && table.get(sectionId) === void 0) throw new RosterUnknownSectionError(sectionId);
@@ -19472,19 +19803,19 @@ var RosterStore = class {
 					channelIds: without
 				}]);
 			}
-			for (const [id, record] of removals) await table.put(id, record);
-			if (target !== void 0) await table.put(target[0], target[1]);
+			for (const [id, record] of removals) table.put(id, record);
+			if (target !== void 0) table.put(target[0], target[1]);
 			const state = global.get();
 			if (state.topOrder === void 0) return;
 			const next = sanitizeTopOrder(sectionId === void 0 ? [...state.topOrder, {
 				kind: "channel",
 				id: channelId
 			}] : state.topOrder.filter((entry) => entry.kind !== "channel" || entry.id !== channelId), table);
-			if (!sameEntries(next, state.topOrder)) await global.set(nextGlobalState(state, { topOrder: next }));
+			if (!sameEntries(next, state.topOrder)) global.set(nextGlobalState(state, { topOrder: next }));
 		});
 	}
 	sectionReorder(order) {
-		return this.enqueue(async () => {
+		return this.enqueue(() => {
 			const table = this.requireTable();
 			const global = this.requireGlobal();
 			const current = this.orderedSections(global.get().sectionOrder).map((section) => section.id);
@@ -19515,7 +19846,7 @@ var RosterStore = class {
 			}
 			const storedTop = state.topOrder;
 			if (sameIds(next, state.sectionOrder) && (topOrder === void 0 || storedTop !== void 0 && sameEntries(topOrder, storedTop))) return next;
-			await global.set(nextGlobalState(state, {
+			global.set(nextGlobalState(state, {
 				sectionOrder: next,
 				topOrder
 			}));
@@ -19523,19 +19854,19 @@ var RosterStore = class {
 		});
 	}
 	topReorder(order) {
-		return this.enqueue(async () => {
+		return this.enqueue(() => {
 			const table = this.requireTable();
 			const global = this.requireGlobal();
 			const state = global.get();
 			const next = sanitizeTopOrder(order, table);
 			const current = state.topOrder === void 0 ? void 0 : sanitizeTopOrder(state.topOrder, table);
 			if (current !== void 0 && sameEntries(next, current)) return next;
-			await global.set(nextGlobalState(state, { topOrder: next }));
+			global.set(nextGlobalState(state, { topOrder: next }));
 			return next;
 		});
 	}
 	applyBatch(change, resolvePin = (pin) => pin) {
-		return this.enqueue(async () => {
+		return this.enqueue(() => {
 			const ids = uniqueStrings(change.channelIds);
 			if (ids.length === 0 || change.channelIds.length > 100 || ids.length !== change.channelIds.length) throw new RangeError(`roster batch must contain 1–100 distinct channels`);
 			const table = this.requireTable();
@@ -19546,19 +19877,19 @@ var RosterStore = class {
 			if (change.action === "pin") {
 				const existing = new Set(pins);
 				const next = [...pins, ...ids.filter((id) => !existing.has(id))];
-				if (!sameIds(next, state.pins)) await global.set(nextGlobalState(state, { pins: next }));
+				if (!sameIds(next, state.pins)) global.set(nextGlobalState(state, { pins: next }));
 				return this.snapshot();
 			}
 			if (change.action === "hide") {
 				const hidden = uniqueStrings(state.hidden ?? []);
 				const existing = new Set(hidden);
 				const next = [...hidden, ...ids.filter((id) => !existing.has(id))];
-				if (!sameIds(next, state.hidden ?? [])) await global.set(nextGlobalState(state, { hidden: next }));
+				if (!sameIds(next, state.hidden ?? [])) global.set(nextGlobalState(state, { hidden: next }));
 				return this.snapshot();
 			}
 			const nextPins = pins.filter((id) => !selected.has(id));
 			if (change.action === "unpin") {
-				if (!sameIds(nextPins, state.pins)) await global.set(nextGlobalState(state, { pins: nextPins }));
+				if (!sameIds(nextPins, state.pins)) global.set(nextGlobalState(state, { pins: nextPins }));
 				return this.snapshot();
 			}
 			const sectionId = change.sectionId;
@@ -19572,12 +19903,12 @@ var RosterStore = class {
 					channelIds
 				}]);
 			}
-			for (const [id, record] of updates) await table.put(id, record);
+			for (const [id, record] of updates) table.put(id, record);
 			const topOrder = state.topOrder === void 0 ? void 0 : sanitizeTopOrder([...state.topOrder.filter((entry) => entry.kind !== "channel" || !selected.has(entry.id)), ...sectionId === void 0 ? ids.map((id) => ({
 				kind: "channel",
 				id
 			})) : []], table);
-			if (!sameIds(nextPins, state.pins) || topOrder !== void 0 && (state.topOrder === void 0 || !sameEntries(topOrder, state.topOrder))) await global.set(nextGlobalState(state, {
+			if (!sameIds(nextPins, state.pins) || topOrder !== void 0 && (state.topOrder === void 0 || !sameEntries(topOrder, state.topOrder))) global.set(nextGlobalState(state, {
 				pins: nextPins,
 				topOrder
 			}));
@@ -19585,20 +19916,20 @@ var RosterStore = class {
 		});
 	}
 	pinsSet(pins) {
-		return this.enqueue(async () => {
+		return this.enqueue(() => {
 			const global = this.requireGlobal();
 			const next = uniqueStrings(pins);
 			const state = global.get();
-			if (!sameIds(next, state.pins)) await global.set(nextGlobalState(state, { pins: next }));
+			if (!sameIds(next, state.pins)) global.set(nextGlobalState(state, { pins: next }));
 			return next;
 		});
 	}
 	hiddenSet(hidden) {
-		return this.enqueue(async () => {
+		return this.enqueue(() => {
 			const global = this.requireGlobal();
 			const next = uniqueStrings(hidden);
 			const state = global.get();
-			if (!sameIds(next, state.hidden ?? [])) await global.set(nextGlobalState(state, { hidden: next }));
+			if (!sameIds(next, state.hidden ?? [])) global.set(nextGlobalState(state, { hidden: next }));
 			return next;
 		});
 	}
@@ -19626,39 +19957,104 @@ var RosterStore = class {
 		return sections;
 	}
 	enqueue(operation) {
-		const result = this.tail.then(async () => {
-			const value = await operation();
+		const result = this.tail.then(() => {
+			if (!this.available) {
+				this.reportUnavailable();
+				throw new RosterUnavailableError();
+			}
+			let value;
 			try {
-				this.options.onCommitted?.();
+				value = this.database.transaction((database) => {
+					this.draft = this.readData();
+					const before = JSON.stringify({
+						state: this.draft.state,
+						sections: [...this.draft.sections]
+					});
+					try {
+						const outcome = operation();
+						const after = JSON.stringify({
+							state: this.draft.state,
+							sections: [...this.draft.sections]
+						});
+						if (before !== after) database.prepare("UPDATE roster_arrangement SET body = ? WHERE singleton = 1").run(after);
+						return outcome;
+					} finally {
+						this.draft = void 0;
+					}
+				}, ["roster"]);
 			} catch (error) {
-				this.options.warn?.(`botharness: roster committed notification failed: ${String(error)}`);
+				if (error instanceof OperationalDatabaseError && this.options.database.mode === "ready" && (error.cause instanceof RosterUnknownSectionError || error.cause instanceof RangeError)) throw error.cause;
+				if (error instanceof OperationalDatabaseError) throw new RosterUnavailableError();
+				throw error;
 			}
+			this.notifyCommitted();
 			return value;
 		});
 		this.tail = result.then(() => {}, () => {});
 		return result;
 	}
+	notifyCommitted() {
+		try {
+			this.options.onCommitted?.();
+		} catch {
+			this.warn("roster-notification initiator=host phase=observer-failed");
+		}
+	}
+	warn(message) {
+		try {
+			this.options.warn?.(message);
+		} catch {}
+	}
 	reportUnavailable() {
 		if (this.warned) return;
 		this.warned = true;
-		this.options.warn?.("botharness: storageDomain is unavailable; the roster arrangement is read-only");
+		this.warn("roster-storage initiator=host phase=unavailable arrangement=read-only");
 	}
-	requireTable() {
-		if (this.table === void 0) {
+	readData() {
+		if (this.draft !== void 0) return this.draft;
+		if (!this.available) {
 			this.reportUnavailable();
 			throw new RosterUnavailableError();
 		}
-		return this.table;
-	}
-	requireGlobal() {
-		if (this.global === void 0) {
-			this.reportUnavailable();
+		try {
+			return this.database.read((database) => {
+				const row = database.prepare("SELECT body FROM roster_arrangement WHERE singleton = 1").get();
+				if (typeof row?.body !== "string") throw new RosterUnavailableError();
+				const record = validateArrangement(JSON.parse(row.body));
+				return {
+					state: record.state,
+					sections: new Map(record.sections)
+				};
+			});
+		} catch {
 			throw new RosterUnavailableError();
 		}
-		return this.global;
+	}
+	requireDraft() {
+		if (this.draft === void 0) throw new RosterUnavailableError();
+		return this.draft;
+	}
+	requireTable() {
+		const sections = this.readData().sections;
+		return {
+			get: (id) => sections.get(id),
+			entries: () => sections.entries(),
+			put: (id, record) => {
+				this.requireDraft().sections.set(id, record);
+			},
+			delete: (id) => this.requireDraft().sections.delete(id)
+		};
+	}
+	requireGlobal() {
+		return {
+			get: () => this.readData().state,
+			set: (state) => {
+				this.requireDraft().state = state;
+			}
+		};
 	}
 };
-function createRosterStore(options = {}) {
+function createRosterStore(options) {
 	return new RosterStore(options);
 }
 //#endregion
@@ -21551,6 +21947,30 @@ function createBridgeMethods(deps) {
 			...humanNickname === void 0 ? {} : { humanNickname }
 		};
 	};
+	const marketplaceCall = async (operation) => {
+		if (deps.marketplace === void 0) return {
+			ok: false,
+			error: {
+				code: "marketplace-unavailable",
+				message: "Bot Marketplace is unavailable"
+			}
+		};
+		const result = await operation(deps.marketplace);
+		if (result.ok) return result;
+		deps.warn?.(JSON.stringify({
+			module: "marketplace",
+			initiator: "client",
+			phase: "request-refused",
+			reason: result.code
+		}));
+		return {
+			ok: false,
+			error: {
+				code: result.code,
+				message: result.code
+			}
+		};
+	};
 	const messagingCall = async (operation) => {
 		if (deps.externalMessaging === void 0) return {
 			ok: false,
@@ -22139,6 +22559,32 @@ function createBridgeMethods(deps) {
 				value: detailOf(result.record)
 			};
 		},
+		marketplaceList(payload) {
+			const source = asObject(payload);
+			const query = {};
+			for (const key of [
+				"cursor",
+				"q",
+				"topic"
+			]) {
+				const value = parseOptional(source, key);
+				if (!value.ok) return Promise.resolve(invalidInput(`invalid ${key}`));
+				const trimmed = value.value?.trim();
+				if (trimmed !== void 0 && trimmed.length > 0) query[key] = trimmed;
+			}
+			const sort = source["sort"];
+			if (sort !== void 0 && sort !== "updated" && sort !== "stars") return Promise.resolve(invalidInput("invalid sort"));
+			if (sort !== void 0) query.sort = sort;
+			return marketplaceCall((client) => client.list(query));
+		},
+		marketplaceTopics() {
+			return marketplaceCall((client) => client.topics());
+		},
+		marketplaceSubmit(payload) {
+			const url = asObject(payload)["url"];
+			if (typeof url !== "string" || url.trim().length === 0) return Promise.resolve(invalidInput("url is required"));
+			return marketplaceCall((client) => client.submit(url.trim()));
+		},
 		update(payload) {
 			const slug = asSlug(payload);
 			if (slug === void 0) return invalidInput("slug is required");
@@ -24546,6 +24992,15 @@ var BotharnessBridgeService = class extends TypertRemoteService {
 	developerModeSet(enabled) {
 		return unwrap(this.methods.developerModeSet({ enabled }));
 	}
+	async marketplaceList(query) {
+		return unwrapAsync(this.methods.marketplaceList(query ?? {}));
+	}
+	async marketplaceSubmit(url) {
+		return unwrapAsync(this.methods.marketplaceSubmit({ url }));
+	}
+	async marketplaceTopics() {
+		return unwrapAsync(this.methods.marketplaceTopics());
+	}
 };
 markRemoteMethods(BotharnessBridgeService.prototype, [
 	"messagingDefaults",
@@ -24664,12 +25119,155 @@ markRemoteMethods(BotharnessBridgeService.prototype, [
 	"browserAccessSet",
 	"browserProfileSet",
 	"botAvatarSet",
-	"botAppearanceSet"
+	"botAppearanceSet",
+	"marketplaceList",
+	"marketplaceSubmit",
+	"marketplaceTopics"
 ]);
 function registerBridge(ctx, methods) {
 	return new BotharnessBridgeService(ctx, methods);
 }
 //#endregion
+//#region packages/core/src/marketplace/client.ts
+const REQUEST_TIMEOUT_MS = 15e3;
+function record$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function parseEntry(value) {
+	const source = record$1(value);
+	if (source === void 0) return void 0;
+	if (![
+		"id",
+		"owner",
+		"name",
+		"fullName",
+		"pushedAt",
+		"htmlUrl",
+		"cloneUrl",
+		"defaultBranch"
+	].every((key) => typeof source[key] === "string")) return void 0;
+	const description = source["description"];
+	const stars = source["stars"];
+	const topics = source["topics"];
+	const head = record$1(source["headCommit"]);
+	if (description !== null && typeof description !== "string") return void 0;
+	if (typeof stars !== "number" || !Array.isArray(topics)) return void 0;
+	return {
+		id: source["id"],
+		owner: source["owner"],
+		name: source["name"],
+		fullName: source["fullName"],
+		description,
+		topics: topics.filter((topic) => typeof topic === "string"),
+		stars,
+		pushedAt: source["pushedAt"],
+		htmlUrl: source["htmlUrl"],
+		cloneUrl: source["cloneUrl"],
+		defaultBranch: source["defaultBranch"],
+		headCommit: head !== void 0 && typeof head["sha"] === "string" && typeof head["committedAt"] === "string" ? {
+			sha: head["sha"],
+			committedAt: head["committedAt"]
+		} : null
+	};
+}
+function parseMarketplacePage(value) {
+	const source = record$1(value);
+	if (source === void 0 || !Array.isArray(source["bots"])) return void 0;
+	const bots = source["bots"].map(parseEntry);
+	if (!bots.every((bot) => bot !== void 0)) return void 0;
+	const nextCursor = source["nextCursor"];
+	return typeof nextCursor === "string" ? {
+		bots,
+		nextCursor
+	} : { bots };
+}
+function parseMarketplaceTopics(value) {
+	const topics = record$1(value)?.["topics"];
+	if (!Array.isArray(topics)) return void 0;
+	const parsed = topics.map((item) => {
+		const source = record$1(item);
+		return typeof source?.["topic"] === "string" && typeof source["count"] === "number" ? {
+			topic: source["topic"],
+			count: source["count"]
+		} : void 0;
+	});
+	return parsed.every((item) => item !== void 0) ? parsed : void 0;
+}
+function listPath(query) {
+	const params = new URLSearchParams();
+	if (query.sort !== void 0) params.set("sort", query.sort);
+	if (query.q !== void 0) params.set("q", query.q);
+	if (query.topic !== void 0) params.set("topic", query.topic);
+	if (query.cursor !== void 0) params.set("cursor", query.cursor);
+	const search = params.toString();
+	return search.length === 0 ? "/v1/bots" : `/v1/bots?${search}`;
+}
+function parseMarketplaceSubmission(value) {
+	const bot = parseEntry(record$1(value)?.["bot"]);
+	return bot === void 0 ? void 0 : { bot };
+}
+function createMarketplaceClient(options) {
+	const fetchImpl = options.fetchImpl ?? fetch;
+	const baseUrl = options.baseUrl.replace(/\/+$/u, "");
+	const timeoutMs = options.timeoutMs ?? REQUEST_TIMEOUT_MS;
+	const request = async (path, init, parse) => {
+		let response;
+		try {
+			response = await fetchImpl(`${baseUrl}${path}`, {
+				...init,
+				signal: AbortSignal.timeout(timeoutMs)
+			});
+		} catch {
+			return {
+				ok: false,
+				code: "marketplace-unavailable"
+			};
+		}
+		let body;
+		try {
+			body = await response.json();
+		} catch {
+			return {
+				ok: false,
+				code: "marketplace-unavailable"
+			};
+		}
+		if (!response.ok) {
+			const code = record$1(record$1(body)?.["error"])?.["code"];
+			return {
+				ok: false,
+				code: typeof code === "string" ? code : "marketplace-unavailable"
+			};
+		}
+		const value = parse(body);
+		return value === void 0 ? {
+			ok: false,
+			code: "marketplace-unavailable"
+		} : {
+			ok: true,
+			value
+		};
+	};
+	return {
+		list: (query) => request(listPath(query), {
+			method: "GET",
+			headers: { accept: "application/json" }
+		}, parseMarketplacePage),
+		topics: () => request("/v1/topics", {
+			method: "GET",
+			headers: { accept: "application/json" }
+		}, parseMarketplaceTopics),
+		submit: (url) => request("/v1/submissions", {
+			method: "POST",
+			headers: {
+				accept: "application/json",
+				"content-type": "application/json"
+			},
+			body: JSON.stringify({ url })
+		}, parseMarketplaceSubmission)
+	};
+}
+//#endregion
 //#region packages/core/src/bots/avatar-snapshot.ts
 function deriveAvatarAppearance(value) {
 	if (!isAvatarRecipe(value)) return void 0;
@@ -24705,39 +25303,117 @@ function createPersonaBotRegistry(options) {
 	const botDir = (slug) => join(rootDir, slug);
 	const botFile = (slug) => join(botDir(slug), "bot.json");
 	const defaultMemoryDir = (slug) => join(botDir(slug), "memory");
+	const port = attachOperationalModule(options.database, "bot-registry");
+	const recordSnapshot = (record) => {
+		const result = {
+			slug: record.slug,
+			displayName: record.displayName,
+			workspaces: [...record.workspaces],
+			createdAt: record.createdAt
+		};
+		for (const key of [
+			"roles",
+			"tag",
+			"description",
+			"avatar",
+			"appearance",
+			"model",
+			"preset",
+			"memoryDir",
+			"paused",
+			"computerAccess",
+			"browserAccess",
+			"browserProfile"
+		]) if (record[key] !== void 0) Object.assign(result, { [key]: record[key] });
+		const route = (value) => ({
+			provider: value.provider,
+			model: value.model,
+			...value.reasoningEffort === void 0 ? {} : { reasoningEffort: value.reasoningEffort }
+		});
+		const plan = record.modelPlan;
+		if (plan !== void 0) result.modelPlan = {
+			revision: plan.revision,
+			sourcePresetId: plan.sourcePresetId,
+			sourcePresetName: plan.sourcePresetName,
+			appliedAt: plan.appliedAt,
+			orchestrator: route(plan.orchestrator),
+			assignmentDefault: route(plan.assignmentDefault),
+			...plan.assignmentModels === void 0 ? {} : { assignmentModels: plan.assignmentModels.map((option) => ({
+				provider: option.provider,
+				model: option.model,
+				allowedEfforts: [...option.allowedEfforts],
+				defaultEffort: option.defaultEffort
+			})) }
+		};
+		return result;
+	};
+	const decode = (text, slug) => {
+		const parsed = JSON.parse(text);
+		if (typeof parsed === "object" && parsed !== null && "appearance" in parsed && !isUsableAvatarAppearance(parsed.appearance, parsed.avatar)) delete parsed.appearance;
+		if (!isPersonaBotRecord(parsed, slug)) throw new Error("Invalid PersonaBot Registry record");
+		return recordSnapshot(parsed);
+	};
 	const read = (slug) => {
 		if (!isValidSlug(slug)) return void 0;
-		let text;
-		try {
-			text = readFileSync(botFile(slug), "utf8");
-		} catch (error) {
-			if (isMissing(error)) return void 0;
-			throw error;
-		}
-		let parsed;
-		try {
-			parsed = JSON.parse(text);
-		} catch {
-			return;
-		}
-		if (typeof parsed === "object" && parsed !== null && "appearance" in parsed && !isUsableAvatarAppearance(parsed.appearance, parsed.avatar)) delete parsed.appearance;
-		return isPersonaBotRecord(parsed, slug) ? parsed : void 0;
+		return port.read((database) => {
+			const row = database.prepare("SELECT body FROM persona_bots WHERE slug = ?").get(slug);
+			return row === void 0 ? void 0 : decode(String(row["body"]), slug);
+		});
 	};
 	const write = (record) => {
-		const dir = botDir(record.slug);
-		mkdirSync(dir, { recursive: true });
-		atomicWriteFile(botFile(record.slug), `${JSON.stringify(record, null, 2)}\n`);
-	};
-	const list = () => {
-		let entries;
+		port.transaction((database) => {
+			database.prepare(`INSERT INTO persona_bots (slug, body) VALUES (?, ?)
+        ON CONFLICT (slug) DO UPDATE SET body = excluded.body`).run(record.slug, JSON.stringify(recordSnapshot(record)));
+		}, ["bot-registry"]);
+	};
+	const erase = (slug) => {
+		port.transaction((database) => {
+			database.prepare("DELETE FROM persona_bots WHERE slug = ?").run(slug);
+		}, ["bot-registry"]);
+	};
+	const list = () => port.read((database) => database.prepare("SELECT slug, body FROM persona_bots").all().map((row) => decode(String(row["body"]), String(row["slug"]))).sort((left, right) => left.slug.localeCompare(right.slug)));
+	if (options.database.mode === "ready" && !port.read((database) => database.prepare("SELECT singleton FROM persona_bots_import WHERE singleton = 1").get())) {
+		const startedAt = performance.now();
+		const report = (phase, count) => {
+			try {
+				options.onImport?.({
+					phase,
+					...count === void 0 ? {} : { count },
+					durationMs: performance.now() - startedAt
+				});
+			} catch {}
+		};
 		try {
-			entries = readdirSync(rootDir, { withFileTypes: true });
-		} catch (error) {
-			if (isMissing(error)) return [];
-			throw error;
+			let entries;
+			try {
+				entries = readdirSync(rootDir, { withFileTypes: true });
+			} catch (error) {
+				if (!isMissing(error)) throw error;
+				entries = [];
+			}
+			const records = [];
+			for (const entry of entries.filter((entry) => entry.isDirectory() && isValidSlug(entry.name))) {
+				let text;
+				try {
+					text = readFileSync(botFile(entry.name), "utf8");
+				} catch (error) {
+					if (isMissing(error)) continue;
+					throw error;
+				}
+				records.push(decode(text, entry.name));
+			}
+			port.transaction((database) => {
+				if (database.prepare("SELECT slug FROM persona_bots LIMIT 1").get()) throw new Error("PersonaBot Registry target is populated without an import marker");
+				const insert = database.prepare("INSERT INTO persona_bots (slug, body) VALUES (?, ?)");
+				for (const record of records) insert.run(record.slug, JSON.stringify(record));
+				database.prepare("INSERT INTO persona_bots_import (singleton, imported_at) VALUES (1, ?)").run(now().toISOString());
+			}, ["bot-registry"]);
+			report("complete", records.length);
+		} catch {
+			report("failed");
+			throw new Error("PersonaBot Registry import failed; repair retained legacy records before retry");
 		}
-		return entries.filter((entry) => entry.isDirectory()).map((entry) => read(entry.name)).filter((record) => record !== void 0).sort((left, right) => left.slug.localeCompare(right.slug));
-	};
+	}
 	const memoryDirOf = (record) => record.memoryDir ?? defaultMemoryDir(record.slug);
 	const ensurePersonaFile = (memoryDir, body) => {
 		mkdirSync(memoryDir, { recursive: true });
@@ -24850,7 +25526,7 @@ function createPersonaBotRegistry(options) {
 					ok: false,
 					reason: cloned.code
 				};
-				if (existsSync(botDir(input.slug))) return {
+				if (read(input.slug) !== void 0 || existsSync(botDir(input.slug))) return {
 					ok: false,
 					reason: "duplicate"
 				};
@@ -24872,10 +25548,12 @@ function createPersonaBotRegistry(options) {
 					recursive: true,
 					force: true
 				});
-				if (ownsBotDir && !created && !existsSync(botFile(input.slug))) rmSync(botDir(input.slug), {
-					recursive: true,
-					force: true
-				});
+				if (ownsBotDir && !created && options.database.mode === "ready") try {
+					if (read(input.slug) === void 0) rmSync(botDir(input.slug), {
+						recursive: true,
+						force: true
+					});
+				} catch {}
 			}
 		},
 		get(slug) {
@@ -24889,7 +25567,7 @@ function createPersonaBotRegistry(options) {
 		},
 		remove(slug, removeOptions) {
 			if (!isValidSlug(slug)) return false;
-			const exists = existsSync(botDir(slug));
+			const exists = read(slug) !== void 0 || existsSync(botDir(slug));
 			if (removeOptions?.purge === true) {
 				const removeFiles = () => {
 					if (exists) rmSync(botDir(slug), {
@@ -24899,10 +25577,11 @@ function createPersonaBotRegistry(options) {
 				};
 				if (options.onPurge === void 0) removeFiles();
 				else options.onPurge(slug, removeFiles);
+				erase(slug);
 				return exists;
 			}
 			if (!exists) return false;
-			rmSync(botFile(slug), { force: true });
+			erase(slug);
 			return true;
 		},
 		memoryDirFor(slug) {
@@ -28585,6 +29264,49 @@ const BOT_HARNESS_SCHEMA_PLAN = defineSchemaPlan([
         BEGIN SELECT RAISE(ABORT, 'Messaging defaults revisions are immutable'); END;
       CREATE TRIGGER messaging_defaults_no_delete BEFORE DELETE ON messaging_default_revisions
         BEGIN SELECT RAISE(ABORT, 'Messaging defaults revisions are immutable'); END;
+    `);
+		}
+	},
+	{
+		generation: 54,
+		module: "model-presets",
+		description: "Own reusable Model Presets and their one-time import marker in the Profile database",
+		migrate(database) {
+			database.exec(`
+      CREATE TABLE model_presets (id TEXT PRIMARY KEY, body TEXT NOT NULL CHECK (json_valid(body)));
+      CREATE TABLE model_presets_import (
+        singleton INTEGER PRIMARY KEY CHECK (singleton = 1), imported_at TEXT NOT NULL
+      );
+    `);
+		}
+	},
+	{
+		generation: 55,
+		module: "bot-registry",
+		description: "Own PersonaBot identities and applied plans with a durable Registry import marker",
+		migrate(database) {
+			database.exec(`
+      CREATE TABLE persona_bots (slug TEXT PRIMARY KEY, body TEXT NOT NULL CHECK (json_valid(body)));
+      CREATE TABLE persona_bots_import (
+        singleton INTEGER PRIMARY KEY CHECK (singleton = 1), imported_at TEXT NOT NULL
+      );
+    `);
+		}
+	},
+	{
+		generation: 56,
+		module: "roster",
+		description: "Own Channel sections and roster arrangement in the Profile database",
+		migrate(database) {
+			database.exec(`
+      CREATE TABLE roster_arrangement (
+        singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+        body TEXT NOT NULL CHECK (json_valid(body))
+      );
+      CREATE TABLE roster_arrangement_import (
+        singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+        imported_at TEXT NOT NULL
+      );
     `);
 		}
 	}
@@ -37089,7 +37811,7 @@ var BotRuntimeImplementation = class {
 		}
 		if (!row || !["pending", "retryable"].includes(row.attempt_state)) return;
 		const active = this.#activeTurns.get(botSlug);
-		if (row.reason === "group-mention" && this.#delivery(botSlug, "group-mention") === "steer" && active && this.#agents.steerOrchestrator) {
+		if ((row.reason === "group-mention" || row.reason === "human-dm") && this.#delivery(botSlug, row.reason) === "steer" && active && this.#agents.steerOrchestrator) {
 			const source = this.#externalMessaging.inbound.read(botSlug, sourceEventId);
 			const unit = {
 				sourceEventId,
@@ -38467,13 +39189,16 @@ var BotRuntimeImplementation = class {
              WHERE source_kind IN ('memory-change', 'bridge-message')
                AND source_event_id IN (
                  SELECT source_event_id FROM inbox_admissions
-                  WHERE reason IN ('memory-change', 'group-mention', 'group-ordinary') AND attempt_state = 'retryable'
+                  WHERE reason IN ('memory-change', 'group-mention', 'group-ordinary', 'human-dm') AND attempt_state = 'retryable'
                     AND side_effect_started_at IS NULL
                )
           `).run();
 			database.prepare(`
             UPDATE inbox_admissions SET observed_at = NULL
-             WHERE reason IN ('memory-change', 'group-mention', 'group-ordinary') AND attempt_state = 'retryable'
+             WHERE (reason IN ('memory-change', 'group-mention', 'group-ordinary') OR
+                    (reason = 'human-dm' AND source_event_id IN (
+                      SELECT source_event_id FROM source_events WHERE source_kind = 'bridge-message'
+                    ))) AND attempt_state = 'retryable'
                AND side_effect_started_at IS NULL
           `).run();
 		}, ["source-event", "bot-inbox"]);
@@ -39779,7 +40504,7 @@ var BotRuntimeImplementation = class {
         AND a.attempt_state IN ('pending', 'retryable') AND a.observed_at IS NULL
       WINDOW policy AS (PARTITION BY g.id, a.wake_policy_revision, a.source_policy_revision, a.external_default_revision, a.reason, CASE WHEN json_extract(tp.body, '$.mode') = 'follow' THEN tp.thread_id ELSE '' END, CASE WHEN json_extract(tp.body, '$.mode') = 'follow' THEN tp.revision ELSE 0 END)
     ) SELECT source_event_id, body, created_at, attempt_state FROM pending
-      WHERE reason = 'group-mention' OR (reason = 'group-ordinary' AND (
+      WHERE reason = 'group-mention' OR (reason = 'human-dm' AND wake_mode = 'all') OR (reason = 'group-ordinary' AND (
         wake_mode = 'all' OR (wake_mode = 'digest' AND (pending_count >= wake_count OR
           (julianday(?) - julianday(first_at)) * 86400000 >= wake_interval_ms)) OR
         (? = 1 AND has_mention = 1 AND wake_mode IN ('digest', 'mentions'))))
@@ -39907,7 +40632,7 @@ var BotRuntimeImplementation = class {
 		this.#database.transaction((db) => {
 			for (const id of ids) if (db.prepare(`UPDATE inbox_admissions SET observed_at = COALESCE(observed_at, ?),
           side_effect_started_at = COALESCE(side_effect_started_at, ?), attempt_state = 'running', last_error = NULL
-          WHERE bot_slug = ? AND source_event_id = ? AND reason IN ('group-mention', 'group-ordinary')
+          WHERE bot_slug = ? AND source_event_id = ? AND reason IN ('group-mention', 'group-ordinary', 'human-dm')
             AND attempt_state IN ('pending', 'retryable') RETURNING source_event_id`).get(at, at, botSlug, id)) readAdmissions.add(id);
 		}, ["bot-inbox"]);
 	}
@@ -39963,7 +40688,7 @@ var BotRuntimeImplementation = class {
 		this.#database.transaction((database) => database.prepare(`
             UPDATE inbox_admissions
                SET side_effect_started_at = COALESCE(side_effect_started_at, ?)
-             WHERE bot_slug = ? AND reason IN ('assignment-report', 'assignment-lifecycle', 'memory-change', 'group-mention', 'group-ordinary')
+             WHERE bot_slug = ? AND reason IN ('assignment-report', 'assignment-lifecycle', 'memory-change', 'group-mention', 'group-ordinary', 'human-dm')
                AND attempt_state = 'running'
                AND source_event_id IN (${placeholders})
           `).run(this.#now().toISOString(), botSlug, ...sourceEventIds), ["bot-inbox"]);
@@ -39982,7 +40707,7 @@ var BotRuntimeImplementation = class {
                      WHEN side_effect_started_at IS NULL THEN 'retryable'
                      ELSE 'needs-repair'
                    END
-             WHERE reason IN ('assignment-report', 'assignment-lifecycle', 'memory-change', 'group-mention', 'group-ordinary')
+             WHERE reason IN ('assignment-report', 'assignment-lifecycle', 'memory-change', 'group-mention', 'group-ordinary', 'human-dm')
                AND attempt_state IN ('pending', 'retryable', 'running')
                AND (? IS NULL OR bot_slug = ?)
                AND source_event_id IN (${placeholders})
@@ -39994,7 +40719,7 @@ var BotRuntimeImplementation = class {
 		const placeholders = sourceEventIds.map(() => "?").join(", ");
 		this.#database.transaction((database) => database.prepare(`
             UPDATE inbox_admissions SET attempt_state = 'handled', handled_at = ?
-             WHERE reason IN ('assignment-report', 'assignment-lifecycle', 'memory-change', 'group-mention', 'group-ordinary')
+             WHERE reason IN ('assignment-report', 'assignment-lifecycle', 'memory-change', 'group-mention', 'group-ordinary', 'human-dm')
                AND attempt_state = 'running'
                AND (? IS NULL OR bot_slug = ?)
                AND source_event_id IN (${placeholders})
@@ -48176,6 +48901,7 @@ function handleCompactionEvent(sink, sessionId, eventType) {
 	}
 }
 const DEFAULT_AGENT_PRESET = "standard";
+const DEFAULT_MARKETPLACE_URL = "https://market.botharness.ai";
 const DEFAULT_CONFIG = {
 	enabled: true,
 	agentPreset: DEFAULT_AGENT_PRESET
@@ -48183,7 +48909,8 @@ const DEFAULT_CONFIG = {
 const Config = Schema.object({
 	enabled: Schema.boolean().default(DEFAULT_CONFIG.enabled).description("启用 BotHarness core"),
 	activityDetailConsumers: Schema.array(Schema.string()).default([]).description("Explicitly trusted Host Plugin names allowed to read Activity Tool details"),
-	agentPreset: Schema.string().default(DEFAULT_AGENT_PRESET).description("PersonaBot 会话加入的 DSH agent preset（提供 file/Shell/grep 等普通工具）")
+	agentPreset: Schema.string().default(DEFAULT_AGENT_PRESET).description("PersonaBot 会话加入的 DSH agent preset（提供 file/Shell/grep 等普通工具）"),
+	marketplaceUrl: Schema.string().default(DEFAULT_MARKETPLACE_URL).description("Bot Marketplace 服务地址")
 });
 function unavailableAgentAdapter() {
 	const unavailable = () => Promise.reject(/* @__PURE__ */ new Error("BotHarness Agent runtime is unavailable outside a DSH Host"));
@@ -48199,45 +48926,65 @@ function unavailableAgentAdapter() {
 function createCore(options = {}) {
 	const dshHome = options.dshHome ?? resolveDshHome();
 	const rootDir = join(dshHome, "botharness", "bots");
+	const operationalDatabase = mountOperationalDatabase({
+		dshHome,
+		schemaPlan: BOT_HARNESS_SCHEMA_PLAN
+	});
 	let usage;
-	const registry = createPersonaBotRegistry({
-		rootDir,
-		onDisplayNameChanged: () => {
-			try {
-				live?.publishRosterCommitted();
-			} catch {
-				options.warn?.("bot-name-publication-failed");
+	let registry;
+	let modelPresets;
+	let roster;
+	let live;
+	try {
+		registry = createPersonaBotRegistry({
+			rootDir,
+			database: operationalDatabase,
+			onImport: (event) => options.warn?.(`bot-registry-import initiator=host-startup phase=${event.phase} count=${event.count ?? 0} durationMs=${Math.round(event.durationMs)}`),
+			onDisplayNameChanged: () => {
+				try {
+					live?.publishRosterCommitted();
+				} catch {
+					options.warn?.("bot-name-publication-failed");
+				}
+			},
+			onPurge: (slug, removeFiles) => {
+				if (usage === void 0) throw new Error("Usage purge requires a ready operational database");
+				usage.purgeBot(slug, removeFiles);
+			},
+			cloneMemory: (destination, url) => cloneMemoryRepository({
+				destination,
+				url
+			}),
+			initializeMemory: (memoryDir) => {
+				const repository = ensureMemoryRepository({ memoryDir });
+				return repository.ok ? { ok: true } : {
+					ok: false,
+					...repository.code === "git-not-found" ? { code: "git-not-found" } : {},
+					message: `${repository.code}: ${repository.message}`
+				};
 			}
-		},
-		onPurge: (slug, removeFiles) => {
-			if (usage === void 0) throw new Error("Usage purge requires a ready operational database");
-			usage.purgeBot(slug, removeFiles);
-		},
-		cloneMemory: (destination, url) => cloneMemoryRepository({
-			destination,
-			url
-		}),
-		initializeMemory: (memoryDir) => {
-			const repository = ensureMemoryRepository({ memoryDir });
-			return repository.ok ? { ok: true } : {
-				ok: false,
-				...repository.code === "git-not-found" ? { code: "git-not-found" } : {},
-				message: `${repository.code}: ${repository.message}`
-			};
-		}
-	});
-	const modelPresets = createModelPresetStore(join(dshHome, "botharness"));
+		});
+		roster = createRosterStore({
+			database: operationalDatabase,
+			warn: options.warn,
+			onCommitted: () => live?.publishRosterCommitted()
+		});
+		modelPresets = createModelPresetStore({
+			rootDir: join(dshHome, "botharness"),
+			database: operationalDatabase,
+			onImport: (event) => options.warn?.(`model-presets-import initiator=host-startup phase=${event.phase} count=${event.count ?? 0} durationMs=${Math.round(event.durationMs)}`)
+		});
+	} catch (error) {
+		operationalDatabase.close();
+		throw error;
+	}
 	const states = createBotStateTracker();
-	let live;
 	let runtime;
 	const attachments = createAttachmentStore({ rootDir: join(dshHome, "botharness", "attachments") });
-	const operationalDatabase = mountOperationalDatabase({
-		dshHome,
-		schemaPlan: BOT_HARNESS_SCHEMA_PLAN
-	});
 	const sourcePolicy = createBotSourcePolicyStore(attachOperationalModule(operationalDatabase, "bot-inbox"));
 	const externalMessaging = createOutboundMessaging({
 		onDefaultsChanged: () => live?.publishRosterCommitted(),
+		onReceptionChanged: () => live?.publishRosterCommitted(),
 		attachments,
 		database: attachOperationalModule(operationalDatabase, "messaging"),
 		sourcePolicy,
@@ -48302,6 +49049,7 @@ function createCore(options = {}) {
 		const refreshDurableAttention = () => states.replaceDurableAttention(humanAttention.durableAttention().filter((row) => registry.get(row.botSlug) !== void 0));
 		refreshDurableAttention();
 		operationalDatabase.subscribe(({ topics }) => {
+			if (topics.some((topic) => topic === "bindings" || topic === "grants")) live?.publishRosterCommitted();
 			if (topics.some((topic) => [
 				"assignments",
 				"source-event",
@@ -48409,10 +49157,7 @@ function createCore(options = {}) {
 		humanAttentionDecisions,
 		attachments,
 		live,
-		roster: createRosterStore({
-			warn: options.warn,
-			onCommitted: () => live?.publishRosterCommitted()
-		}),
+		roster,
 		runtime
 	};
 }
@@ -48484,6 +49229,7 @@ function apply(ctx, config) {
 	});
 	publishDraft = (event) => core.live.publishDraft(event);
 	ctx.effect(() => () => core.operationalDatabase.close(), "botharness: operational database");
+	ctx.effect(() => () => core.roster.detach(), "botharness: roster");
 	ctx.effect(() => {
 		const controller = new AbortController();
 		if (core.operationalDatabase.mode === "ready") core.channels.migrateAttachments?.(controller.signal).catch(() => {
@@ -48499,7 +49245,8 @@ function apply(ctx, config) {
 		for (const platform of [
 			"feishu",
 			"slack",
-			"discord"
+			"discord",
+			"weixin"
 		]) {
 			const provider = createDshImProvider(child.get("dshIm"), platform);
 			if (provider !== void 0) child.effect(() => core.externalMessaging.register(provider));
@@ -48702,6 +49449,7 @@ function apply(ctx, config) {
 		userQuestions,
 		toolRules: core.toolRules,
 		assignmentAccess: core.assignmentAccess,
+		marketplace: createMarketplaceClient({ baseUrl: config.marketplaceUrl ?? "https://market.botharness.ai" }),
 		developerMode: { set: (enabled) => developerModeTarget.gate?.set(enabled) },
 		computerAccess: { changed: (slug) => {
 			(ctx.get("botharnessComputerTools")?.reconcileBot?.(slug))?.catch((error) => {
@@ -48847,10 +49595,9 @@ function apply(ctx, config) {
 		});
 	}
 	ctx.inject(["storageDomain"], (storageCtx) => {
-		core.roster.attach(storageCtx.storageDomain).catch((error) => {
-			ctx.logger.warn(`botharness: failed to open the roster domain: ${String(error)}`);
+		core.roster.attach(storageCtx.storageDomain).catch(() => {
+			ctx.logger.warn("roster-import initiator=host-startup phase=unavailable arrangement=read-only");
 		});
-		storageCtx.effect(() => () => core.roster.detach(), "botharness: roster domain");
 	});
 	ctx.systemPrompt.section({
 		name: "botharness:persona",