membot 0.7.0 → 0.10.0

package/.claude/skills/membot.md

@@ -64,6 +64,7 @@ membot read <logical_path>                       # current markdown surrogate
 membot read <logical_path> --bytes               # original bytes (base64) — PDF/DOCX/image as ingested
 membot read <logical_path> --version <ts>        # historical snapshot
 membot info <logical_path>                       # metadata only (no content)
+membot stats [prefix]                            # whole-index summary; optional prefix scopes the aggregates
 membot versions <logical_path>                   # every version, newest first
 membot diff <logical_path> --a <ts> [--b <ts>]   # unified diff between versions
 ```
@@ -129,6 +130,7 @@ Tombstones hide a path from `ls` / `tree` / `search` but `versions` and `read --
 | `membot write <path> --content <txt>` | Write inline agent-authored markdown as a new version                          |
 | `membot search <query>`               | Hybrid search (semantic + BM25); add `--include-history` to search older versions |
 | `membot info <path>`                  | Inspect metadata (source, downloader, refresh schedule, digests) without content |
+| `membot stats [prefix]`               | Summarize the index (file/version/chunk/blob counts, on-disk size, refresh health, mime/source/downloader breakdowns); optional prefix scopes |
 | `membot versions <path>`              | List every version newest-first with version_id and change notes               |
 | `membot diff <path> --a <ts>`         | Unified diff between two versions                                              |
 | `membot mv <old> <new>`               | Rename a logical_path (history preserved)                                      |
@@ -161,4 +163,5 @@ Tombstones hide a path from `ls` / `tree` / `search` but `versions` and `read --
 
 - Data lives in `~/.membot/index.duckdb` (override via `MEMBOT_HOME`).
 - Optional `ANTHROPIC_API_KEY` enables LLM fallback for messy/binary input. Without it, conversion degrades to deterministic native output.
+- `embedding.workers` (config key) caps the per-command embed-worker subprocess pool spawned at the top of `add` / `refresh` / `write`. Default `null` resolves to `cpus()-1`; set `1` to disable the pool.
 - Config file: `~/.membot/config.json` (see `membot --help` for the global flags).

package/.cursor/rules/membot.mdc

@@ -64,6 +64,7 @@ membot read <logical_path>                       # current markdown surrogate
 membot read <logical_path> --bytes               # original bytes (base64) — PDF/DOCX/image as ingested
 membot read <logical_path> --version <ts>        # historical snapshot
 membot info <logical_path>                       # metadata only (no content)
+membot stats [prefix]                            # whole-index summary; optional prefix scopes the aggregates
 membot versions <logical_path>                   # every version, newest first
 membot diff <logical_path> --a <ts> [--b <ts>]   # unified diff between versions
 ```
@@ -129,6 +130,7 @@ Tombstones hide a path from `ls` / `tree` / `search` but `versions` and `read --
 | `membot write <path> --content <txt>` | Write inline agent-authored markdown as a new version                          |
 | `membot search <query>`               | Hybrid search (semantic + BM25); add `--include-history` to search older versions |
 | `membot info <path>`                  | Inspect metadata (source, downloader, refresh schedule, digests) without content |
+| `membot stats [prefix]`               | Summarize the index (file/version/chunk/blob counts, on-disk size, refresh health, mime/source/downloader breakdowns); optional prefix scopes |
 | `membot versions <path>`              | List every version newest-first with version_id and change notes               |
 | `membot diff <path> --a <ts>`         | Unified diff between two versions                                              |
 | `membot mv <old> <new>`               | Rename a logical_path (history preserved)                                      |
@@ -161,4 +163,5 @@ Tombstones hide a path from `ls` / `tree` / `search` but `versions` and `read --
 
 - Data lives in `~/.membot/index.duckdb` (override via `MEMBOT_HOME`).
 - Optional `ANTHROPIC_API_KEY` enables LLM fallback for messy/binary input. Without it, conversion degrades to deterministic native output.
+- `embedding.workers` (config key) caps the per-command embed-worker subprocess pool spawned at the top of `add` / `refresh` / `write`. Default `null` resolves to `cpus()-1`; set `1` to disable the pool.
 - Config file: `~/.membot/config.json` (see `membot --help` for the global flags).

package/README.md

