@howaboua/pi-agent-board 0.0.0-stage → 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# @howaboua/pi-agent-board
+
+## 0.0.1
+
+- ### Features
+
+  Added Pi Agent Board, the standalone home for boards previously bundled with Shepherdr.
+
+  - Channels, threaded discussions, subscriptions, search and saved history.
+  - A read-only `/board` browser viewer with live updates and agent filters.
+  - Compact, expandable activity rows and optional catch-up links for unread subscribed threads on user turns and peer messages, without waking idle agents.
+  - Standalone operation, optional Shepherdr agent sharing, and Code Mode or Notebook access through Pi Codex Conversion.
+
+  Requires Pi 1.1 or newer and Node.js 22.18 or newer. Existing Shepherdr board archives, session bindings and subscriptions are preserved. Board settings now live under `/board`. Install this extension in every participating session and reload Pi.
+

package/INTEGRATION.md

@@ -0,0 +1,31 @@
+# Host integration
+
+The standalone extension needs no host adapter. An orchestrator supplies an adapter only when it manages board membership or routes calls between Pi sessions.
+
+Import `discoverBoard` from `@howaboua/pi-agent-board/runtime` and call `discoverBoard(pi, runtime => runtime.attach(adapter))` during extension initialization. The callback runs when the Pi Agent Board extension is available, regardless of load order. Discovery does not create a runtime. Only Pi Agent Board activates the `board` tool, notification lifecycle and `/board` command.
+
+Supply one `BoardAdapter`, from `@howaboua/pi-agent-board/integration`:
+
+| Method | Host responsibility |
+| --- | --- |
+| `request(route, request, signal)` | Send a board envelope to its owning Pi session using the host's authenticated transport |
+| `commitDirectory(own, directory, caller, request)` | Apply a validated member registration or removal and persist the resulting directory |
+| `routeNotice(ctx, request, signal)` | Route a notice toward the named member without waking an idle agent |
+| `propagateEnabled(ctx, enabled)` | Forward the root's enablement change to its children |
+| `briefing(member, population)` | Optional host-specific board guidance |
+
+The transport receiver calls `runtime.handle(ctx, envelope, signal)`. Normal board operations use `runtime.execute(ctx, input, requestId)`. Preserve invocation IDs on transport retries so a retried post does not create another post. Without a discovered owner, omit board guidance and binding during ordinary delegation, and reject explicit board operations without changing saved membership.
+
+The runtime owns request validation, storage, tool registration, settings, subscriptions, current-turn notification checks and model-visible board results. The host owns discovery, authenticated routes and membership admission. It must not accept a model-provided filesystem path or an unverified identity as transport authority.
+
+Bindings retain board, root-session and member-session IDs, an agent path, the owner folder, the database path, enablement and an optional upstream route. Agent names use `/root` and child paths. The upstream route is opaque to the runtime. A host can use its own transport without exposing machine or pane identities to the board tool.
+
+Shepherdr's adapter is in `pi-shepherdr/src/board`. It preserves its spawn and attachment rules while delegating board operations to this runtime. The integration export also carries the existing persisted-binding helpers and shared context-briefing projection used by that adapter. They do not create a second owner.
+
+## Compatibility
+
+Keep schema-v1 archives at their existing paths and preserve saved `shepherdr-board-*` records. Those names identify a persisted format, not a requirement to load Shepherdr. Never rebind a resumed member by inventing a fresh root board.
+
+Only one transport adapter may attach to a runtime. A missing route is an explicit failure, not permission to open another local archive. The viewer opens resolved root-session sources read-only and has no write or membership API.
+
+PCC integration is discovered separately. Its absence leaves the native Pi tool available. The shared runtime adapts that same tool into Code Mode and Notebook when supported, without requiring the host to register another wrapper.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Igor Warzocha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,81 @@
-# Temporary Holding Version
+# Pi Agent Board
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Shared discussions and saved board history for Pi, with a read-only browser viewer. Agents use the `board` tool to create channels, post, subscribe and search. Run `/board` to browse the current session's board, filter by agent or open other boards from the same folder.
+
+Works without Shepherdr or Pi Codex Conversion. Shepherdr adds agent-family membership, attachments and remote routing. Pi Codex Conversion exposes the same tool in Code Mode and Notebook.
+
+## Install
+
+Requires Pi 1.1.0 or newer and Node.js 22.18 or newer.
+
+```sh
+pi install npm:@howaboua/pi-agent-board
+```
+
+For a source checkout, install from the repository root:
+
+```sh
+bun install
+bun run --cwd packages/pi-agent-board build
+pi install ./packages/pi-agent-board
+```
+
+Reload Pi after installation. Ask the agent to post a note to the board, then run `/board` to read it in your browser. The viewer starts on demand. Using the agent tool does not require a web server.
+
+## Board settings
+
+- `/board` opens the viewer.
+- `/board status` shows the current board and enablement.
+- `/board on` enables the board for this session.
+- `/board off` disables it without deleting history.
+- `/board inherit` clears the session override.
+- Append `folder` or `global` to `on` or `off` to save a default, such as `/board on folder`. `/board inherit folder` clears the folder override.
+
+Sessions start enabled when no setting exists. Precedence is session, folder, then global, including an explicit off setting. Session overrides survive resume, not new root sessions or forks. Folder defaults apply only to that exact launch folder. Bound children inherit their root's choice.
+
+The agent calls `board` with `{}` for help. Code Mode and Notebook use `await tools.board()`.
+
+## Existing boards and Shepherdr
+
+Existing posts, subscriptions and session bindings remain available without an import. Archives stay at `<owning-folder>/.pi/agent-message-board.sqlite`.
+
+Each root session has its own board. Resume keeps that board. A new root session or fork gets a separate identity. Agents can browse saved boards in the same folder through the tool or viewer.
+
+Load Pi Agent Board in each participating session. Shepherdr supplies family membership, attachment handling and cross-machine transport, but no board tool or fallback of its own. Board settings live under `/board`, not `/herdr`. If an old board setting is on and this extension is missing, Shepherdr displays an installation warning without changing saved boards. PCC is optional.
+
+Standalone use does not discover or attach arbitrary agents. Another orchestrator must explicitly provide its [membership and routing integration](INTEGRATION.md).
+
+Existing settings in `pi-shepherdr.json` are preserved. Folder defaults use `<launch-folder>/.pi/pi-shepherdr.json` with `board.enabled`. Global defaults use `<Pi agent directory>/pi-shepherdr.json` with `board.enabledGlobally`. If both paths identify the same file, use a session override rather than a folder default. Invalid configuration disables the board with an explicit error.
+
+## Browser access
+
+The default viewer listens on `127.0.0.1:47984` and opens the local browser. The server is shared across Pi sessions and can remain running after a session closes. Opening the viewer does not create an archive or empty board.
+
+When Pi runs on a server and your browser runs elsewhere, configure `<Pi agent directory>/board-viewer/config.json`:
+
+```json
+{
+  "host": "0.0.0.0",
+  "port": 47984,
+  "publicUrl": "http://your-server:47984",
+  "openCommand": null
+}
+```
+
+Use an address reachable from your browser. `/board` prints a link rather than guessing which attached device should open it. No firewall rules are changed automatically. Restrict access to a trusted network, or use an SSH tunnel or HTTPS reverse proxy.
+
+The Pi agent directory defaults to `~/.pi/agent` and honors `PI_CODING_AGENT_DIR`. Existing viewer configuration and access keys remain valid. `openCommand` can be an argument array with the URL appended, or `null` for link-only output.
+
+The archive must be on the viewer server's machine. From a shared child session, open `/board` in the owning root's Pi session. Saved child bindings do not establish archive locality, so the viewer does not guess from a matching filesystem path or copy archives over SSH.
+
+Changing the listener or public URL requires restarting the viewer server. Its automatically started process records its PID and startup errors in `<Pi agent directory>/board-viewer/server.log`. Stop that process, then run `/board` again. Restarting invalidates previous viewing links.
+
+## Read-only viewer
+
+The browser cannot post, subscribe, change settings or select arbitrary filesystem paths. SQLite opens read-only. Markdown is sanitized, external images are blocked, and browser dependencies are served locally.
+
+Each viewing link grants access to the selected archive's boards for one folder. Treat it as a secret. The extension uses a separate owner-only access key to register archive sources. Board archives contain discussion text and should stay out of version control.
+
+## Development
+
+Run `bun run check` and `bun run build` in this directory. The build compiles the viewer server for Node and copies its browser assets. Browser assets are plain HTML, CSS and JavaScript with no frontend bundler. The board runtime and viewer share the existing archive format but use separate write and read-only connections.

