@clubnet/seedclub 0.2.0

package/assets/extensions/seedclub/tools/signals.ts

@@ -0,0 +1,275 @@
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { ApiError, api } from "../api-client.js";
+import { wrapExecute } from "../tool-utils.js";
+
+// --- Type labels ---
+
+const TYPE_LABEL: Record<string, string> = {
+	twitter_account: "twitter",
+	company: "company",
+	person: "person",
+	blog: "blog",
+	github_profile: "github",
+	topic: "topic",
+	newsletter: "newsletter",
+	podcast: "podcast",
+	subreddit: "subreddit",
+	custom: "signal",
+};
+
+// --- API handlers (used by /add internally, NOT exposed to LLM) ---
+
+export async function importSignals(args: { input: string; defaultType?: string; tags?: string[] }) {
+	try {
+		const response = await api.post<any>("/signals/import", args);
+		return { created: response.created, skipped: response.skipped, total: response.total };
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+export async function createSignal(args: {
+	type: string;
+	name: string;
+	description?: string;
+	externalUrl?: string;
+	imageUrl?: string;
+	tags?: string[];
+	metadata?: Record<string, unknown>;
+}) {
+	try {
+		const response = await api.post<any>("/signals", args);
+		return {
+			id: response.signal.id,
+			type: response.signal.type,
+			name: response.signal.name,
+			slug: response.signal.slug,
+		};
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+// --- Read-only handlers ---
+
+async function getSignal(args: { signalId?: string; slug?: string }) {
+	try {
+		const params: Record<string, string | undefined> = {};
+		if (args.signalId) params.id = args.signalId;
+		if (args.slug) params.slug = args.slug;
+		const response = await api.get<any>("/signals", params);
+		return { signal: response.signal };
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+export async function listSignals(args: { type?: string; tag?: string; limit?: number }) {
+	try {
+		const response = await api.get<any>("/signals", args);
+		return { signals: response.signals, total: response.total };
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+export async function searchSignals(args: { query: string; limit?: number }) {
+	try {
+		const response = await api.get<any>("/signals", { search: args.query, limit: args.limit });
+		return { signals: response.signals, total: response.total, query: args.query };
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function deleteSignal(args: { signalId: string }) {
+	try {
+		const response = await api.delete<any>("/signals", { id: args.signalId });
+		return { success: response.success, message: response.message };
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+// --- Bulk operations (used by /sort) ---
+
+export async function deleteUnsortedSignals() {
+	try {
+		const response = await api.delete<any>("/signals", { id: "unsorted" });
+		return { deleted: response.deleted, message: response.message };
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+// --- Sort operations ---
+
+export async function getUnsortedSignals() {
+	try {
+		const response = await api.get<any>("/signals/sort/auto", {});
+		return {
+			unsorted: response.unsorted,
+			unsortedCount: response.unsortedCount,
+			buckets: response.buckets,
+			angelMd: response.angelMd,
+		};
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function submitSortScores(args: { scores: Record<string, Record<string, number>> }) {
+	try {
+		const response = await api.post<any>("/signals/sort/auto", { scores: args.scores });
+		return {
+			sorted: response.sortedCount,
+			skipped: response.skippedCount,
+			adjusted: response.adjustedCount,
+		};
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+// --- LLM tool registration ---
+
+export function registerSignalTools(pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "leaf_list_signals",
+		label: "List Signals",
+		description: "List the user's signals. Use /add to create new signals.",
+		parameters: Type.Object({
+			type: Type.Optional(Type.String({ description: "Filter by signal type" })),
+			tag: Type.Optional(Type.String({ description: "Filter by tag" })),
+			limit: Type.Optional(Type.Number({ description: "Maximum number of results" })),
+		}),
+		execute: wrapExecute(listSignals),
+		renderResult(result: any, { expanded }: any, theme: any) {
+			if (result.isError) return new Text(theme.fg("error", result.content?.[0]?.text || "Error"), 0, 0);
+			const d = result.details || {};
+			let text = theme.fg("muted", `${d.total ?? 0} signals`);
+			if (d.signals?.length) {
+				for (const s of d.signals.slice(0, expanded ? 50 : 10)) {
+					const label = TYPE_LABEL[s.type] || "signal";
+					text += `\n  ${s.name} [${label}]`;
+				}
+				if (!expanded && d.signals.length > 10) {
+					text += theme.fg("dim", `\n  ... and ${d.signals.length - 10} more`);
+				}
+			}
+			return new Text(text, 0, 0);
+		},
+	});
+
+	pi.registerTool({
+		name: "leaf_search_signals",
+		label: "Search Signals",
+		description: "Search the user's signals by name or description.",
+		parameters: Type.Object({
+			query: Type.String({ description: "Search query" }),
+			limit: Type.Optional(Type.Number({ description: "Maximum number of results" })),
+		}),
+		execute: wrapExecute(searchSignals),
+		renderResult(result: any, { expanded }: any, theme: any) {
+			if (result.isError) return new Text(theme.fg("error", result.content?.[0]?.text || "Error"), 0, 0);
+			const d = result.details || {};
+			if (!d.signals?.length) return new Text(theme.fg("dim", `No results for "${d.query}"`), 0, 0);
+			let text = theme.fg("muted", `${d.total} results:`);
+			for (const s of d.signals.slice(0, expanded ? 50 : 10)) {
+				const label = TYPE_LABEL[s.type] || "signal";
+				text += `\n  ${s.name} [${label}]`;
+			}
+			return new Text(text, 0, 0);
+		},
+	});
+
+	pi.registerTool({
+		name: "leaf_get_signal",
+		label: "Get Signal",
+		description: "Get details of a specific signal.",
+		parameters: Type.Object({
+			signalId: Type.Optional(Type.String({ description: "Signal ID" })),
+			slug: Type.Optional(Type.String({ description: "Signal slug" })),
+		}),
+		execute: wrapExecute(getSignal),
+	});
+
+	pi.registerTool({
+		name: "leaf_delete_signal",
+		label: "Delete Signal",
+		description: "Delete a signal by ID.",
+		parameters: Type.Object({
+			signalId: Type.String({ description: "ID of the signal to delete" }),
+		}),
+		execute: wrapExecute(deleteSignal),
+	});
+
+	pi.registerTool({
+		name: "leaf_get_unsorted_signals",
+		label: "Get Unsorted Signals",
+		description:
+			"Get signals that haven't been sorted into buckets yet. Returns signals with their descriptions, metadata, and the 10 bucket definitions. Also returns the user's angel.md (investment thesis) if set.",
+		parameters: Type.Object({}),
+		execute: wrapExecute(async () => {
+			const result = await getUnsortedSignals();
+			if ("error" in result) return result;
+			return {
+				count: result.unsortedCount,
+				buckets: result.buckets,
+				angelMd: result.angelMd,
+				signals: result.unsorted?.map((s: any) => ({
+					id: s.userSignalId,
+					name: s.name,
+					description: s.description,
+					url: s.externalUrl,
+					type: s.type,
+					metadata: s.metadata,
+				})),
+			};
+		}),
+		renderResult(result: any, _opts: any, theme: any) {
+			if (result.isError) return new Text(theme.fg("error", result.content?.[0]?.text || "Error"), 0, 0);
+			const d = result.details || {};
+			return new Text(
+				theme.fg("muted", `${d.count ?? 0} unsorted signals, ${d.buckets?.length ?? 0} buckets`),
+				0,
+				0,
+			);
+		},
+	});
+
+	pi.registerTool({
+		name: "leaf_submit_sort_scores",
+		label: "Submit Sort Scores",
+		description:
+			"Submit bucket scores for signals. Each signal needs scores (0-1) for each of the 10 buckets: vision, execution, resilience, social, learning, taste, technical, innovation, domain, commercial. Server applies the user's taste prior on top of your raw scores. Pass a map of userSignalId -> { bucketKey: score }.",
+		parameters: Type.Object({
+			scores: Type.Record(
+				Type.String({ description: "userSignalId" }),
+				Type.Record(Type.String({ description: "bucket key" }), Type.Number({ description: "score 0-1" })),
+				{ description: "Map of signalId to bucket scores" },
+			),
+		}),
+		execute: wrapExecute(submitSortScores),
+		renderResult(result: any, _opts: any, theme: any) {
+			if (result.isError) return new Text(theme.fg("error", result.content?.[0]?.text || "Error"), 0, 0);
+			const d = result.details || {};
+			const parts: string[] = [];
+			if (d.sorted) parts.push(`${d.sorted} sorted`);
+			if (d.skipped) parts.push(`${d.skipped} skipped`);
+			if (d.adjusted) parts.push(`${d.adjusted} adjusted by taste`);
+			return new Text(theme.fg("muted", parts.join(", ") || "done"), 0, 0);
+		},
+	});
+}

package/assets/extensions/seedclub/tools/utility.ts

@@ -0,0 +1,31 @@
+import { Type } from "@sinclair/typebox";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { ApiError, api } from "../api-client.js";
+import { wrapExecute } from "../tool-utils.js";
+
+export async function getCurrentUser() {
+	try {
+		const response = await api.get<any>("/user");
+		return {
+			id: response.user.id,
+			name: response.user.name,
+			email: response.user.email,
+			role: response.user.role,
+			createdAt: response.user.createdAt,
+			stats: response.stats,
+		};
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+export function registerUtilityTools(pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "leaf_get_current_user",
+		label: "Get Current User",
+		description: "Get information about the currently authenticated Seed Club user and their stats.",
+		parameters: Type.Object({}),
+		execute: wrapExecute(getCurrentUser),
+	});
+}

package/assets/extensions/seedclub/twitter-client.ts

@@ -0,0 +1,277 @@
+/**
+ * Singleton wrapper for the bird TwitterClient.
+ * Detects the system default browser and tries it first for cookie resolution.
+ */
+
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+import { type CookieSource, resolveCredentials, TwitterClient, type TwitterCookies } from "@connormartin/bird";
+import { isDiaAvailable, readDiaTwitterCookies } from "./dia-cookies.js";
+
+// --- Default browser detection ---
+
+type BrowserKind = "safari" | "chrome" | "firefox";
+
+interface BrowserInfo {
+	kind: BrowserKind;
+	bundleId: string;
+	cookieDir?: string; // specific cookie directory for this browser
+}
+
+const BUNDLE_TO_BROWSER: Record<string, BrowserInfo> = {
+	"com.apple.safari": { kind: "safari", bundleId: "com.apple.safari" },
+	"com.google.chrome": { kind: "chrome", bundleId: "com.google.chrome", cookieDir: "Google/Chrome" },
+	"com.brave.browser": { kind: "chrome", bundleId: "com.brave.browser", cookieDir: "BraveSoftware/Brave-Browser" },
+	"company.thebrowser.browser": { kind: "chrome", bundleId: "company.thebrowser.browser", cookieDir: "Arc/User Data" },
+	"com.microsoft.edgemac": { kind: "chrome", bundleId: "com.microsoft.edgemac", cookieDir: "Microsoft Edge" },
+	"com.vivaldi.vivaldi": { kind: "chrome", bundleId: "com.vivaldi.vivaldi", cookieDir: "Vivaldi" },
+	"org.mozilla.firefox": { kind: "firefox", bundleId: "org.mozilla.firefox" },
+	"org.mozilla.nightly": { kind: "firefox", bundleId: "org.mozilla.nightly" },
+	"company.thebrowser.dia": { kind: "chrome", bundleId: "company.thebrowser.dia", cookieDir: "Dia/User Data" },
+};
+
+function detectDefaultBrowser(): BrowserInfo | null {
+	if (process.platform !== "darwin") return null;
+	try {
+		const plistPath = join(
+			process.env.HOME || "",
+			"Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure.plist",
+		);
+		const plist = execFileSync("plutil", ["-convert", "json", "-o", "-", plistPath], {
+			encoding: "utf-8",
+			timeout: 3000,
+		});
+		const data = JSON.parse(plist);
+		const handlers = data.LSHandlers ?? [];
+		for (const h of handlers) {
+			if (h.LSHandlerURLScheme === "https" && h.LSHandlerRoleAll) {
+				const bundleId = h.LSHandlerRoleAll.toLowerCase();
+				for (const [prefix, info] of Object.entries(BUNDLE_TO_BROWSER)) {
+					if (bundleId.includes(prefix)) return info;
+				}
+			}
+		}
+	} catch {}
+	return null;
+}
+
+// --- Chrome profile detection ---
+
+/** Find Chrome profiles in a specific app support directory. */
+function detectChromeProfiles(cookieDir?: string): string[] {
+	if (process.platform !== "darwin") return [];
+
+	const home = process.env.HOME || "";
+	const dirs = cookieDir
+		? [join(home, "Library/Application Support", cookieDir)]
+		: [
+				join(home, "Library/Application Support/Dia/User Data"),
+				join(home, "Library/Application Support/Google/Chrome"),
+				join(home, "Library/Application Support/BraveSoftware/Brave-Browser"),
+				join(home, "Library/Application Support/Arc/User Data"),
+				join(home, "Library/Application Support/Microsoft Edge"),
+				join(home, "Library/Application Support/Vivaldi"),
+			];
+
+	const profiles: { name: string; mtimeMs: number }[] = [];
+
+	for (const dir of dirs) {
+		if (!existsSync(dir)) continue;
+		try {
+			const defaultCookies = join(dir, "Default", "Cookies");
+			if (existsSync(defaultCookies)) {
+				profiles.push({ name: "Default", mtimeMs: statSync(defaultCookies).mtimeMs });
+			}
+			const entries = readdirSync(dir);
+			for (const name of entries) {
+				if (!name.startsWith("Profile ")) continue;
+				const cookiesPath = join(dir, name, "Cookies");
+				if (existsSync(cookiesPath)) {
+					profiles.push({ name, mtimeMs: statSync(cookiesPath).mtimeMs });
+				}
+			}
+		} catch {}
+	}
+
+	profiles.sort((a, b) => b.mtimeMs - a.mtimeMs);
+	return profiles.map((p) => p.name);
+}
+
+// --- Credential resolution ---
+
+export class TwitterClientError extends Error {
+	constructor(
+		message: string,
+		public code: "NO_CREDENTIALS" | "API_ERROR",
+	) {
+		super(message);
+		this.name = "TwitterClientError";
+	}
+}
+
+export interface CredentialCheckResult {
+	valid: boolean;
+	source?: string;
+	warnings: string[];
+	user?: { id: string; username: string; name: string };
+}
+
+let cachedClient: TwitterClient | null = null;
+let _cachedCookies: TwitterCookies | null = null;
+
+export function clearTwitterClient(): void {
+	cachedClient = null;
+	_cachedCookies = null;
+}
+
+async function tryBrowser(
+	source: CookieSource,
+	opts?: { chromeProfile?: string; firefoxProfile?: string },
+): Promise<{ cookies: TwitterCookies; warnings: string[] } | null> {
+	const result = await resolveCredentials({
+		cookieSource: [source],
+		chromeProfile: opts?.chromeProfile,
+		firefoxProfile: opts?.firefoxProfile,
+	});
+	if (result.cookies.authToken && result.cookies.ct0) {
+		return { cookies: result.cookies, warnings: result.warnings };
+	}
+	return null;
+}
+
+async function resolveTwitterCredentials(): Promise<{
+	cookies: TwitterCookies;
+	warnings: string[];
+}> {
+	const allWarnings: string[] = [];
+	const defaultBrowser = detectDefaultBrowser();
+
+	// Dia: sweet-cookie doesn't support it, so we read cookies directly
+	if (defaultBrowser?.bundleId === "company.thebrowser.dia" || (!defaultBrowser && isDiaAvailable())) {
+		const dia = readDiaTwitterCookies();
+		if (dia) {
+			return {
+				cookies: {
+					authToken: dia.authToken,
+					ct0: dia.ct0,
+					cookieHeader: dia.cookieHeader,
+					source: "Dia",
+				},
+				warnings: [],
+			};
+		}
+		if (defaultBrowser?.bundleId === "company.thebrowser.dia") {
+			return {
+				cookies: { authToken: null, ct0: null, cookieHeader: null, source: null },
+				warnings: ["No Twitter login found in Dia. Log in to x.com there."],
+			};
+		}
+	}
+
+	// If we know the default browser, try ONLY that browser's cookies.
+	if (defaultBrowser) {
+		const result = await tryBrowserInfo(defaultBrowser);
+		if (result) return result;
+		allWarnings.push("No Twitter login found in your default browser. Log in to x.com there.");
+		return {
+			cookies: { authToken: null, ct0: null, cookieHeader: null, source: null },
+			warnings: allWarnings,
+		};
+	}
+
+	// No default browser detected — try all in order
+	for (const browser of ["safari", "chrome", "firefox"] as BrowserKind[]) {
+		const result = await tryBrowserKind(browser);
+		if (result) return result;
+	}
+
+	allWarnings.push("No Twitter credentials found in any browser. Log in to x.com.");
+	return {
+		cookies: { authToken: null, ct0: null, cookieHeader: null, source: null },
+		warnings: allWarnings,
+	};
+}
+
+async function tryBrowserInfo(info: BrowserInfo): Promise<{ cookies: TwitterCookies; warnings: string[] } | null> {
+	if (info.kind === "safari") return tryBrowser("safari");
+	if (info.kind === "firefox") return tryBrowser("firefox", { firefoxProfile: process.env.FIREFOX_PROFILE });
+
+	// Chrome-based — use specific cookie dir for this browser only
+	const profiles = detectChromeProfiles(info.cookieDir);
+	for (const profile of profiles) {
+		const result = await tryBrowser("chrome", { chromeProfile: profile });
+		if (result) return result;
+	}
+	return null;
+}
+
+async function tryBrowserKind(kind: BrowserKind): Promise<{ cookies: TwitterCookies; warnings: string[] } | null> {
+	if (kind === "safari") return tryBrowser("safari");
+	if (kind === "firefox") return tryBrowser("firefox", { firefoxProfile: process.env.FIREFOX_PROFILE });
+
+	// Chrome — try all dirs
+	const profiles = detectChromeProfiles();
+	for (const profile of profiles) {
+		const result = await tryBrowser("chrome", { chromeProfile: profile });
+		if (result) return result;
+	}
+	return null;
+}
+
+// --- Public API ---
+
+export async function getTwitterClient(): Promise<TwitterClient> {
+	if (cachedClient) return cachedClient;
+
+	const { cookies, warnings: _warnings } = await resolveTwitterCredentials();
+	if (!cookies.authToken || !cookies.ct0) {
+		throw new TwitterClientError(
+			"Twitter credentials not found. Log in to x.com in your default browser.",
+			"NO_CREDENTIALS",
+		);
+	}
+
+	_cachedCookies = cookies;
+	cachedClient = new TwitterClient({ cookies });
+	return cachedClient;
+}
+
+export async function checkTwitterCredentials(): Promise<CredentialCheckResult> {
+	const { cookies, warnings } = await resolveTwitterCredentials();
+
+	if (!cookies.authToken || !cookies.ct0) {
+		return {
+			valid: false,
+			warnings: [...warnings, "No valid Twitter credentials found. Log in to x.com in your default browser."],
+		};
+	}
+
+	try {
+		const client = new TwitterClient({ cookies });
+		const result = await client.getCurrentUser();
+
+		if (!result.success || !result.user) {
+			return {
+				valid: false,
+				source: cookies.source ?? undefined,
+				warnings: [...warnings, result.error ?? "Failed to verify credentials"],
+			};
+		}
+
+		_cachedCookies = cookies;
+		cachedClient = client;
+
+		return { valid: true, source: cookies.source ?? undefined, warnings, user: result.user };
+	} catch (error) {
+		return {
+			valid: false,
+			source: cookies.source ?? undefined,
+			warnings: [
+				...warnings,
+				`Credential verification failed: ${error instanceof Error ? error.message : String(error)}`,
+			],
+		};
+	}
+}

package/assets/extensions/seedclub-ui/editor.ts

@@ -0,0 +1,93 @@
+/**
+ * Green Bar Editor — solid emerald background input, full width.
+ * The text input is a bright green bar. Content above is black bg.
+ */
+
+import { type EditorTheme, type TUI, visibleWidth } from "@mariozechner/pi-tui";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { KeybindingsManager } from "@mariozechner/pi-coding-agent";
+import { CustomEditor } from "@mariozechner/pi-coding-agent";
+
+const EMERALD_BG = "\x1b[48;2;80;200;120m";
+const BLACK_FG = "\x1b[38;2;14;14;15m";
+const EMERALD_FG = "\x1b[38;2;80;200;120m";
+const PANEL_BG = "\x1b[48;2;14;14;15m";
+const PANEL_FG = EMERALD_FG;
+const RESET = "\x1b[0m";
+
+class GreenBarEditor extends CustomEditor {
+	constructor(tui: TUI, theme: EditorTheme, kb: KeybindingsManager) {
+		super(tui, theme, kb);
+		// Disable default border rendering
+		this.borderColor = (_text: string) => "";
+	}
+
+	render(width: number): string[] {
+		const rawLines = super.render(width);
+		const filtered: string[] = [];
+
+		for (const line of rawLines) {
+			const stripped = this.stripAnsi(line);
+			if (this.isBorderLine(stripped)) continue;
+			filtered.push(line);
+		}
+
+		const paintEmerald = (line: string): string => {
+			const plain = this.stripAnsi(line);
+			const vis = visibleWidth(plain);
+			const pad = " ".repeat(Math.max(0, width - vis));
+			return `${EMERALD_BG}${BLACK_FG}${plain}${pad}${RESET}`;
+		};
+
+		if (filtered.length === 0) {
+			return [paintEmerald("")];
+		}
+
+		// Keep input bar emerald, but render slash/autocomplete menu on dark panel
+		// so it isn't washed out by emerald background.
+		if (this.isShowingAutocomplete()) {
+			const [inputLine, ...menuLines] = filtered;
+			const out = [paintEmerald(inputLine ?? "")];
+
+			for (const menuLine of menuLines) {
+				const plain = this.stripAnsi(menuLine);
+				const trimmed = plain.trim();
+				// Drop visual separator rules for cleaner menu block
+				if (/^[─-]+$/.test(trimmed)) continue;
+				const vis = visibleWidth(plain);
+				const pad = " ".repeat(Math.max(0, width - vis));
+				const color = trimmed.startsWith("→") || trimmed.startsWith(">") ? EMERALD_FG : PANEL_FG;
+				out.push(`${PANEL_BG}${color}${plain}${pad}${RESET}`);
+			}
+			return out;
+		}
+
+		return filtered.map((line) => paintEmerald(line));
+	}
+
+	private stripAnsi(s: string): string {
+		return s
+			// CSI sequences (colors, clears, cursor moves, etc.)
+			.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "")
+			// OSC/APC style sequences
+			.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
+			.replace(/\x1b_[^\x1b]*\x1b\\/g, "");
+	}
+
+	private isBorderLine(stripped: string): boolean {
+		const trimmed = stripped.trim();
+		if (trimmed.length === 0) return false;
+		// Match lines that are purely border characters
+		return /^[─╭╮╰╯├┤┬┴│]+$/.test(trimmed);
+	}
+
+	override invalidate(): void {
+		super.invalidate();
+	}
+}
+
+export default function (pi: ExtensionAPI) {
+	pi.on("session_start", (_event, ctx) => {
+		ctx.ui.setEditorComponent((tui, theme, kb) => new GreenBarEditor(tui, theme, kb));
+	});
+}

package/assets/extensions/seedclub-ui/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Seed Club UI — built-in theme experience.
+ * Window frame, rounded emerald editor, welcome header with weather/markets.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import editorExtension from "./editor.js";
+import updateExtension from "./update.js";
+import welcomeExtension from "./welcome.js";
+
+export default function (pi: ExtensionAPI) {
+	editorExtension(pi);
+	welcomeExtension(pi, { enableFrame: true });
+	updateExtension(pi);
+}