@@ -10,6 +10,7 @@
 - **Local everything** — embeddings run on your machine; data lives in `~/.membot/index.duckdb`.
 - **One mental model** — every artifact (markdown, PDF, image, audio) becomes a markdown surrogate that flows through the same chunk → embed → search pipeline.
 - **Append-only versioning** — every ingest, refresh, or write creates a new `(logical_path, version_id)` row. History is queryable; nothing is mutated.
+- **Parallel ingest** — directory/glob ingests run a worker pool (default `cpus - 1`, max 8) with a `Bun.Worker` per slot for the WASM embed step, so a `~/notes/**/*.md` import actually uses your cores. The TTY shows one status line per active worker plus an ETA and a running chunk total.
 - **Two surfaces, one source of truth** — every operation is exposed identically as a CLI subcommand and an MCP tool. The agent sees `membot_search`; you see `membot search`.
 
 ## Install
@@ -83,6 +84,7 @@ The skill files describe the discover → ingest → search → read → write w
 | `membot read <path>`            | Read the markdown surrogate (or `--bytes` for original bytes, base64)             |
 | `membot search <query>`         | Hybrid search (semantic + BM25); `--include-history` searches older versions      |
 | `membot info <path>`            | Inspect metadata (source, fetcher, schedule, digests) without content             |
+| `membot stats [prefix]`         | Summarize the index (file/version/chunk/blob counts, on-disk size, refresh health, mime/source/downloader breakdowns); optional prefix scopes the aggregates |
 | `membot versions <path>`        | List every version newest-first                                                   |
 | `membot diff <path> <a> [b]`    | Unified diff between two versions                                                 |
 | `membot write <path>`           | Write inline agent-authored markdown as a new version                             |
@@ -136,12 +138,17 @@ Add `--watch` (and optional `--tick <sec>`) to also run the refresh daemon, whic
   membot config list                                            # show every value (secrets masked)
   membot config set llm.anthropic_api_key sk-ant-...            # enable LLM-fallback paths
   membot config set chunker.target_chars 800                    # tweak any nested value
+  membot config set embedding.workers 4                         # cap parallel embed workers
   membot config set converters.max_inline_image_captions 50     # raise per-doc cap on vision captions for embedded images