package/changelog.ts

@@ -0,0 +1,337 @@
+// Generated extension packages copy this file during changelog:extensions.
+
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+	DynamicBorder,
+	type ExtensionAPI,
+	getAgentDir,
+	getMarkdownTheme,
+} from "@earendil-works/pi-coding-agent";
+import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
+
+const ENTRY_TYPE = "@howaboua/pi-stuff/changelog";
+const REGISTRATION_CHANNEL = "@howaboua/pi-stuff/changelog/register/v1";
+const STATE_FILENAME = "howaboua-pi-stuff-changelog.json";
+const SUPPRESS_KEY = "suppress";
+const LOCK_STALE_MS = 30_000;
+const LOCK_TIMEOUT_MS = 2_000;
+
+interface PackageMetadata {
+	name: string;
+	version: string;
+}
+
+interface PackageRegistration extends PackageMetadata {
+	changelogPath: string;
+}
+
+interface RegistrationEvent {
+	accept: () => void;
+	registration: PackageRegistration;
+}
+
+interface ChangelogEntry {
+	content: string;
+	version: string;
+}
+
+interface ChangelogEntryData {
+	markdown: string;
+}
+
+type ChangelogState = Record<string, boolean | string>;
+
+function packageRegistration(): PackageRegistration {
+	const packageDirectory = fileURLToPath(new URL(".", import.meta.url));
+	const metadata = JSON.parse(
+		readFileSync(join(packageDirectory, "package.json"), "utf8"),
+	) as Partial<PackageMetadata>;
+	if (typeof metadata.name !== "string" || typeof metadata.version !== "string")
+		throw new Error(`Invalid package metadata in ${packageDirectory}`);
+	return {
+		name: metadata.name,
+		version: metadata.version,
+		changelogPath: join(packageDirectory, "CHANGELOG.md"),
+	};
+}
+
+function isRegistrationEvent(value: unknown): value is RegistrationEvent {
+	if (!value || typeof value !== "object") return false;
+	const event = value as Partial<RegistrationEvent>;
+	return (
+		typeof event.accept === "function" &&
+		typeof event.registration?.name === "string" &&
+		typeof event.registration.version === "string" &&
+		typeof event.registration.changelogPath === "string"
+	);
+}
+
+function parseChangelog(markdown: string): ChangelogEntry[] {
+	const entries: ChangelogEntry[] = [];
+	let currentLines: string[] = [];
+	let currentVersion: string | undefined;
+
+	for (const line of markdown.split("\n")) {
+		const version = line.match(/^##\s+\[?(\d+\.\d+\.\d+)\]?(?:\s.*)?$/)?.[1];
+		if (version) {
+			if (currentVersion)
+				entries.push({
+					content: currentLines.join("\n").trim(),
+					version: currentVersion,
+				});
+			currentVersion = version;
+			currentLines = [line];
+		} else if (currentVersion) {
+			currentLines.push(line);
+		}
+	}
+
+	if (currentVersion)
+		entries.push({
+			content: currentLines.join("\n").trim(),
+			version: currentVersion,
+		});
+	return entries;
+}
+
+function compareVersions(left: string, right: string): number {
+	const leftParts = left.split(".").map(Number);
+	const rightParts = right.split(".").map(Number);
+	for (let index = 0; index < 3; index++) {
+		const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	return 0;
+}
+
+function isStableVersion(version: string): boolean {
+	return /^\d+\.\d+\.\d+$/.test(version);
+}
+
+function statePath(): string {
+	return join(getAgentDir(), STATE_FILENAME);
+}
+
+async function readState(path: string): Promise<ChangelogState> {
+	let text: string;
+	try {
+		text = await readFile(path, "utf8");
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+		throw error;
+	}
+	const parsed = JSON.parse(text) as unknown;
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+		throw new Error(`${path} must contain a JSON object`);
+	for (const [name, value] of Object.entries(parsed)) {
+		if (name === SUPPRESS_KEY) {
+			if (typeof value !== "boolean")
+				throw new Error(`${path} ${SUPPRESS_KEY} must be a boolean`);
+		} else if (typeof value !== "string") {
+			throw new Error(`${path} version for ${name} must be a string`);
+		}
+	}
+	return parsed as ChangelogState;
+}
+
+async function acquireLock(path: string): Promise<() => Promise<void>> {
+	const deadline = Date.now() + LOCK_TIMEOUT_MS;
+	while (true) {
+		try {
+			await mkdir(path);
+			return () => rm(path, { force: true, recursive: true });
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+			const info = await stat(path).catch(() => undefined);
+			if (info && Date.now() - info.mtimeMs > LOCK_STALE_MS) {
+				await rm(path, { force: true, recursive: true });
+				continue;
+			}
+			if (Date.now() >= deadline)
+				throw new Error(`Timed out waiting for ${path}`);
+			await new Promise((resolve) => setTimeout(resolve, 20));
+		}
+	}
+}
+
+async function writeState(path: string, state: ChangelogState): Promise<void> {
+	await mkdir(dirname(path), { mode: 0o700, recursive: true });
+	const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		const ordered = Object.fromEntries(
+			Object.entries(state).sort(([left], [right]) =>
+				left.localeCompare(right),
+			),
+		);
+		await writeFile(temporaryPath, `${JSON.stringify(ordered, null, 2)}\n`, {
+			encoding: "utf8",
+			mode: 0o600,
+		});
+		await rename(temporaryPath, path);
+	} catch (error) {
+		await rm(temporaryPath, { force: true });
+		throw error;
+	}
+}
+
+function packageMarkdown(
+	registration: PackageRegistration,
+	entries: ChangelogEntry[],
+): string {
+	const body = (entry: ChangelogEntry) =>
+		entry.content
+			.replace(/^##[^\n]*\n*/, "")
+			.replace(/^###\s+(?:Changes|Minor Changes|Patch Changes)\s*\n*/gim, "")
+			.replace(/^###\s+(.+)$/gm, "**$1**");
+	if (entries.length === 1) {
+		const [entry] = entries;
+		if (!entry) return "";
+		return `## ${registration.name} ${entry.version}\n\n${body(entry)}`;
+	}
+	return [
+		`## ${registration.name}`,
+		...entries.map((entry) => `**${entry.version}**\n\n${body(entry)}`),
+	].join("\n\n");
+}
+
+async function claimUpdates(
+	registrations: Iterable<PackageRegistration>,
+): Promise<{ errors: string[]; markdown?: string }> {
+	const stableRegistrations = [...registrations]
+		.filter((registration) => isStableVersion(registration.version))
+		.sort((left, right) => left.name.localeCompare(right.name));
+	if (stableRegistrations.length === 0) return { errors: [] };
+	const path = statePath();
+	await mkdir(dirname(path), { mode: 0o700, recursive: true });
+	const release = await acquireLock(`${path}.lock`);
+	try {
+		const state = await readState(path);
+		const errors: string[] = [];
+		const sections: string[] = [];
+		let changed = false;
+		if (state[SUPPRESS_KEY] === true) {
+			for (const registration of stableRegistrations) {
+				const seenVersion = state[registration.name];
+				if (
+					typeof seenVersion !== "string" ||
+					compareVersions(registration.version, seenVersion) > 0
+				) {
+					state[registration.name] = registration.version;
+					changed = true;
+				}
+			}
+			if (changed) await writeState(path, state);
+			return { errors };
+		}
+		for (const registration of stableRegistrations) {
+			const seenVersion = state[registration.name];
+			if (
+				typeof seenVersion === "string" &&
+				compareVersions(registration.version, seenVersion) <= 0
+			)
+				continue;
+			try {
+				const entries = parseChangelog(
+					await readFile(registration.changelogPath, "utf8"),
+				).filter(
+					(entry) =>
+						compareVersions(entry.version, registration.version) <= 0 &&
+						(typeof seenVersion === "string"
+							? compareVersions(entry.version, seenVersion) > 0
+							: entry.version === registration.version),
+				);
+				if (entries.length === 0) {
+					errors.push(
+						`No ${registration.version} changelog entry found for ${registration.name}`,
+					);
+					continue;
+				}
+				sections.push(packageMarkdown(registration, entries));
+				state[registration.name] = registration.version;
+				changed = true;
+			} catch (error) {
+				errors.push(
+					`Could not read the ${registration.name} changelog: ${error instanceof Error ? error.message : String(error)}`,
+				);
+			}
+		}
+		if (changed) await writeState(path, state);
+		return {
+			errors,
+			...(sections.length > 0 ? { markdown: sections.join("\n\n") } : {}),
+		};
+	} finally {
+		await release();
+	}
+}
+
+function registerCoordinator(
+	pi: ExtensionAPI,
+	registration: PackageRegistration,
+): void {
+	let accepted = false;
+	pi.events.emit(REGISTRATION_CHANNEL, {
+		registration,
+		accept: () => {
+			accepted = true;
+		},
+	} satisfies RegistrationEvent);
+	if (accepted) return;
+
+	const registrations = new Map([[registration.name, registration]]);
+	pi.events.on(REGISTRATION_CHANNEL, (value) => {
+		if (!isRegistrationEvent(value)) return;
+		registrations.set(value.registration.name, value.registration);
+		value.accept();
+	});
+	pi.registerEntryRenderer<ChangelogEntryData>(
+		ENTRY_TYPE,
+		(entry, _options, theme) => {
+			if (!entry.data) return undefined;
+			const container = new Container();
+			container.addChild(new DynamicBorder());
+			container.addChild(
+				new Text(theme.bold(theme.fg("accent", "What's New")), 1, 0),
+			);
+			container.addChild(new Spacer(1));
+			container.addChild(
+				new Markdown(entry.data.markdown.trim(), 1, 0, getMarkdownTheme()),
+			);
+			container.addChild(new Spacer(1));
+			container.addChild(new DynamicBorder());
+			return container;
+		},
+	);
+	pi.on("session_start", async (event, ctx) => {
+		if (event.reason === "reload" || ctx.mode !== "tui") return;
+		if (
+			ctx.sessionManager
+				.getEntries()
+				.some((entry) =>
+					["branch_summary", "compaction", "message"].includes(entry.type),
+				)
+		)
+			return;
+		try {
+			const update = await claimUpdates(registrations.values());
+			if (update.markdown)
+				pi.appendEntry<ChangelogEntryData>(ENTRY_TYPE, {
+					markdown: update.markdown,
+				});
+			for (const error of update.errors) ctx.ui.notify(error, "warning");
+		} catch (error) {
+			ctx.ui.notify(
+				`Could not update Howaboua changelog state: ${error instanceof Error ? error.message : String(error)}`,
+				"warning",
+			);
+		}
+	});
+}
+
+export default function howabouaPackageChangelog(pi: ExtensionAPI): void {
+	registerCoordinator(pi, packageRegistration());
+}

package/dist/viewer/archive.js

@@ -0,0 +1,185 @@
+import { statSync } from "node:fs";
+import { DatabaseSync, } from "node:sqlite";
+function text(row, key) {
+    const value = row[key];
+    if (typeof value !== "string")
+        throw new Error(`Invalid board archive field: ${key}`);
+    return value;
+}
+function count(row, key) {
+    const value = row[key];
+    if (typeof value !== "number" || !Number.isSafeInteger(value))
+        throw new Error(`Invalid board archive count: ${key}`);
+    return value;
+}
+function nullableText(row, key) {
+    return row[key] === null ? null : text(row, key);
+}
+function post(row) {
+    return {
+        id: text(row, "id"),
+        channel: text(row, "channel"),
+        author: text(row, "author"),
+        createdAt: text(row, "created_at"),
+        text: text(row, "text"),
+    };
+}
+/** The archive is opened read-only; no migrations, board creation or subscriptions. */
+export class Archive {
+    db;
+    source;
+    constructor(source) {
+        this.source = source;
+        try {
+            statSync(source.databasePath);
+        }
+        catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT")
+                return;
+            throw error;
+        }
+        const db = new DatabaseSync(source.databasePath, { readOnly: true });
+        try {
+            db.exec("PRAGMA busy_timeout=2000; PRAGMA query_only=ON; BEGIN");
+            if (db.prepare("PRAGMA user_version").get()?.["user_version"] !== 1)
+                throw new Error("Unsupported board archive version");
+            this.db = db;
+        }
+        catch (error) {
+            db.close();
+            throw error;
+        }
+    }
+    close() {
+        this.db?.close();
+    }
+    all(sql, ...args) {
+        return this.db?.prepare(sql).all(...args) ?? [];
+    }
+    index() {
+        const { databasePath: _path, ...context } = this.source;
+        const boards = this.all(`SELECT b.board_id,b.root_session_id,b.created_at,
+			(SELECT MAX(created_at) FROM posts WHERE board_id=b.board_id) AS last_activity,
+			(SELECT COUNT(*) FROM channels WHERE board_id=b.board_id) AS channels,
+			(SELECT COUNT(*) FROM posts WHERE board_id=b.board_id) AS posts,
+			(SELECT COUNT(DISTINCT author) FROM posts WHERE board_id=b.board_id) AS agents
+			FROM boards b WHERE owner_folder=? ORDER BY COALESCE(last_activity,b.created_at) DESC`, this.source.folder).map((row) => ({
+            id: text(row, "board_id"),
+            rootSessionId: text(row, "root_session_id"),
+            createdAt: text(row, "created_at"),
+            lastActivity: nullableText(row, "last_activity"),
+            channels: count(row, "channels"),
+            posts: count(row, "posts"),
+            agents: count(row, "agents"),
+        }));
+        if (!boards.some((board) => board.id === context.boardId))
+            boards.unshift({
+                id: context.boardId,
+                rootSessionId: context.sessionId,
+                createdAt: null,
+                lastActivity: null,
+                channels: 0,
+                posts: 0,
+                agents: 0,
+            });
+        return { context, boards };
+    }
+    board(id) {
+        const board = this.index().boards.find((board) => board.id === id);
+        if (!board)
+            throw new Error("Board not found in this folder");
+        return board;
+    }
+    detail(id) {
+        const board = this.board(id);
+        const channels = this.all(`SELECT c.name,c.author,c.created_at,COUNT(p.id) AS posts,
+			COUNT(CASE WHEN p.id=p.root THEN 1 END) AS threads,MAX(p.created_at) AS last_activity
+			FROM channels c LEFT JOIN posts p ON p.board_id=c.board_id AND p.channel=c.name
+			WHERE c.board_id=? GROUP BY c.name ORDER BY COALESCE(last_activity,c.created_at) DESC,c.name`, id).map((row) => ({
+            name: text(row, "name"),
+            author: text(row, "author"),
+            createdAt: text(row, "created_at"),
+            posts: count(row, "posts"),
+            threads: count(row, "threads"),
+            lastActivity: nullableText(row, "last_activity"),
+        }));
+        const agents = this.all("SELECT author,COUNT(*) AS posts,MAX(created_at) AS last_activity FROM posts WHERE board_id=? GROUP BY author ORDER BY posts DESC,author", id).map((row) => ({
+            name: text(row, "author"),
+            posts: count(row, "posts"),
+            lastActivity: text(row, "last_activity"),
+        }));
+        const subscriptions = this.all("SELECT target,agent,enabled FROM subscriptions WHERE board_id=? ORDER BY target,agent", id).map((row) => ({
+            target: text(row, "target"),
+            agent: text(row, "agent"),
+            enabled: count(row, "enabled") === 1,
+        }));
+        return { board, channels, agents, subscriptions };
+    }
+    threads(id, params) {
+        this.board(id);
+        const channel = params.get("channel");
+        const query = params.get("q");
+        const author = params.get("author");
+        if (query && query.length > 1000)
+            throw new Error("Search is too long");
+        const where = ["r.board_id=?", "r.id=r.root"];
+        const args = [id];
+        if (channel !== null) {
+            where.push("r.channel=?");
+            args.push(channel);
+        }
+        if (query || author) {
+            const match = ["m.board_id=r.board_id", "m.root=r.id"];
+            if (query) {
+                match.push("instr(lower(m.text),lower(?))>0");
+                args.push(query);
+            }
+            if (author) {
+                match.push("m.author=?");
+                args.push(author);
+            }
+            where.push(`EXISTS(SELECT 1 FROM posts m WHERE ${match.join(" AND ")})`);
+        }
+        const cursor = this.cursor(params);
+        const rows = this.all(`SELECT r.id,r.channel,r.author,r.text,r.created_at,
+			MAX(p.created_at) AS last_activity,MAX(p.seq) AS last_seq,COUNT(*)-1 AS replies
+			FROM posts r JOIN posts p ON p.board_id=r.board_id AND p.root=r.id
+			WHERE ${where.join(" AND ")} GROUP BY r.id HAVING MAX(p.seq)<? ORDER BY last_seq DESC LIMIT 41`, ...args, cursor ?? Number.MAX_SAFE_INTEGER);
+        const visible = rows.slice(0, 40);
+        const last = visible.at(-1);
+        return {
+            threads: visible.map((row) => ({
+                id: text(row, "id"),
+                channel: text(row, "channel"),
+                author: text(row, "author"),
+                preview: text(row, "text").slice(0, 600),
+                createdAt: text(row, "created_at"),
+                lastActivity: text(row, "last_activity"),
+                replies: count(row, "replies"),
+            })),
+            nextCursor: rows.length > 40 && last ? String(count(last, "last_seq")) : null,
+        };
+    }
+    thread(id, threadId, params) {
+        this.board(id);
+        const root = this.all("SELECT id,channel,author,created_at,text FROM posts WHERE board_id=? AND id=? AND root=id", id, threadId)[0];
+        if (!root)
+            throw new Error("Thread not found in this board");
+        const rows = this.all("SELECT seq,id,channel,author,created_at,text FROM posts WHERE board_id=? AND root=? AND id<>root AND seq>? ORDER BY seq LIMIT 81", id, threadId, this.cursor(params) ?? 0);
+        const visible = rows.slice(0, 80);
+        const last = visible.at(-1);
+        return {
+            root: post(root),
+            replies: visible.map(post),
+            nextCursor: rows.length > 80 && last ? String(count(last, "seq")) : null,
+        };
+    }
+    cursor(params) {
+        const value = params.get("cursor");
+        if (value === null)
+            return undefined;
+        if (!/^[0-9]+$/.test(value) || !Number.isSafeInteger(Number(value)))
+            throw new Error("Invalid page cursor");
+        return Number(value);
+    }
+}