@clubnet/seedclub 0.2.6 → 0.2.7

package/README.md

@@ -71,7 +71,8 @@ A `postinstall` script runs after every install/update and sets up:
         │     ├── seedclub/        ← core: auth, tools, commands
         │     └── seedclub-ui/     ← UI: welcome screen, update check
         ├── themes/
-        │     └── seedclub.json
+        │     ├── dark.json
+        │     └── light.json
         ├── settings.json
         └── .seedclub-version
 ```
@@ -98,7 +99,7 @@ Users never interact with pi's npm package directly. When they run `seedclub upd
 
 ## Theme
 
-The seedclub theme lives at `assets/theme/seedclub.json` and gets installed to `~/.seedclub/agent/themes/seedclub.json`.
+Themes live under `assets/theme/` and are installed to `~/.seedclub/agent/themes/` (currently `dark.json` and `light.json`).
 
 It's a standard pi theme with 51 color tokens. Edit it to change any visual aspect of the app:
 
@@ -140,7 +141,8 @@ seedclub/
   ├── README.md
   └── assets/
         ├── theme/
-        │     └── seedclub.json
+        │     ├── dark.json
+        │     └── light.json
         └── extensions/
               ├── seedclub/        ← core extension source
               └── seedclub-ui/     ← UI extension source

package/assets/extensions/seedclub/auth.ts

@@ -18,6 +18,7 @@ const DEFAULT_API_BASE = "https://looseleaf-rouge.vercel.app";
 export interface StoredToken {
 	token: string;
 	email: string;
+	name?: string;
 	createdAt: string;
 	apiBase: string;
 }
@@ -67,11 +68,20 @@ export async function getToken(): Promise<string | null> {
 	return stored?.token ?? null;
 }
 