+  membot config set ingest.worker_concurrency 4                 # cap parallel ingest workers (default: cpus-1, max 8)
+  membot config set llm.describer_skip_when_titled false        # always LLM-describe (default true skips when markdown has a clear H1)
   membot config get llm.anthropic_api_key --show-secrets        # reveal the masked key
   membot config unset chunker.target_chars                      # back to schema default
   membot config path                                            # print the absolute config path
   ```
 
+  **Parallel embedding:** `embedding.workers` (default `null` → `cpus()-1`) controls how many subprocess workers fan out the WASM embedding work. The pool is **per-command** — spawned at the start of `add` / `refresh` / `write` and killed before the command returns, so membot doesn't keep idle workers around between invocations. Each worker loads its own ~50MB copy of the model, so on RAM-constrained machines drop it to a small fixed number (e.g. `4`); set `1` to disable the pool entirely and embed inline.
+
   Values are written with file mode `0600`. `ANTHROPIC_API_KEY` set in the environment still wins on read, so existing env-var setups keep working.
 - **Browser session:** `~/.membot/auth/browser-profile/` (Playwright persistent profile — cookies, localStorage, IndexedDB). Captured by `membot login`; cookie-based downloaders (Google) reuse it on every fetch. Delete the directory to force a fresh login.
 - **API keys:** stored under `downloaders.<service>.api_key` in `~/.membot/config.json`. Read by API-based downloaders (GitHub, Linear).

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "membot",
-	"version": "0.7.0",
+	"version": "0.10.0",
 	"description": "Versioned context store with hybrid search for AI agents. Stdio + HTTP MCP server and CLI.",
 	"type": "module",
 	"exports": {

package/src/cli.ts

@@ -10,12 +10,23 @@ import { registerReindexCommand } from "./commands/reindex.ts";
 import { registerServeCommand } from "./commands/serve.ts";
 import { registerSkillCommand } from "./commands/skill.ts";
 import { registerUpgradeCommand } from "./commands/upgrade.ts";
+import { EMBED_WORKER_SENTINEL } from "./constants.ts";
 import type { BuildContextOptions } from "./context.ts";
+import { runEmbedWorker } from "./ingest/embed-worker.ts";
 import { mountAsCommanderCommand } from "./mount/commander.ts";
 import { OPERATIONS } from "./operations/index.ts";
 import { logger } from "./output/logger.ts";
 import { maybeCheckForUpdate } from "./update/background.ts";
 
+// Hidden worker mode: the EmbedderPool re-execs this binary with the sentinel
+// as argv[2] (or argv[1] when `bun run src/cli.ts <sentinel>` is invoked
+// directly during tests). We bypass commander entirely and run the worker
+// stdin/stdout protocol loop instead.
+if (process.argv.includes(EMBED_WORKER_SENTINEL)) {
+	await runEmbedWorker();
+	process.exit(0);
+}
+
 program
 	.name("membot")
 	.description("Versioned context store with hybrid search for AI agents. Stdio + HTTP MCP server and CLI.")

package/src/config/schemas.ts

@@ -1,6 +1,18 @@
+import { availableParallelism } from "node:os";
 import { z } from "zod";
 import { DEFAULTS, defaultMembotHome, EMBEDDING_DIMENSION, EMBEDDING_MODEL } from "../constants.ts";
 
+/**
+ * Compute the default ingest worker count: one fewer than the available CPUs
+ * (so the orchestrator and any background work still has a core), clamped to
+ * `[1, MAX_WORKERS]` to avoid hammering Anthropic with too many concurrent
+ * describe calls on machines with very high core counts.
+ */
+function defaultWorkerConcurrency(): number {
+	const cpus = availableParallelism();
+	return Math.min(DEFAULTS.MAX_WORKERS, Math.max(1, cpus - 1));
+}
+
 export const ChunkerConfigSchema = z.object({
 	mode: z.enum(["deterministic", "llm"]).default(DEFAULTS.CHUNKER_MODE),
 	target_chars: z.number().int().positive().default(DEFAULTS.CHUNKER_TARGET_CHARS),
@@ -17,12 +29,29 @@ export const LlmConfigSchema = z.object({
 	chunker_model: z.string().default(DEFAULTS.CHUNKER_MODEL),
 	describer_model: z.string().default(DEFAULTS.DESCRIBER_MODEL),
 	vision_model: z.string().default(DEFAULTS.VISION_MODEL),
+	describer_skip_when_titled: z.boolean().default(DEFAULTS.DESCRIBER_SKIP_WHEN_TITLED),
+});
+
+export const IngestConfigSchema = z.object({
+	worker_concurrency: z.number().int().positive().default(defaultWorkerConcurrency),
 });
 
 export const DaemonConfigSchema = z.object({
 	tick_interval_sec: z.number().int().positive().default(DEFAULTS.DAEMON_TICK_SEC),
 });
 
+/**
+ * Embedding parallelism. `workers = null` (the default) resolves to
+ * `max(1, cpus()-1)` at context-build time so the pool grows with the host
+ * machine. Setting `workers = 1` disables the subprocess pool entirely
+ * and runs embedding inline in the parent (the original single-thread
+ * behaviour). Each worker loads its own copy of the WASM model
+ * (~50MB resident), so cap this on RAM-constrained machines.
+ */
+export const EmbeddingConfigSchema = z.object({
+	workers: z.number().int().min(1).nullable().default(null),
+});
+
 export const LinearDownloaderConfigSchema = z.object({
 	api_key: z.string().meta({ secret: true }).default(""),
 });
@@ -47,7 +76,9 @@ export const MembotConfigSchema = z.object({
 	embedding_model: z.string().default(EMBEDDING_MODEL),
 	embedding_dimension: z.number().int().positive().default(EMBEDDING_DIMENSION),
 	chunker: ChunkerConfigSchema.default(() => ChunkerConfigSchema.parse({})),
+	embedding: EmbeddingConfigSchema.default(() => EmbeddingConfigSchema.parse({})),
 	converters: ConvertersConfigSchema.default(() => ConvertersConfigSchema.parse({})),
+	ingest: IngestConfigSchema.default(() => IngestConfigSchema.parse({})),
 	llm: LlmConfigSchema.default(() => LlmConfigSchema.parse({})),
 	downloaders: DownloadersConfigSchema.default(() => DownloadersConfigSchema.parse({})),
 	daemon: DaemonConfigSchema.default(() => DaemonConfigSchema.parse({})),
@@ -57,7 +88,9 @@ export const MembotConfigSchema = z.object({
 
 export type MembotConfig = z.infer<typeof MembotConfigSchema>;
 export type ChunkerConfig = z.infer<typeof ChunkerConfigSchema>;
+export type EmbeddingConfig = z.infer<typeof EmbeddingConfigSchema>;
 export type ConvertersConfig = z.infer<typeof ConvertersConfigSchema>;
+export type IngestConfig = z.infer<typeof IngestConfigSchema>;
 export type LlmConfig = z.infer<typeof LlmConfigSchema>;
 export type DownloadersConfig = z.infer<typeof DownloadersConfigSchema>;
 export type LinearDownloaderConfig = z.infer<typeof LinearDownloaderConfigSchema>;

package/src/constants.ts

@@ -28,6 +28,14 @@ export const EMBEDDING_DIMENSION = 384;
  */
 export const EMBEDDING_BATCH_SIZE = 16;
 
+/**
+ * Hidden first-arg sentinel that re-execs the membot binary as an embed
+ * worker. The pool spawns `process.execPath <sentinel>` so the same compiled
+ * binary serves both the user-facing CLI and the worker subprocess; cli.ts
+ * checks this argv slot before commander sees it.
+ */
+export const EMBED_WORKER_SENTINEL = "__embed_worker";
+
 export const DEFAULTS = {
 	CHUNKER_MODE: "deterministic" as const,
 	CHUNKER_TARGET_CHARS: 4_000,
@@ -47,6 +55,21 @@ export const DEFAULTS = {
 	 * embedded images doesn't fan out into hundreds of vision requests.
 	 */
 	MAX_INLINE_IMAGE_CAPTIONS: 20,
+	/**
+	 * Hard cap for `ingest.worker_concurrency`. The runtime default is
+	 * `cpus - 1` so machines with very high core counts can scale, but we
+	 * clamp here to keep concurrent Anthropic describe calls (and per-worker
+	 * WASM embedder allocations — each pipeline holds the model weights) from
+	 * spiraling out of control.
+	 */
+	MAX_WORKERS: 8,
+	/**
+	 * When true, describe() skips the LLM for self-describing markdown/text
+	 * (a clear H1 within the first 40 lines of body) and uses the heading +
+	 * 200-char prefix instead. Avoids paying for an LLM round-trip when the
+	 * file already has a human-written description.
+	 */
+	DESCRIBER_SKIP_WHEN_TITLED: true,
 } as const;
 
 export const FILES = {

package/src/context.ts

@@ -1,3 +1,4 @@
+import { cpus } from "node:os";
 import { join } from "node:path";
 import { loadConfig } from "./config/loader.ts";
 import type { MembotConfig } from "./config/schemas.ts";
@@ -25,11 +26,34 @@ export interface BuildContextOptions {
 	noInteractive?: boolean;
 }
 
+/**
+ * Resolve `config.embedding.workers` to a concrete worker count. Precedence:
+ *   1. An explicit numeric value in the config wins (user opt-in).
+ *   2. `MEMBOT_EMBEDDING_WORKERS` env var, if set to a positive integer.
+ *      The test harness sets this to `1` so unit tests doing tiny writes
+ *      don't pay the per-pool subprocess-spawn cost on slow CI runners.
+ *   3. Otherwise `null`/missing → `max(1, cpus()-1)`. The minus-one leaves
+ *      a core for the parent process (DB writes, IO, the spinner).
+ */
+export function resolveEmbeddingWorkers(configured: number | null | undefined): number {
+	if (typeof configured === "number" && configured >= 1) return configured;
+	const envOverride = process.env.MEMBOT_EMBEDDING_WORKERS;
+	if (envOverride) {
+		const n = Number(envOverride);
+		if (Number.isFinite(n) && n >= 1) return Math.floor(n);
+	}
+	return Math.max(1, cpus().length - 1);
+}
+
 /**
  * Build the AppContext used by every operation handler. Initializes:
  *  - output mode (TTY/JSON/color detection — frozen for the rest of the run)
  *  - config (~/.membot/config.json with env overrides)
  *  - DuckDB connection (~/.membot/index.duckdb), running migrations on first open
+ *
+ * The embedder worker pool is NOT created here — it's per-command,
+ * spawned by `withEmbedderPool()` at the top of bulk-embedding handlers
+ * (`add`, `refresh`, `write`) and disposed before they return.
  */
 export async function buildContext(options: BuildContextOptions = {}): Promise<AppContext> {
 	setMode(detectMode({ json: options.json, verbose: options.verbose, noColor: options.noColor }));

package/src/ingest/concurrency.ts

@@ -0,0 +1,60 @@
+/**
+ * Run `worker(item, index, workerId)` over `items` with at most `concurrency`
+ * workers in flight at a time. Each runner has a stable `workerId` in
+ * `[0, concurrency)` for the life of the call — useful when callers want to
+ * address per-worker UI slots. Results come back in input order. Worker
+ * rejections are caught and surfaced as `{ ok: false, error }` entries
+ * instead of aborting the batch; partial failures are normal during bulk
+ * ingest, and the caller decides how to render them per-entry.
+ */
+export async function pMap<T, R>(
+	items: readonly T[],
+	concurrency: number,
+	worker: (item: T, index: number, workerId: number) => Promise<R>,
+): Promise<Array<{ ok: true; value: R } | { ok: false; error: unknown }>> {
+	const limit = Math.max(1, Math.floor(concurrency));
+	const results: Array<{ ok: true; value: R } | { ok: false; error: unknown }> = new Array(items.length);
+	let next = 0;
+
+	const runOne = async (workerId: number): Promise<void> => {
+		while (true) {
+			const i = next++;
+			if (i >= items.length) return;
+			const item = items[i] as T;
+			try {
+				const value = await worker(item, i, workerId);
+				results[i] = { ok: true, value };
+			} catch (error) {
+				results[i] = { ok: false, error };
+			}
+		}
+	};
+
+	const runners = Array.from({ length: Math.min(limit, items.length) }, (_, workerId) => runOne(workerId));
+	await Promise.all(runners);
+	return results;
+}
+
+/**
+ * Single-slot async mutex. `lock(fn)` runs `fn` with exclusive access and
+ * returns its result; queued callers run in FIFO order. Used to gate the
+ * persist phase of bulk ingest because all workers share a single DuckDB
+ * connection and DuckDB rejects nested `BEGIN` statements.
+ */
+export class AsyncMutex {
+	private chain: Promise<void> = Promise.resolve();
+
+	async lock<T>(fn: () => Promise<T>): Promise<T> {
+		const prev = this.chain;
+		let release!: () => void;
+		this.chain = new Promise<void>((r) => {
+			release = r;
+		});
+		await prev;
+		try {
+			return await fn();
+		} finally {
+			release();
+		}
+	}
+}

package/src/ingest/describer.ts

@@ -13,9 +13,12 @@ Rules:
 
 /**
  * Generate a one-paragraph description for the file's surrogate, used
- * as the `<description>` line in chunks.search_text. Falls back to a
- * deterministic heuristic when no API key is configured so the pipeline
- * still produces a non-empty description offline.
+ * as the `<description>` line in chunks.search_text. When the file is
+ * self-describing (markdown/text with a clear H1 in the opening) and the
+ * `describer_skip_when_titled` flag is on, returns the title-derived
+ * description without calling the LLM. Falls back to a deterministic
+ * heuristic when no API key is configured so the pipeline still produces
+ * a non-empty description offline.
  */
 export async function describe(
 	logicalPath: string,
@@ -23,6 +26,13 @@ export async function describe(
 	surrogate: string,
 	llm: LlmConfig,
 ): Promise<string> {
+	if (llm.describer_skip_when_titled) {
+		const titled = tryTitleDescription(mimeType, surrogate);
+		if (titled) {
+			logger.debug(`describer: using title-derived description for ${logicalPath}`);
+			return titled;
+		}
+	}
 	if (!llm.anthropic_api_key || llm.anthropic_api_key.trim() === "") {
 		return deterministicDescription(logicalPath, mimeType, surrogate);
 	}
@@ -52,6 +62,42 @@ export async function describe(
 	}
 }
 
+const TEXTUAL_MIMES = new Set(["application/json", "application/yaml", "application/x-yaml"]);
+
+/**
+ * Returns a title-derived description when the surrogate is "self-describing"
+ * markdown/text — a clear H1 within the first 40 non-blank lines, of
+ * reasonable length. Returns null otherwise so the caller falls through to
+ * the LLM. Skipping the LLM for files that already have a human-written
+ * heading is the main throughput win during bulk ingest.
+ */
+export function tryTitleDescription(mimeType: string, surrogate: string): string | null {
+	if (!mimeType.startsWith("text/") && !TEXTUAL_MIMES.has(mimeType)) return null;
+	const lines = surrogate.split(/\r?\n/);
+	let nonBlank = 0;
+	let heading: string | null = null;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		nonBlank += 1;
+		if (nonBlank > 40) break;
+		const m = trimmed.match(/^#\s+(.+?)\s*#*$/);
+		if (m?.[1]) {
+			heading = m[1].trim();
+			break;
+		}
+	}
+	if (!heading) return null;
+	if (heading.length < 5 || heading.length > 200) return null;
+	const body = surrogate
+		.replace(/^#\s+.+$/m, "")
+		.trim()
+		.slice(0, 200)
+		.replace(/\s+/g, " ")
+		.trim();
+	return body ? `${heading} — ${body}` : heading;
+}
+
 /**
  * Cheap, deterministic description used when the LLM isn't available.
  * For markdown/text it's the first heading + a 200-char prefix; for

package/src/ingest/embed-worker.ts

@@ -0,0 +1,74 @@
+import { createInterface } from "node:readline";
+import { asHelpful, isHelpfulError } from "../errors.ts";
+import { embed } from "./embedder.ts";
+
+/**
+ * Wire-format message exchanged between the parent EmbedderPool and a worker
+ * subprocess over the worker's stdin/stdout. Each message is a single JSON
+ * object terminated by `\n` — a robust, language-agnostic encoding that
+ * survives partial reads on either end. There is no init/ready handshake;
+ * the worker lazy-loads the WASM pipeline on its first `embed` request.
+ */
+interface EmbedRequest {
+	type: "embed";
+	id: number;
+	model: string;
+	texts: string[];
+}
+
+interface EmbedResponse {
+	type: "embed-response";
+	id: number;
+	vectors?: number[][];
+	error?: { kind: string; message: string; hint: string };
+}
+
+/** Atomic JSON-line write to stdout — the protocol channel back to the parent. */
+function send(msg: EmbedResponse): void {
+	process.stdout.write(`${JSON.stringify(msg)}\n`);
+}
+
+/**
+ * Drive the embed-worker subprocess: read newline-delimited JSON requests
+ * from stdin, dispatch them to the local `embed()` (which uses the WASM
+ * pipeline), and write JSON responses to stdout. Diagnostics (logger output)
+ * go to stderr, so the protocol channel on stdout stays clean.
+ *
+ * The worker exits naturally when stdin closes (parent died or sent EOF).
+ */
+export async function runEmbedWorker(): Promise<void> {
+	const rl = createInterface({ input: process.stdin, crlfDelay: Number.POSITIVE_INFINITY });
+	for await (const line of rl) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		let req: EmbedRequest;
+		try {
+			req = JSON.parse(trimmed) as EmbedRequest;
+		} catch {
+			// A malformed line on stdin is almost certainly a bug in the parent —
+			// log to stderr and keep the worker alive so the parent's other
+			// requests still get served.
+			process.stderr.write(`embed-worker: ignoring malformed stdin line: ${trimmed.slice(0, 200)}\n`);
+			continue;
+		}
+		if (req.type !== "embed") continue;
+		await handleEmbed(req);
+	}
+}
+
+/** Run one embed request and reply with vectors or a serialisable error. */
+async function handleEmbed(req: EmbedRequest): Promise<void> {
+	try {
+		const vectors = await embed(req.texts, req.model);
+		send({ type: "embed-response", id: req.id, vectors });
+	} catch (err) {
+		const helpful = isHelpfulError(err)
+			? err
+			: asHelpful(err, "in embed worker", "Inspect the parent process stderr for the full stack trace.");
+		send({
+			type: "embed-response",
+			id: req.id,
+			error: { kind: helpful.kind, message: helpful.message, hint: helpful.hint },
+		});
+	}
+}