-export async function storeToken(token: string, email: string, apiBase: string): Promise<void> {
+export async function storeToken(
+	token: string,
+	email: string,
+	apiBase: string,
+	options?: { name?: string },
+): Promise<void> {
 	await mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
 	await writeFile(
 		TOKEN_FILE,
-		JSON.stringify({ token, email, createdAt: new Date().toISOString(), apiBase }, null, 2),
+		JSON.stringify(
+			{ token, email, name: options?.name, createdAt: new Date().toISOString(), apiBase },
+			null,
+			2,
+		),
 		{ mode: 0o600 },
 	);
 	try {

package/assets/extensions/seedclub/commands/seedclub.ts

@@ -14,6 +14,13 @@ interface SeedclubDeps {
 }
 
 export function registerSeedclubCommand(pi: ExtensionAPI, deps: SeedclubDeps) {
+	pi.registerCommand("connect", {
+		description: "Connect your Seed Club account",
+		handler: async (args, ctx) => {
+			await deps.connect(args, ctx);
+		},
+	});
+
 	pi.registerCommand("seedclub", {
 		description: "Seed Club",
 		handler: async (args, ctx) => {

package/assets/extensions/seedclub/index.ts

@@ -17,6 +17,11 @@ import { registerSignalTools } from "./tools/signals.js";
 import { getCurrentUser, registerUtilityTools } from "./tools/utility.js";
 
 export default function (pi: ExtensionAPI) {
+	const formatSeedLabel = (name?: string, email?: string) => {
+		const label = (name?.trim() || email?.trim() || "connected").replace(/\s+/g, " ");
+		return label;
+	};
+
 	// Tools (read-only signals + user info)
 	registerSignalTools(pi);
 	registerUtilityTools(pi);
@@ -31,7 +36,7 @@ export default function (pi: ExtensionAPI) {
 		const stored = await getStoredToken();
 		if (stored) {
 			const isDev = stored.apiBase?.includes("localhost") || stored.apiBase?.includes("127.0.0.1");
-			ctx.ui.setStatus("seed", `seed: ${stored.email}`);
+			ctx.ui.setStatus("seed", formatSeedLabel(stored.name, stored.email));
 			if (isDev) ctx.ui.setStatus("seed-api", `dev: ${stored.apiBase}`);
 		} else if (process.env.SEEDCLUB_TOKEN || process.env.SEED_NETWORK_TOKEN) {
 			ctx.ui.setStatus("seed", "seed: connected (env)");
@@ -89,9 +94,9 @@ export default function (pi: ExtensionAPI) {
 			return;
 		}
 
-		await storeToken(token, result.email, apiBase);
-		ctx.ui.notify(`Connected as ${result.email}`, "success");
-		ctx.ui.setStatus("seed", `seed: ${result.email}`);
+		await storeToken(token, result.email, apiBase, { name: result.name });
+		ctx.ui.notify(`Connected as ${result.name || result.email}`, "success");
+		ctx.ui.setStatus("seed", formatSeedLabel(result.name, result.email));
 	}
 }
 

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

@@ -1,93 +1,118 @@
-/**
- * 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 EditorTheme, type TUI, truncateToWidth } 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";
+import { visibleWidth } from "@mariozechner/pi-tui";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { uiState } from "./state.js";
+
+interface Palette {
+	surfaceBg: string;
+}
 
-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 SurfaceEditor extends CustomEditor {
+	private readonly palette: Palette;
+	private static readonly RESET = "\x1b[0m";
+	private static readonly INSET = "  ";
+	private static readonly PLACEHOLDER = "/ for menu";
+	private static readonly PLACEHOLDER_DIM = "\x1b[38;2;85;85;85m";
 
-class GreenBarEditor extends CustomEditor {
-	constructor(tui: TUI, theme: EditorTheme, kb: KeybindingsManager) {
+	constructor(tui: TUI, theme: EditorTheme, kb: KeybindingsManager, palette: Palette) {
 		super(tui, theme, kb);
-		// Disable default border rendering
-		this.borderColor = (_text: string) => "";
+		this.palette = palette;
+		this.setPaddingX(2);
 	}
 
 	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);
+		if (!uiState.ready) {
+			return [];
 		}
+		const rawLines = super.render(width);
+		const showPlaceholder = this.getText().length === 0;
+		let placeholderPlaced = false;
+		return rawLines.map((line) => {
+			const stripped = this.stripAnsi(line).trim();
+			const isBorderLine = stripped.startsWith("─");
+			if (isBorderLine) {
+				return this.paintLine(line, width, false);
+			}
+			if (showPlaceholder && !placeholderPlaced) {
+				placeholderPlaced = true;
+				return this.paintLine(line, width, true);
+			}
+			return this.paintLine(line, width, false);
+		});
+	}
 
-		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}`;
-		};
+	override invalidate(): void {
+		super.invalidate();
+	}
 
-		if (filtered.length === 0) {
-			return [paintEmerald("")];
+	override handleInput(data: string): void {
+		if (!uiState.ready) {
+			// Keep app-level interrupts available while startup UI is loading.
+			if (data === "\u0003" || data === "\u0004" || data === "\u001b") {
+				super.handleInput(data);
+			}
+			return;
 		}
+		super.handleInput(data);
+	}
 
-		// 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}`);
+	private paintLine(line: string, width: number, addPlaceholder: boolean): string {
+		const stripped = this.stripAnsi(line).trim();
+		const isBorderLine = stripped.startsWith("─");
+		if (isBorderLine) {
+			return `${this.palette.surfaceBg}${" ".repeat(Math.max(0, width))}${SurfaceEditor.RESET}`;
+		}
+		// Editor lines include ANSI resets (e.g. cursor rendering). Re-apply our bg
+		// after each reset so the input row stays a solid surface.
+		let lineWithStableBg = line.replace(/\x1b\[0m/g, `${SurfaceEditor.RESET}${this.palette.surfaceBg}`);
+		if (addPlaceholder) {
+			const cursorCell = "\x1b[7m \x1b[0m";
+			if (lineWithStableBg.includes(cursorCell)) {
+				const slashCursor = "\x1b[7m/\x1b[0m";
+				lineWithStableBg = lineWithStableBg.replace(
+					cursorCell,
+					`${slashCursor}${this.palette.surfaceBg}${SurfaceEditor.PLACEHOLDER_DIM}${SurfaceEditor.PLACEHOLDER.slice(1)}${SurfaceEditor.RESET}${this.palette.surfaceBg}`,
+				);
+			} else {
+				lineWithStableBg += `${this.palette.surfaceBg}${SurfaceEditor.PLACEHOLDER_DIM}${SurfaceEditor.PLACEHOLDER}${SurfaceEditor.RESET}${this.palette.surfaceBg}`;
 			}
-			return out;
 		}
-
-		return filtered.map((line) => paintEmerald(line));
+		const usableWidth = Math.max(1, width - visibleWidth(SurfaceEditor.INSET));
+		const shifted = truncateToWidth(lineWithStableBg, usableWidth, "");
+		const pad = " ".repeat(Math.max(0, usableWidth - visibleWidth(shifted)));
+		return `${this.palette.surfaceBg}${SurfaceEditor.INSET}${shifted}${pad}${SurfaceEditor.RESET}`;
 	}
 
 	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();
-	}
+function pickPalette(): Palette {
+	const settingsPath = join(homedir(), ".seedclub", "agent", "settings.json");
+	let theme = "dark";
+	try {
+		if (existsSync(settingsPath)) {
+			const raw = JSON.parse(readFileSync(settingsPath, "utf-8"));
+			if (typeof raw?.theme === "string") theme = raw.theme.toLowerCase();
+		}
+	} catch {}
+	return theme === "light"
+		? { surfaceBg: "\x1b[48;2;228;234;242m" }
+		: { surfaceBg: "\x1b[48;2;38;38;38m" };
 }
 
 export default function (pi: ExtensionAPI) {
 	pi.on("session_start", (_event, ctx) => {
-		ctx.ui.setEditorComponent((tui, theme, kb) => new GreenBarEditor(tui, theme, kb));
+		const palette = pickPalette();
+		ctx.ui.setEditorComponent((tui, theme, kb) => new SurfaceEditor(tui, theme, kb, palette));
 	});
 }

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

@@ -0,0 +1,134 @@
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { uiState } from "./state.js";
+
+const WHITE = "\x1b[38;2;242;244;247m";
+const RESET = "\x1b[0m";
+const INSET = "  ";
+
+type FooterState = {
+	modelLine: string;
+	contextDisplay: string;
+	userLine: string;
+	costLine: string;
+};
+
+function formatTokens(count: number): string {
+	if (!Number.isFinite(count) || count <= 0) return "0";
+	if (count < 1000) return String(Math.round(count));
+	if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+	if (count < 1000000) return `${Math.round(count / 1000)}k`;
+	if (count < 10000000) return `${(count / 1000000).toFixed(1)}M`;
+	return `${Math.round(count / 1000000)}M`;
+}
+
+function joinLeftRight(left: string, right: string, width: number): string {
+	const leftWidth = visibleWidth(left);
+	const rightWidth = visibleWidth(right);
+	if (leftWidth + rightWidth + 1 <= width) {
+		const pad = " ".repeat(Math.max(1, width - leftWidth - rightWidth));
+		return `${left}${pad}${right}`;
+	}
+	const targetLeft = Math.max(1, width - rightWidth - 1);
+	const truncLeft = truncateToWidth(left, targetLeft, "...");
+	const pad = " ".repeat(Math.max(1, width - visibleWidth(truncLeft) - rightWidth));
+	return `${truncLeft}${pad}${right}`;
+}
+
+function computeFooterState(pi: ExtensionAPI, ctx: ExtensionContext): FooterState {
+	const modelId = ctx.model?.id ?? "no-model";
+	const thinking = ctx.model?.reasoning ? pi.getThinkingLevel() : "off";
+	const modelLine = `${modelId} • ${thinking}`;
+
+	const context = ctx.getContextUsage();
+	const contextWindow = context?.contextWindow ?? ctx.model?.contextWindow ?? 0;
+	const pct = context?.percent;
+	const contextPct = pct == null ? "?" : `${pct.toFixed(1)}%`;
+	const contextDisplay = `${contextPct}/${formatTokens(contextWindow)} (auto)`;
+
+	let totalCost = 0;
+	for (const entry of ctx.sessionManager.getEntries()) {
+		if (entry.type !== "message" || entry.message.role !== "assistant") continue;
+		totalCost += entry.message.usage?.cost?.total ?? 0;
+	}
+	const costLine = `$${totalCost.toFixed(3)}`;
+	return {
+		modelLine,
+		contextDisplay,
+		userLine: "",
+		costLine,
+	};
+}
+
+export default function footerExtension(pi: ExtensionAPI) {
+	const state: FooterState = {
+		modelLine: "no-model • off",
+		contextDisplay: "?/0 (auto)",
+		userLine: "",
+		costLine: "$0.000",
+	};
+let requestRender: (() => void) | undefined;
+let lastCtx: ExtensionContext | undefined;
+
+	const refresh = (ctx: ExtensionContext) => {
+		const next = computeFooterState(pi, ctx);
+		state.modelLine = next.modelLine;
+		state.contextDisplay = next.contextDisplay;
+		state.costLine = next.costLine;
+		requestRender?.();
+	};
+
+	pi.on("session_start", (_event, ctx) => {
+		if (!ctx.hasUI) return;
+		lastCtx = ctx;
+		refresh(ctx);
+		ctx.ui.setFooter((tui, theme, footerData) => {
+			requestRender = () => tui.requestRender();
+			return {
+				render(width: number): string[] {
+					if (!uiState.ready) return [];
+					const usableWidth = Math.max(1, width - visibleWidth(INSET));
+					if (lastCtx) {
+						const live = computeFooterState(pi, lastCtx);
+						state.modelLine = live.modelLine;
+						state.contextDisplay = live.contextDisplay;
+						state.costLine = live.costLine;
+					}
+					state.userLine = footerData.getExtensionStatuses().get("seed") ?? "";
+					const topRight = theme.fg("dim", `${state.costLine} • ${state.contextDisplay}`);
+					const top = theme.fg("dim", truncateToWidth(state.modelLine, usableWidth));
+					const topAligned = joinLeftRight(top, topRight, usableWidth);
+					if (!state.userLine) return [`${INSET}${topAligned}`];
+					const bottomLeft = `${WHITE}${state.userLine}${RESET}`;
+					const bottom = joinLeftRight(
+						bottomLeft,
+						"",
+						usableWidth,
+					);
+					return [`${INSET}${topAligned}`, `${INSET}${bottom}`];
+				},
+				invalidate() {},
+				dispose() {
+					requestRender = undefined;
+				},
+			};
+		});
+	});
+
+	pi.on("turn_end", (_event, ctx) => {
+		if (!ctx.hasUI) return;
+		refresh(ctx);
+	});
+
+	pi.on("model_select", (_event, ctx) => {
+		if (!ctx.hasUI) return;
+		lastCtx = ctx;
+		refresh(ctx);
+	});
+
+	pi.on("session_switch", (_event, ctx) => {
+		if (!ctx.hasUI) return;
+		lastCtx = ctx;
+		refresh(ctx);
+	});
+}

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

@@ -5,11 +5,11 @@
 
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import editorExtension from "./editor.js";
-import updateExtension from "./update.js";
+import footerExtension from "./footer.js";
 import welcomeExtension from "./welcome.js";
 
 export default function (pi: ExtensionAPI) {
 	editorExtension(pi);
-	welcomeExtension(pi, { enableFrame: true });
-	updateExtension(pi);
+	footerExtension(pi);
+	welcomeExtension(pi, { enableFrame: false });
 }

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

@@ -0,0 +1,4 @@
+export const uiState = {
+	ready: false,
+};
+

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

@@ -49,25 +49,5 @@ function getLatestVersion(): Promise<string | null> {
 }
 
 export default function (pi: ExtensionAPI) {
-	// Check for updates on session start (background, non-blocking)
-	pi.on("session_start", async (_event, ctx) => {
-		if (!ctx.hasUI) return;
-
-		const installed = getInstalledVersion();
-		if (!installed) return;
-
-		try {
-			const latest = await getLatestVersion();
-			if (!latest) return;
-
-			if (compareSemver(latest, installed.seedclubVersion) > 0) {
-				ctx.ui.setWidget("seedclub-update", [
-					`⚡ seedclub v${latest} available (current: v${installed.seedclubVersion})`,
-					`   Run: seedclub update`,
-				]);
-			}
-		} catch {
-			// Silent — no network is fine
-		}
-	});
+	void pi;
 }

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

@@ -1,16 +1,23 @@
 /**
  * Welcome header with live weather + market data.
- * /commands and /extensions still available as commands.
+ * /commands and /extensions are available as commands.
  */
 
 import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { uiState } from "./state.js";
 
-const EMERALD = "\x1b[38;2;80;200;120m";
+const EMERALD = "\x1b[38;2;39;163;91m";
 const DODGER = "\x1b[38;2;30;144;255m";
 const RED = "\x1b[38;2;255;0;0m";
 const DIM = "\x1b[38;2;85;85;85m";
 const WHITE = "\x1b[38;2;200;200;200m";
+const GRAY_MID = "\x1b[38;2;160;160;160m";
+const GRAY_DIM = "\x1b[38;2;115;115;115m";
+const WHITE_BRIGHT = "\x1b[38;2;236;236;236m";
 const BOLD = "\x1b[1m";
 const RESET = "\x1b[0m";
 
@@ -130,29 +137,105 @@ async function getData() {
 	return { weather, market };
 }
 
+function hasSeedConnection(): boolean {
+	if (process.env.SEEDCLUB_TOKEN || process.env.SEED_NETWORK_TOKEN) return true;
+	const tokenPath = join(homedir(), ".config", "seedclub", "token");
+	return existsSync(tokenPath);
+}
+
 function formatQuote(q: MarketQuote): string {
 	const color = q.change.startsWith("+") ? EMERALD : q.change.startsWith("-") ? RED : DIM;
 	return `${WHITE}${q.symbol}${RESET} ${DIM}${q.price}${RESET} ${color}${q.pct}${RESET}`;
 }
 
-const EMERALD_ANSI = "\x1b[38;2;80;200;120m";
+const EMERALD_ANSI = "\x1b[38;2;39;163;91m";
+
+function renderCoinLoaderLines(frame: number): string[] {
+	const rawShape = [
+		"        XXXXXX    XXXXXX",
+		"       XXXXXX    XXXXXX",
+		"      XXXXXX    XXXXXX",
+		"     XXXXXX    XXXXXX",
+		"    XXXXXX    XXXXXX",
+		"   XXXXXX    XXXXXX",
+		"            XXXXXX",
+		"           XXXXXX",
+		"          XXXXXX",
+		"         XXXXXX",
+		"        XXXXXX",
+		"       XXXXXX",
+		"      XXXXXX",
+		"     XXXXXX",
+		"    XXXXXX",
+		"   XXXXXX",
+	];
+	const cols = rawShape.reduce((max, row) => Math.max(max, row.length), 0);
+	const shape = rawShape.map((row) => row.padEnd(cols, " "));
+	const rows = shape.length;
+	const texture = [" ", ".", ":", "-", "=", "+", "*", "#"] as const;
+
+	const lines: string[] = [];
+	for (let r = 0; r < rows; r++) {
+		let line = "  ";
+		for (let c = 0; c < cols; c++) {
+			if (shape[r]![c] !== "X") {
+				line += " ";
+				continue;
+			}
+
+			// Diagonal wipe: bright band moves across cube faces.
+			const wipePos = (frame * 1.1) % (cols + 12);
+			const dist = Math.abs(c + r * 0.6 - wipePos);
+			const glow = Math.max(0, 1 - dist / 8);
+			const base = ((Math.sin(frame * 0.18 + c * 0.21 - r * 0.33) + 1) / 2) * 0.35;
+			const intensity = Math.max(0, Math.min(1, base + glow * 0.85));
+
+			const idx = Math.min(texture.length - 1, Math.max(1, Math.floor(intensity * texture.length)));
+			const glyph = texture[idx]!;
+
+			if (intensity > 0.72) {
+				line += `${WHITE_BRIGHT}${glyph}${RESET}`;
+			} else if (intensity > 0.38) {
+				line += `${GRAY_MID}${glyph}${RESET}`;
+			} else {
+				line += `${GRAY_DIM}${glyph}${RESET}`;
+			}
+		}
+		lines.push(line);
+	}
+
+	const loadingLabel = "loading...";
+	const loadingIndent = " ".repeat(2 + Math.max(0, Math.floor((cols - loadingLabel.length) / 2)));
+	return [...lines, "", `${loadingIndent}${DIM}${loadingLabel}${RESET}`];
+}
 
 export default function (pi: ExtensionAPI, options?: { enableFrame?: boolean }) {
 	let headerLines: string[] = [
 		"",
 		`  ${EMERALD}${BOLD}The Human+ Venture Network${RESET}`,
 		"",
-		`  ${DIM}loading...${RESET}`,
+		...renderCoinLoaderLines(0),
 		"",
 	];
 
 	pi.on("session_start", async (_event, ctx) => {
 		if (!ctx.hasUI) return;
+		uiState.ready = false;
+		const hasAnyAuth = ctx.modelRegistry.getAvailable().length > 0;
+		const hasSelectedModel = !!ctx.model;
+		const connectedToSeed = hasSeedConnection();
+		const setupHints: string[] = [];
+		if (!hasAnyAuth) setupHints.push("/login");
+		if (!hasSelectedModel) setupHints.push("/model");
+		if (!connectedToSeed) setupHints.push("/connect");
 
 		let tuiRef: any = null;
+		let loaderFrame = 0;
+		let loaderTimer: ReturnType<typeof setInterval> | undefined;
 
 		ctx.ui.setHeader((tui, _theme) => {
 			tuiRef = tui;
+			tui.setClearOnShrink(true);
 
 			// Enable window frame around entire TUI (footer excluded)
 			if (options?.enableFrame && tui.setFrame) {
@@ -172,10 +255,34 @@ export default function (pi: ExtensionAPI, options?: { enableFrame?: boolean })
 			};
 		});
 
+		loaderTimer = setInterval(() => {
+			if (uiState.ready) return;
+			headerLines = [
+				"",
+				`  ${EMERALD}${BOLD}The Human+ Venture Network${RESET}`,
+				"",
+				...renderCoinLoaderLines(loaderFrame++),
+				"",
+			];
+			tuiRef?.requestRender();
+		}, 120);
+
 		try {
 			const { weather, market } = await getData();
 			const weatherLine = `  ${weather.icon} ${WHITE}${weather.temp}${RESET} ${DIM}${weather.condition}${RESET}  ${DIM}·${RESET}  ${DIM}${weather.location}${RESET}`;
 			const marketLine = `  ${market.map(formatQuote).join(`  ${DIM}·${RESET}  `)}`;
+			const setupLines = setupHints.flatMap((hint) => {
+				if (hint === "/login") {
+					return [`  ${WHITE}/login${RESET} ${DIM}sign in with Anthropic, OpenAI, Gemini, or others${RESET}`];
+				}
+				if (hint === "/model") {
+					return [`  ${WHITE}/model${RESET} ${DIM}choose your model${RESET}`];
+				}
+				if (hint === "/connect") {
+					return [`  ${WHITE}/connect${RESET} ${DIM}to seeclub.com${RESET}`];
+				}
+				return [`  ${WHITE}${hint}${RESET}`];
+			});
 
 			headerLines = [
 				"",
@@ -184,20 +291,45 @@ export default function (pi: ExtensionAPI, options?: { enableFrame?: boolean })
 				weatherLine,
 				marketLine,
 				"",
-				`  ${DIM}type ${WHITE}/${RESET}${DIM} to see commands${RESET}`,
+				...setupLines,
 				"",
 			];
 			tuiRef?.requestRender();
 		} catch {
+			const setupLines = setupHints.flatMap((hint) => {
+				if (hint === "/login") {
+					return [`  ${WHITE}/login${RESET} ${DIM}sign in with Anthropic, OpenAI, Gemini, or others${RESET}`];
+				}
+				if (hint === "/model") {
+					return [`  ${WHITE}/model${RESET} ${DIM}choose your model${RESET}`];
+				}
+				if (hint === "/connect") {
+					return [`  ${WHITE}/connect${RESET} ${DIM}to seeclub.com${RESET}`];
+				}
+				return [`  ${WHITE}${hint}${RESET}`];
+			});
 			headerLines = [
 				"",
 				`  ${EMERALD}${BOLD}The Human+ Venture Network${RESET}`,
 				"",
-				`  ${DIM}type ${WHITE}/${RESET}${DIM} to see commands${RESET}`,
+				...setupLines,
 				"",
 			];
 			tuiRef?.requestRender();
+		} finally {
+			if (loaderTimer) clearInterval(loaderTimer);
 		}
+		uiState.ready = true;
+		ctx.ui.setEditorText("");
+	});
+
+	pi.on("input", async (event, ctx) => {
+		if (event.source !== "interactive") return;
+		if (!uiState.ready) return { action: "handled" };
+		if (event.text.trim().startsWith("/")) return;
+		if (ctx.model) return;
+		ctx.ui.notify("Set up first: /login, then /model, then /connect.", "info");
+		return { action: "handled" };
 	});
 
 	pi.registerCommand("commands", {

package/assets/theme/{seedclub.json → dark.json}

@@ -1,23 +1,23 @@
 {
 	"$schema": "https://raw.githubusercontent.com/badlogic/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
-	"name": "seedclub",
+	"name": "dark",
 	"vars": {
-		"brand": "#00C853",
-		"brandDim": "#00963F",
-		"brandLight": "#69F0AE",
-		"warmWhite": "#E8E6E3",
-		"coolGray": "#8A8F98",
-		"dimGray": "#5C6370",
-		"darkGray": "#3E4451",
-		"deepBg": "#1A1D23",
-		"cardBg": "#21252B",
-		"surfaceBg": "#282C34",
-		"red": "#E06C75",
-		"yellow": "#E5C07B",
-		"blue": "#61AFEF",
+		"brand": "#3EBE4D",
+		"brandDim": "#3EBE4D",
+		"brandLight": "#3EBE4D",
+		"warmWhite": "#F2F4F7",
+		"coolGray": "#B8B8B8",
+		"dimGray": "#909090",
+		"darkGray": "#5F5F5F",
+		"deepBg": "#111111",
+		"cardBg": "#1D1D1D",
+		"surfaceBg": "#262626",
+		"red": "#E1251B",
+		"yellow": "#F0B323",
+		"blue": "#1E90FF",
 		"purple": "#C678DD",
 		"cyan": "#56B6C2",
-		"green": "#98C379"
+		"green": "#3EBE4D"
 	},
 	"colors": {
 		"accent": "brand",
@@ -32,40 +32,40 @@
 		"text": "",
 		"thinkingText": "coolGray",
 
-		"selectedBg": "#2C3340",
-		"userMessageBg": "surfaceBg",
+		"selectedBg": "surfaceBg",
+		"userMessageBg": "#141414",
 		"userMessageText": "",
-		"customMessageBg": "cardBg",
+		"customMessageBg": "surfaceBg",
 		"customMessageText": "",
 		"customMessageLabel": "brand",
 		"toolPendingBg": "deepBg",
-		"toolSuccessBg": "#1A2E1A",
-		"toolErrorBg": "#2E1A1A",
-		"toolTitle": "brandLight",
+		"toolSuccessBg": "#0F0F0F",
+		"toolErrorBg": "#180D0D",
+		"toolTitle": "warmWhite",
 		"toolOutput": "coolGray",
 
 		"mdHeading": "yellow",
 		"mdLink": "blue",
 		"mdLinkUrl": "dimGray",
-		"mdCode": "cyan",
-		"mdCodeBlock": "green",
+		"mdCode": "blue",
+		"mdCodeBlock": "coolGray",
 		"mdCodeBlockBorder": "coolGray",
 		"mdQuote": "coolGray",
 		"mdQuoteBorder": "coolGray",
 		"mdHr": "darkGray",
-		"mdListBullet": "brand",
+		"mdListBullet": "coolGray",
 
 		"toolDiffAdded": "green",
 		"toolDiffRemoved": "red",
 		"toolDiffContext": "coolGray",
 
-		"syntaxComment": "#7F848E",
-		"syntaxKeyword": "purple",
+		"syntaxComment": "#888888",
+		"syntaxKeyword": "warmWhite",
 		"syntaxFunction": "blue",
-		"syntaxVariable": "red",
-		"syntaxString": "green",
-		"syntaxNumber": "#D19A66",
-		"syntaxType": "cyan",
+		"syntaxVariable": "coolGray",
+		"syntaxString": "coolGray",
+		"syntaxNumber": "coolGray",
+		"syntaxType": "blue",
 		"syntaxOperator": "warmWhite",
 		"syntaxPunctuation": "coolGray",
 
@@ -74,13 +74,13 @@
 		"thinkingLow": "brandDim",
 		"thinkingMedium": "brand",
 		"thinkingHigh": "brandLight",
-		"thinkingXhigh": "#B9F6CA",
+		"thinkingXhigh": "#8CBFAD",
 
 		"bashMode": "yellow"
 	},
 	"export": {
-		"pageBg": "#1A1D23",
-		"cardBg": "#21252B",
-		"infoBg": "#2A2D25"
+		"pageBg": "#111111",
+		"cardBg": "#1D1D1D",
+		"infoBg": "#262626"
 	}
 }

package/assets/theme/light.json

@@ -0,0 +1,86 @@
+{
+	"$schema": "https://raw.githubusercontent.com/badlogic/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+	"name": "light",
+	"vars": {
+		"brand": "#3EBE4D",
+		"brandDim": "#3EBE4D",
+		"brandLight": "#3EBE4D",
+		"warmWhite": "#1F2730",
+		"coolGray": "#666666",
+		"dimGray": "#7A7A7A",
+		"darkGray": "#CCCCCC",
+		"deepBg": "#F4F4F4",
+		"cardBg": "#ECECEC",
+		"surfaceBg": "#E4E4E4",
+		"red": "#D91F16",
+		"yellow": "#B57900",
+		"blue": "#1E90FF",
+		"purple": "#7D5AC8",
+		"cyan": "#227E90",
+		"green": "#3EBE4D"
+	},
+	"colors": {
+		"accent": "brand",
+		"border": "brandDim",
+		"borderAccent": "brandLight",
+		"borderMuted": "darkGray",
+		"success": "green",
+		"error": "red",
+		"warning": "yellow",
+		"muted": "coolGray",
+		"dim": "dimGray",
+		"text": "warmWhite",
+		"thinkingText": "coolGray",
+
+		"selectedBg": "surfaceBg",
+		"userMessageBg": "#CECECE",
+		"userMessageText": "warmWhite",
+		"customMessageBg": "surfaceBg",
+		"customMessageText": "warmWhite",
+		"customMessageLabel": "brand",
+		"toolPendingBg": "cardBg",
+		"toolSuccessBg": "#C6C6C6",
+		"toolErrorBg": "#E6D6D6",
+		"toolTitle": "warmWhite",
+		"toolOutput": "coolGray",
+
+		"mdHeading": "yellow",
+		"mdLink": "blue",
+		"mdLinkUrl": "dimGray",
+		"mdCode": "blue",
+		"mdCodeBlock": "coolGray",
+		"mdCodeBlockBorder": "coolGray",
+		"mdQuote": "coolGray",
+		"mdQuoteBorder": "coolGray",
+		"mdHr": "darkGray",
+		"mdListBullet": "coolGray",
+
+		"toolDiffAdded": "green",
+		"toolDiffRemoved": "red",
+		"toolDiffContext": "coolGray",
+
+		"syntaxComment": "#7A7A7A",
+		"syntaxKeyword": "warmWhite",
+		"syntaxFunction": "blue",
+		"syntaxVariable": "coolGray",
+		"syntaxString": "coolGray",
+		"syntaxNumber": "coolGray",
+		"syntaxType": "blue",
+		"syntaxOperator": "warmWhite",
+		"syntaxPunctuation": "coolGray",
+
+		"thinkingOff": "darkGray",
+		"thinkingMinimal": "dimGray",
+		"thinkingLow": "brandDim",
+		"thinkingMedium": "brand",
+		"thinkingHigh": "brandLight",
+		"thinkingXhigh": "#2F5C4A",
+
+		"bashMode": "yellow"
+	},
+	"export": {
+		"pageBg": "#F4F4F4",
+		"cardBg": "#ECECEC",
+		"infoBg": "#E4E4E4"
+	}
+}

package/bin/cli.js

@@ -3,12 +3,15 @@
 
 const { execFileSync, spawn } = require("child_process");
 const { readFileSync, existsSync, writeFileSync, unlinkSync } = require("fs");
-const { join, dirname } = require("path");
+const { join, dirname, basename } = require("path");
 const { homedir } = require("os");
 const readline = require("readline");
 
 const SC_DIR = join(homedir(), ".seedclub", "agent");
 const VERSION_FILE = join(SC_DIR, ".seedclub-version");
+const PI_MAIN_LAUNCHER = join(__dirname, "pi-main-launcher.js");
+process.title = "seedclub";
+const SEEDCLUB_ENV_EXCLUDE = new Set(["SEEDCLUB_NPM_TOKEN", "SEEDCLUB_PI_MAIN"]);
 
 function printPrivateRegistryHint() {
 	console.error("seedclub: install/update failed.");
@@ -114,6 +117,51 @@ function withOptionalEphemeralNpmrc(run) {
 	}
 }
 
+function findPackageRoot(fromFile, expectedName) {
+	let dir = dirname(fromFile);
+	while (true) {
+		const pkgPath = join(dir, "package.json");
+		if (existsSync(pkgPath)) {
+			try {
+				const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+				if (!expectedName || pkg.name === expectedName) {
+					return { dir, pkgPath, pkg };
+				}
+			} catch {}
+		}
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	throw new Error(`Could not find package root for ${expectedName || "module"}`);
+}
+
+function resolvePackageJsonPath(packageName, extraBaseDirs = []) {
+	const searchDirs = [];
+	for (const baseDir of extraBaseDirs) {
+		searchDirs.push(join(baseDir, "node_modules"));
+	}
+	const resolverDirs = require.resolve.paths(packageName) || [];
+	searchDirs.push(...resolverDirs);
+	for (const dir of searchDirs) {
+		const pkgPath = join(dir, packageName, "package.json");
+		if (existsSync(pkgPath)) return pkgPath;
+	}
+	throw new Error(`Package not found: ${packageName}`);
+}
+
+function mapSeedclubEnvToPiEnv(env) {
+	for (const [key, value] of Object.entries(env)) {
+		if (!key.startsWith("SEEDCLUB_") || SEEDCLUB_ENV_EXCLUDE.has(key)) continue;
+		const suffix = key.slice("SEEDCLUB_".length);
+		if (!suffix) continue;
+		const piKey = `PI_${suffix}`;
+		if (env[piKey] === undefined && value !== undefined) {
+			env[piKey] = value;
+		}
+	}
+}
+
 // ── Subcommands ──────────────────────────────────────────────────────────
 
 const cmd = process.argv[2];
@@ -157,23 +205,30 @@ if (cmd !== "setup-auth") {
 	// ── Resolve pi binary ───────────────────────────────────────────────────
 
 	let piBin;
+	let piEntry;
+	let piMainPath;
 	try {
-		const piPkgPath = join(
+		const piPkgPath = resolvePackageJsonPath("@mariozechner/pi-coding-agent", [
 			__dirname,
-			"..",
-			"node_modules",
-			"@mariozechner",
-			"pi-coding-agent",
-			"package.json",
+			process.cwd(),
+		]);
+		const { dir: piPkgDir, pkg: piPkg } = findPackageRoot(
+			piPkgPath,
+			"@mariozechner/pi-coding-agent",
 		);
-		if (!existsSync(piPkgPath)) {
-			throw new Error("pi package.json not found in package-local node_modules");
-		}
-		const piPkg = JSON.parse(readFileSync(piPkgPath, "utf-8"));
 		const binEntry = piPkg.bin && (piPkg.bin.pi || Object.values(piPkg.bin)[0]);
 		if (!binEntry) throw new Error("No bin entry in pi package.json");
-		piBin = join(dirname(piPkgPath), binEntry);
+		piBin = join(piPkgDir, binEntry);
 		if (!existsSync(piBin)) throw new Error(`pi bin not found at ${piBin}`);
+		piEntry = piBin;
+		// pi's CLI shim hardcodes process.title = "pi"; call main.js directly to keep Seedclub naming.
+		if (basename(piBin) === "cli.js") {
+			const mainCandidate = join(dirname(piBin), "main.js");
+			if (existsSync(mainCandidate)) {
+				piMainPath = mainCandidate;
+				piEntry = PI_MAIN_LAUNCHER;
+			}
+		}
 	} catch (err) {
 		console.error("seedclub: could not locate pi runtime. Reinstall with:");
 		console.error("  npm install -g @clubnet/seedclub");
@@ -182,16 +237,21 @@ if (cmd !== "setup-auth") {
 
 	// ── Environment ─────────────────────────────────────────────────────────
 
+	mapSeedclubEnvToPiEnv(process.env);
 	process.env.PI_CODING_AGENT_DIR = SC_DIR;
 	process.env.PI_SKIP_VERSION_CHECK = "1";
+	if (!process.env.PI_CLEAR_ON_SHRINK) process.env.PI_CLEAR_ON_SHRINK = "1";
+	process.env.PI_HARDWARE_CURSOR = "0";
+	if (piMainPath) process.env.SEEDCLUB_PI_MAIN = piMainPath;
 	process.env.NODE_OPTIONS = `--no-warnings ${process.env.NODE_OPTIONS || ""}`.trim();
 
 	// ── Spawn pi ────────────────────────────────────────────────────────────
 
 	const args = process.argv.slice(2);
-	const child = spawn(process.execPath, [piBin, ...args], {
+	const child = spawn(process.execPath, [piEntry, ...args], {
 		stdio: "inherit",
 		env: process.env,
+		argv0: "seedclub",
 	});
 
 	child.on("exit", (code, signal) => {

package/bin/pi-main-launcher.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+"use strict";
+
+const { pathToFileURL } = require("url");
+const { dirname, join } = require("path");
+const { existsSync } = require("fs");
+
+process.title = "seedclub";
+
+async function patchInteractiveWarnings(piMainPath) {
+	try {
+		const interactiveModePath = join(dirname(piMainPath), "modes", "interactive", "interactive-mode.js");
+		if (!existsSync(interactiveModePath)) return;
+		const interactiveModeUrl = pathToFileURL(interactiveModePath).href;
+		const mod = await import(interactiveModeUrl);
+		const InteractiveMode = mod?.InteractiveMode;
+		if (!InteractiveMode?.prototype?.showWarning) return;
+
+		const originalShowWarning = InteractiveMode.prototype.showWarning;
+		InteractiveMode.prototype.showWarning = function (message, ...args) {
+			if (
+				typeof message === "string" &&
+				message.includes("No models available. Use /login or set an API key environment variable")
+			) {
+				return;
+			}
+			return originalShowWarning.call(this, message, ...args);
+		};
+	} catch {
+		// Best-effort patch; ignore if pi internals change.
+	}
+}
+
+async function run() {
+	const piMainPath = process.env.SEEDCLUB_PI_MAIN;
+	if (!piMainPath) {
+		throw new Error("Missing SEEDCLUB_PI_MAIN");
+	}
+	await patchInteractiveWarnings(piMainPath);
+	const mainUrl = pathToFileURL(piMainPath).href;
+	const mod = await import(mainUrl);
+	if (!mod || typeof mod.main !== "function") {
+		throw new Error(`Invalid pi main entry: ${piMainPath}`);
+	}
+	await mod.main(process.argv.slice(2));
+}
+
+run().catch((err) => {
+	console.error(err instanceof Error ? err.stack || err.message : String(err));
+	process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubnet/seedclub",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "The Human+ Venture Network — AI agent for deal sourcing, research, and signal tracking",
   "license": "MIT",
   "repository": {

package/postinstall.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync, rmSync } = require("fs");
+const { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync, rmSync, readdirSync } = require("fs");
 const { join } = require("path");
 const { homedir } = require("os");
 const { execFileSync } = require("child_process");
@@ -33,13 +33,15 @@ for (const dir of ["extensions", "themes", "prompts"]) {
 	mkdirSync(join(SC_DIR, dir), { recursive: true });
 }
 
-// ── 2. Copy theme ───────────────────────────────────────────────────────
+// ── 2. Copy themes ──────────────────────────────────────────────────────
 
-const themeSrc = join(PKG_ROOT, "assets", "theme", "seedclub.json");
-const themeDest = join(SC_DIR, "themes", "seedclub.json");
-if (existsSync(themeSrc)) {
-	cpSync(themeSrc, themeDest);
-	ok("Installed theme");
+const themeDir = join(PKG_ROOT, "assets", "theme");
+if (existsSync(themeDir)) {
+	for (const file of readdirSync(themeDir)) {
+		if (!file.endsWith(".json")) continue;
+		cpSync(join(themeDir, file), join(SC_DIR, "themes", file));
+	}
+	ok("Installed themes");
 }
 
 // ── 3. Copy extensions ──────────────────────────────────────────────────
@@ -89,13 +91,22 @@ if (!existsSync(settingsFile)) {
 	writeFileSync(
 		settingsFile,
 		JSON.stringify(
-			{ theme: "seedclub", quietStartup: true, enableSkillCommands: true },
+			{ theme: "dark", quietStartup: true, enableSkillCommands: true },
 			null,
 			2,
 		) + "\n",
 	);
 	ok("Created default settings");
 } else {
+	// Migrate legacy theme name to the current dark/light naming.
+	try {
+		const raw = JSON.parse(readFileSync(settingsFile, "utf-8"));
+		if (raw && typeof raw === "object" && raw.theme === "seedclub") {
+			raw.theme = "dark";
+			writeFileSync(settingsFile, JSON.stringify(raw, null, 2) + "\n");
+			ok("Migrated theme: seedclub -> dark");
+		}
+	} catch {}
 	ok("Settings already exist (preserved)");
 }