@clubnet/seedclub 0.2.7 → 0.2.9

package/README.md

@@ -201,13 +201,16 @@ npm publish
 
 For reproducible extension dependency installs, commit `assets/extensions/seedclub/package-lock.json` and keep it in sync when changing extension deps.
 
-### Release checklist
+### Release process
 
-1. Test new pi version locally
-2. Test extensions work
-3. Bump version in `package.json`
-4. Push to main
-5. `npm publish`
+Standard order: **GitHub first, npm second**. Always publish from a tagged commit on `main`.
+
+1. Create a branch, make changes, open PR
+2. Merge to `main`
+3. Pull `main`, run `npm install -g ./` and smoke test (`seedclub`)
+4. Bump version: `npm version patch|minor|major` (creates a git tag)
+5. Push commits + tags: `git push --follow-tags`
+6. Publish from that tag: `npm publish`
 
 ### Publishing
 

package/assets/extensions/seedclub/branding.ts

@@ -0,0 +1,39 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+const BRANDING_INSTRUCTIONS = `
+IMPORTANT BRANDING RULES:
+- Always refer to the product as Seed Club.
+- Never mention the name \"pi\" in any response.
+- If the user mentions \"pi\", interpret it as Seed Club and respond using \"Seed Club\".
+- When summarizing intent or describing the system, use Seed Club wording only.
+`;
+
+const BRAND_REGEX = /\bpi\b/gi;
+
+function replaceBranding(text: string): string {
+	return text.replace(BRAND_REGEX, "Seed Club");
+}
+
+export default function registerBrandingGuard(pi: ExtensionAPI) {
+	pi.on("before_agent_start", async (event) => {
+		return {
+			systemPrompt: `${event.systemPrompt}\n${BRANDING_INSTRUCTIONS}`,
+		};
+	});
+
+	pi.on("input", async (event) => {
+		if (event.source === "extension") return { action: "continue" };
+		const nextText = replaceBranding(event.text);
+		if (nextText !== event.text) return { action: "transform", text: nextText };
+		return { action: "continue" };
+	});
+
+	pi.on("tool_result", async (event) => {
+		const nextContent = event.content.map((item) => {
+			if (item.type !== "text") return item;
+			const nextText = replaceBranding(item.text);
+			return nextText === item.text ? item : { ...item, text: nextText };
+		});
+		return { content: nextContent };
+	});
+}

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

@@ -0,0 +1,169 @@
+/**
+ * /extract — the main entry point for the extraction system.
+ *
+ * Usage:
+ *   /extract <url>              — Capture + extract a URL into the 9-dimension schema
+ *   /extract                    — Extract from content already in the conversation
+ *   /extract clubtone           — Turn the last extraction into content directions
+ *
+ * Flow:
+ *   1. User shares a URL or pastes content
+ *   2. /extract captures it (L1) and runs 9-dimension extraction (L2)
+ *   3. /extract clubtone takes the extraction and generates content seeds
+ */
+
+import type { ExtensionAPI } from "@mariozechner/Seed Club-coding-agent";
+import { capture } from "../extraction/capture.js";
+import { buildExtractionPrompt, buildContentSeedPrompt } from "../extraction/schema.js";
+
+export function registerExtractCommand(pi: ExtensionAPI) {
+	// ── /extract command ──────────────────────────────────────────────
+
+	pi.registerCommand("extract", {
+		description: "Extract structured knowledge from a URL or conversation content",
+		handler: async (args, ctx) => {
+			const arg = args?.trim() || "";
+
+			// /extract clubtone — content seed pass
+			if (arg === "clubtone" || arg === "club" || arg === "tone" || arg === "seeds" || arg === "content") {
+				pi.sendUserMessage(
+					`Look at the most recent extraction in our conversation. Now turn it into content directions using this approach:\n\n` +
+						`Generate 3-5 content directions I could take. For each:\n` +
+						`1. **Hook** — opening line that stops a scroll\n` +
+						`2. **Core argument** — what I'd actually say, grounded in the source\n` +
+						`3. **Format** — tweet thread, short post, essay, newsletter, conversation starter\n` +
+						`4. **Source grounding** — which claims, patterns, quotes feed this\n` +
+						`5. **Voice note** — how I'd explain this to a friend in 2 sentences\n\n` +
+						`Don't be generic. These should feel like things only someone who deeply read the source would write. My voice, not the source's voice.`,
+				);
+				return;
+			}
+
+			// /extract <url> — capture + extract
+			const url = extractUrl(arg);
+			if (url) {
+				ctx.ui.notify(`Capturing ${url}...`, "info");
+
+				const result = await capture(url, pi);
+				if (!result.complete || !result.content) {
+					ctx.ui.notify(`Failed to capture ${url}${result.note ? `: ${result.note}` : ""}`, "error");
+					return;
+				}
+
+				const title = extractTitle(result.content) || new URL(url).hostname;
+				ctx.ui.notify(`Captured (${result.fetchMethod}). Running extraction...`, "info");
+
+				// Truncate if massive — keep first 40K chars for extraction
+				const content = result.content.length > 40000
+					? result.content.slice(0, 40000) + "\n\n[Content truncated at 40K chars]"
+					: result.content;
+
+				const prompt = buildExtractionPrompt(content, url, title);
+				pi.sendUserMessage(
+					prompt +
+					"
+
+After completing the extraction, call seed_save_extraction with the structured results so they are saved to persistent memory. Include all 9 dimensions."
+				);
+				return;
+			}
+
+			// /extract (no args) — extract from conversation context
+			if (!arg) {
+				pi.sendUserMessage(
+					`Look at the content I've shared in this conversation (URLs, pasted text, documents, etc.) and run a full 9-dimension extraction:\n\n` +
+						`1. **Summary** — 2-3 sentences\n` +
+						`2. **Claims & Arguments** — every claim including implicit ones, with evidence and confidence\n` +
+						`3. **Entities** — people, orgs, concepts, products, technologies\n` +
+						`4. **Temporal** — only if time-sensitive, otherwise skip\n` +
+						`5. **Quotes** — direct quotes worth preserving\n` +
+						`6. **Patterns & Themes** ⭐ — highest value; patterns and how they connect to my work\n` +
+						`7. **Relevance** — which areas this matters for and why\n` +
+						`8. **Actionable** — content seeds, follow-ups, research threads\n` +
+						`9. **Extraction Notes** — your observations on what's rich, what's thin\n\n` +
+						`Be thorough. Single-pass extraction misses ~40% of content. Go deep on patterns, relevance, and actionable items.
+
+After completing the extraction, call seed_save_extraction with the structured results so they are saved to persistent memory.`,
+				);
+				return;
+			}
+
+			// /extract <something that's not a URL> — treat as a topic/concept
+			pi.sendUserMessage(
+				`I want to explore and extract from the concept: "${arg}"\n\n` +
+					`Treat this as source material. Run a full 9-dimension extraction:\n` +
+					`1. **Summary** — what is this concept/topic\n` +
+					`2. **Claims & Arguments** — key claims around this topic\n` +
+					`3. **Entities** — key people, orgs, frameworks\n` +
+					`4. **Temporal** — only if time-sensitive\n` +
+					`5. **Quotes** — notable quotes if you know them\n` +
+					`6. **Patterns & Themes** ⭐ — patterns and connections to broader work\n` +
+					`7. **Relevance** — where this matters\n` +
+					`8. **Actionable** — what can be done with this\n` +
+					`9. **Extraction Notes** — what's rich, what needs more research\n\n` +
+					`Be thorough and connect everything to real work context.
+
+After completing the extraction, call seed_save_extraction with the structured results so they are saved to persistent memory.`,
+			);
+		},
+	});
+
+	// ── /clubtone shorthand ───────────────────────────────────────────
+
+	pi.registerCommand("clubtone", {
+		description: "Turn extracted knowledge into content directions",
+		handler: async (args, ctx) => {
+			const context = args?.trim();
+			const contextLine = context
+				? `\n\nAdditional context for content direction: ${context}`
+				: "";
+
+			pi.sendUserMessage(
+				`Look at the most recent extraction or source material in our conversation. Turn it into content directions.\n\n` +
+					`Generate 3-5 content directions I could take. For each:\n` +
+					`1. **Hook** — opening line that stops a scroll\n` +
+					`2. **Core argument** — what I'd actually say, grounded in the source\n` +
+					`3. **Format** — tweet thread, short post, essay, newsletter, conversation starter\n` +
+					`4. **Source grounding** — which claims, patterns, quotes feed this\n` +
+					`5. **Voice note** — how I'd explain this to a friend in 2 sentences\n\n` +
+					`Don't be generic. My voice, not the source's voice.
+
+After generating content directions, call seed_save_content_seeds to save them (you'll need the extraction ID from the most recent seed_save_extraction call).${contextLine}`,
+			);
+		},
+	});
+}
+
+	// ── /extractions — list saved extractions ─────────────────────────────
+
+	pi.registerCommand("extractions", {
+		description: "Browse your saved extractions",
+		handler: async (args, ctx) => {
+			pi.sendUserMessage(
+				"List my recent extractions using seed_list_extractions. Show them in a clean format with title, date, and counts of patterns/claims/actionable items. If I have none, let me know I can use /extract to get started."
+			);
+		},
+	});
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+function extractUrl(text: string): string | null {
+	// Direct URL
+	if (text.match(/^https?:\/\//)) return text.split(/\s/)[0];
+
+	// URL somewhere in text
+	const match = text.match(/(https?:\/\/[^\s]+)/);
+	return match ? match[1] : null;
+}
+
+function extractTitle(markdown: string): string | null {
+	// Try to find a title from Jina Reader markdown output
+	const titleMatch = markdown.match(/^#\s+(.+)$/m);
+	if (titleMatch) return titleMatch[1].trim();
+
+	// Try Title: header
+	const metaMatch = markdown.match(/^Title:\s*(.+)$/m);
+	if (metaMatch) return metaMatch[1].trim();
+
+	return null;
+}

package/assets/extensions/seedclub/extraction/capture.ts

@@ -0,0 +1,91 @@
+/**
+ * L1 Raw Capture — fetch full-fidelity content from URLs.
+ *
+ * Uses Jina Reader (r.jina.ai) for articles/pages.
+ * Returns markdown content without LLM processing.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/Seed Club-coding-agent";
+
+export interface CaptureResult {
+	content: string;
+	contentType: "markdown" | "text" | "html";
+	fetchMethod: string;
+	complete: boolean;
+	note?: string;
+}
+
+/**
+ * Fetch full content from a URL via Jina Reader.
+ * Returns clean markdown — no summarization, no LLM processing.
+ */
+export async function captureUrl(url: string, pi: ExtensionAPI): Promise<CaptureResult> {
+	const jinaUrl = `https://r.jina.ai/${url}`;
+
+	const result = await pi.exec("curl", ["-sL", "-H", "Accept: text/markdown", jinaUrl], {
+		timeout: 30000,
+	});
+
+	if (result.code !== 0 || !result.stdout?.trim()) {
+		// Fallback: try direct fetch
+		const direct = await pi.exec("curl", ["-sL", url], { timeout: 15000 });
+		if (direct.code === 0 && direct.stdout?.trim()) {
+			return {
+				content: direct.stdout,
+				contentType: "html",
+				fetchMethod: "direct-curl",
+				complete: true,
+				note: "Jina Reader failed; raw HTML captured",
+			};
+		}
+
+		return {
+			content: "",
+			contentType: "text",
+			fetchMethod: "failed",
+			complete: false,
+			note: `Fetch failed for ${url}`,
+		};
+	}
+
+	return {
+		content: result.stdout,
+		contentType: "markdown",
+		fetchMethod: "jina-reader",
+		complete: true,
+	};
+}
+
+/**
+ * Capture a tweet via FxTwitter API (returns JSON with full tweet data).
+ */
+export async function captureTweet(url: string, pi: ExtensionAPI): Promise<CaptureResult> {
+	// Convert x.com/twitter.com URL to fxtwitter API
+	const fxUrl = url
+		.replace("x.com", "api.fxtwitter.com")
+		.replace("twitter.com", "api.fxtwitter.com");
+
+	const result = await pi.exec("curl", ["-sL", fxUrl], { timeout: 15000 });
+
+	if (result.code !== 0 || !result.stdout?.trim()) {
+		// Fallback to Jina
+		return captureUrl(url, pi);
+	}
+
+	return {
+		content: result.stdout,
+		contentType: "text",
+		fetchMethod: "fxtwitter",
+		complete: true,
+	};
+}
+
+/**
+ * Auto-detect content type and use the right capture method.
+ */
+export async function capture(url: string, pi: ExtensionAPI): Promise<CaptureResult> {
+	if (url.match(/(?:x\.com|twitter\.com)\/\w+\/status\/\d+/)) {
+		return captureTweet(url, pi);
+	}
+	return captureUrl(url, pi);
+}

package/assets/extensions/seedclub/extraction/schema.ts

@@ -0,0 +1,184 @@
+/**
+ * L2 Extraction Schema — the 9-dimension extraction format.
+ *
+ * Every source gets extracted into these dimensions.
+ * This is where value compounds — connecting source material to your context.
+ */
+
+export interface Claim {
+	claim: string;
+	evidence: string;
+	confidence: "high" | "medium" | "low";
+	implicit: boolean;
+	notes?: string;
+}
+
+export interface Entity {
+	name: string;
+	type: "person" | "org" | "concept" | "product" | "technology";
+	role: string;
+}
+
+export interface Quote {
+	text: string;
+	attribution: string;
+	context?: string;
+}
+
+export interface Pattern {
+	pattern: string;
+	connection: string; // How it connects to operator's context/work
+	strength: "strong" | "moderate" | "emerging";
+}
+
+export interface Relevance {
+	area: string;
+	rating: "high" | "medium" | "low";
+	why: string;
+}
+
+export interface Actionable {
+	type: "content_seed" | "follow_up" | "design_audit" | "research" | "outreach";
+	description: string;
+	priority: "high" | "medium" | "low";
+}
+
+export interface ExtractionNotes {
+	observations: string[];
+	schemaFitness: string;
+	secondPassCandidate: boolean;
+}
+
+/**
+ * The full L2 extraction output for a single source.
+ */
+export interface L2Extraction {
+	sourceId: string;
+	sourceUrl: string;
+	sourceTitle: string;
+	extractedAt: string;
+
+	// The 9 dimensions
+	summary: string;
+	claims: Claim[];
+	entities: Entity[];
+	temporal?: { events: string[]; note: string }; // Optional — only if time-sensitive
+	quotes: Quote[];
+	patterns: Pattern[];
+	relevance: Relevance[];
+	actionable: Actionable[];
+	extractionNotes: ExtractionNotes;
+}
+
+/**
+ * Returns the extraction prompt for Claude.
+ * This is what gets injected when the user runs /extract.
+ */
+export function buildExtractionPrompt(sourceContent: string, sourceUrl: string, sourceTitle: string): string {
+	return `Extract structured knowledge from this source material using the 9-dimension schema below.
+
+## Source
+- **URL:** ${sourceUrl}
+- **Title:** ${sourceTitle}
+
+## Content
+<source_content>
+${sourceContent}
+</source_content>
+
+## Extraction Schema (9 Dimensions)
+
+Extract into these dimensions. Be thorough — single-pass extraction misses ~40% of content.
+
+### 1. Summary
+2-3 sentences capturing the core contribution.
+
+### 2. Claims & Arguments
+Every claim the source makes, including implicit ones.
+For each: the claim, supporting evidence, confidence (high/medium/low), whether it's implicit, and any notes.
+
+### 3. Entities
+People, organizations, concepts, products, technologies mentioned.
+For each: name, type, and their role in the source.
+
+### 4. Temporal (only if time-sensitive)
+Skip if the content isn't date-dependent. If it is: key events and timeline notes.
+
+### 5. Quotes
+Direct quotes worth preserving, with attribution and context.
+
+### 6. Patterns & Themes ⭐ (highest compound value)
+Patterns you see in this material and how they connect to broader work — strategy, product thinking, market dynamics, creative practice, etc.
+For each: the pattern, the connection to operator context, and strength (strong/moderate/emerging).
+
+### 7. Relevance
+Which areas of work this is relevant to and why.
+Rate each: high/medium/low with explanation.
+
+### 8. Actionable
+Content seeds, follow-ups, research threads, outreach opportunities.
+For each: type, description, priority.
+
+### 9. Extraction Notes
+Your observations about the extraction process itself — what was rich, what was thin, whether a second pass would surface more.
+
+## Output Format
+Return a JSON object matching this schema. Be specific in patterns and relevance — generic observations aren't useful. Connect everything to real work context.
+
+\`\`\`json
+{
+  "sourceId": "extract-${Date.now()}",
+  "sourceUrl": "${sourceUrl}",
+  "sourceTitle": "${sourceTitle}",
+  "extractedAt": "${new Date().toISOString()}",
+  "summary": "...",
+  "claims": [{ "claim": "...", "evidence": "...", "confidence": "high|medium|low", "implicit": false, "notes": "..." }],
+  "entities": [{ "name": "...", "type": "person|org|concept|product|technology", "role": "..." }],
+  "temporal": null,
+  "quotes": [{ "text": "...", "attribution": "...", "context": "..." }],
+  "patterns": [{ "pattern": "...", "connection": "...", "strength": "strong|moderate|emerging" }],
+  "relevance": [{ "area": "...", "rating": "high|medium|low", "why": "..." }],
+  "actionable": [{ "type": "content_seed|follow_up|design_audit|research|outreach", "description": "...", "priority": "high|medium|low" }],
+  "extractionNotes": { "observations": ["..."], "schemaFitness": "...", "secondPassCandidate": false }
+}
+\`\`\``;
+}
+
+/**
+ * Returns a prompt for the "clubtone" / content seed pass.
+ * Takes extraction output and turns it into usable content directions.
+ */
+export function buildContentSeedPrompt(extraction: L2Extraction, userContext?: string): string {
+	const context = userContext
+		? `\n## User Context\n${userContext}\n`
+		: "";
+
+	return `You have a structured extraction from "${extraction.sourceTitle}". Now turn it into content directions — things the user could write, post, discuss, or build on.
+
+## Extraction Summary
+${extraction.summary}
+
+## Key Patterns
+${extraction.patterns.map((p) => `- **${p.pattern}** (${p.strength}): ${p.connection}`).join("\n")}
+
+## Notable Claims
+${extraction.claims.slice(0, 5).map((c) => `- ${c.claim} [${c.confidence}]`).join("\n")}
+
+## Actionable Items
+${extraction.actionable.map((a) => `- [${a.type}] ${a.description} (${a.priority})`).join("\n")}
+
+## Best Quotes
+${extraction.quotes.slice(0, 3).map((q) => `- "${q.text}" — ${q.attribution}`).join("\n")}
+${context}
+## What to Produce
+
+Generate 3-5 **content directions** the user could take. For each:
+
+1. **Hook** — The opening line or angle (something that would stop a scroll)
+2. **Core argument** — What you'd actually say, grounded in the source material
+3. **Format** — Tweet thread, short post, essay section, newsletter bit, conversation starter
+4. **Source grounding** — Which extraction dimensions feed this (cite specific claims, patterns, quotes)
+5. **Voice note** — How you'd explain this to a friend in 2 sentences (this is the vibe check)
+
+Don't be generic. These should feel like things only someone who deeply read this source would write. The user's voice, not the source's voice.`;
+}

package/assets/extensions/seedclub/index.ts

@@ -13,8 +13,11 @@ import { getApiBase, getStoredToken, storeToken } from "./auth.js";
 import { registerAddInterceptor } from "./commands/add.js";
 import { registerSeedclubCommand } from "./commands/seedclub.js";
 import { registerSortCommand } from "./commands/sort.js";
+import { registerExtractCommand } from "./commands/extract.js";
+import { registerExtractionTools } from "./tools/extractions.js";
 import { registerSignalTools } from "./tools/signals.js";
 import { getCurrentUser, registerUtilityTools } from "./tools/utility.js";
+import registerBrandingGuard from "./branding.js";
 
 export default function (pi: ExtensionAPI) {
 	const formatSeedLabel = (name?: string, email?: string) => {
@@ -26,10 +29,15 @@ export default function (pi: ExtensionAPI) {
 	registerSignalTools(pi);
 	registerUtilityTools(pi);
 
+	// Branding guard
+	registerBrandingGuard(pi);
+
 	// Commands — /seedclub menu, /add, /sort
 	registerSeedclubCommand(pi, { connect, disconnect });
 	registerAddInterceptor(pi);
 	registerSortCommand(pi);
+	registerExtractCommand(pi);
+	registerExtractionTools(pi);
 
 	// Show connection status on session start
 	pi.on("session_start", async (_event, ctx) => {

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

@@ -0,0 +1,221 @@
+/**
+ * Extraction tools — save and retrieve extractions from the Seed Club API.
+ *
+ * These tools let the LLM persist extractions after running /extract,
+ * and save content seeds after running /clubtone.
+ */
+
+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";
+
+// ── API handlers ────────────────────────────────────────────────────────
+
+async function saveExtraction(args: {
+	sourceUrl?: string;
+	sourceTitle: string;
+	sourceType?: string;
+	rawContent?: string;
+	fetchMethod?: string;
+	summary?: string;
+	claims?: any[];
+	entities?: any[];
+	temporal?: any;
+	quotes?: any[];
+	patterns?: any[];
+	relevance?: any[];
+	actionable?: any[];
+	extractionNotes?: any;
+	depth?: string;
+	passCount?: number;
+}) {
+	try {
+		const response = await api.post<any>("/extractions", args);
+		return {
+			id: response.extraction.id,
+			sourceTitle: response.extraction.sourceTitle,
+			status: response.extraction.status,
+		};
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function saveContentSeeds(args: {
+	seeds: Array<{
+		extractionId: string;
+		hook: string;
+		coreArgument: string;
+		format: string;
+		sourceGrounding: string;
+		voiceNote: string;
+		userContext?: string;
+	}>;
+}) {
+	try {
+		const response = await api.post<any>("/extractions", args);
+		return { count: response.count, seeds: response.seeds?.map((s: any) => s.id) };
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function listExtractions(args: { limit?: number; search?: string }) {
+	try {
+		const params: Record<string, string | number | undefined> = {};
+		if (args.limit) params.limit = args.limit;
+		if (args.search) params.search = args.search;
+		const response = await api.get<any>("/extractions", params);
+		return { extractions: response.extractions, total: response.total };
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function getExtraction(args: { id: string; seeds?: boolean }) {
+	try {
+		const params: Record<string, string | number | undefined> = { id: args.id };
+		if (args.seeds) params.seeds = "true";
+		const response = await api.get<any>("/extractions", params);
+		return { extraction: response.extraction, seeds: response.seeds };
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+// ── Tool registration ───────────────────────────────────────────────────
+
+export function registerExtractionTools(pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "seed_save_extraction",
+		label: "Save Extraction",
+		description:
+			"Save a structured extraction to persistent memory. Call this after completing a /extract analysis to store the 9-dimension extraction. Returns the extraction ID needed for saving content seeds.",
+		parameters: Type.Object({
+			sourceUrl: Type.Optional(Type.String({ description: "Source URL if from web" })),
+			sourceTitle: Type.String({ description: "Title of the source" }),
+			sourceType: Type.Optional(Type.String({ description: "article, tweet, essay, conversation, concept" })),
+			summary: Type.Optional(Type.String({ description: "2-3 sentence summary" })),
+			claims: Type.Optional(Type.Array(Type.Object({
+				claim: Type.String(),
+				evidence: Type.String(),
+				confidence: Type.String(),
+				implicit: Type.Boolean(),
+				notes: Type.Optional(Type.String()),
+			}))),
+			entities: Type.Optional(Type.Array(Type.Object({
+				name: Type.String(),
+				type: Type.String(),
+				role: Type.String(),
+			}))),
+			quotes: Type.Optional(Type.Array(Type.Object({
+				text: Type.String(),
+				attribution: Type.String(),
+				context: Type.Optional(Type.String()),
+			}))),
+			patterns: Type.Optional(Type.Array(Type.Object({
+				pattern: Type.String(),
+				connection: Type.String(),
+				strength: Type.String(),
+			}))),
+			relevance: Type.Optional(Type.Array(Type.Object({
+				area: Type.String(),
+				rating: Type.String(),
+				why: Type.String(),
+			}))),
+			actionable: Type.Optional(Type.Array(Type.Object({
+				type: Type.String(),
+				description: Type.String(),
+				priority: Type.String(),
+			}))),
+			extractionNotes: Type.Optional(Type.Object({
+				observations: Type.Array(Type.String()),
+				schemaFitness: Type.String(),
+				secondPassCandidate: Type.Boolean(),
+			})),
+		}),
+		execute: wrapExecute(saveExtraction),
+		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 || {};
+			if (d.error) return new Text(theme.fg("error", d.error), 0, 0);
+			return new Text(
+				theme.fg("success", `✓ Saved extraction: ${d.sourceTitle || d.id}`),
+				0, 0,
+			);
+		},
+	});
+
+	pi.registerTool({
+		name: "seed_save_content_seeds",
+		label: "Save Content Seeds",
+		description:
+			"Save content seeds (content directions) generated from a /clubtone pass. Each seed needs the extractionId from a saved extraction.",
+		parameters: Type.Object({
+			seeds: Type.Array(Type.Object({
+				extractionId: Type.String({ description: "ID of the source extraction" }),
+				hook: Type.String({ description: "Opening line / angle" }),
+				coreArgument: Type.String({ description: "What you'd actually say" }),
+				format: Type.String({ description: "tweet_thread, short_post, essay, newsletter, etc." }),
+				sourceGrounding: Type.String({ description: "Which extraction dimensions feed this" }),
+				voiceNote: Type.String({ description: "2-sentence friend explanation" }),
+				userContext: Type.Optional(Type.String({ description: "User context that shaped this" })),
+			})),
+		}),
+		execute: wrapExecute(saveContentSeeds),
+		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 || {};
+			if (d.error) return new Text(theme.fg("error", d.error), 0, 0);
+			return new Text(
+				theme.fg("success", `✓ Saved ${d.count || 0} content seeds`),
+				0, 0,
+			);
+		},
+	});
+
+	pi.registerTool({
+		name: "seed_list_extractions",
+		label: "List Extractions",
+		description:
+			"List the user's saved extractions. Shows source, summary, and counts of patterns/claims/actionable items.",
+		parameters: Type.Object({
+			limit: Type.Optional(Type.Number({ description: "Max results (default 20)" })),
+			search: Type.Optional(Type.String({ description: "Search by title or summary" })),
+		}),
+		execute: wrapExecute(listExtractions),
+		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.extractions?.length) return new Text(theme.fg("dim", "No extractions yet"), 0, 0);
+			let text = theme.fg("muted", `${d.total} extractions`);
+			for (const e of d.extractions.slice(0, expanded ? 50 : 10)) {
+				const counts = [
+					e.patternCount && `${e.patternCount}p`,
+					e.claimCount && `${e.claimCount}c`,
+					e.actionableCount && `${e.actionableCount}a`,
+				].filter(Boolean).join("/");
+				text += `\n  ${e.sourceTitle}${counts ? ` [${counts}]` : ""} — ${e.status}`;
+			}
+			return new Text(text, 0, 0);
+		},
+	});
+
+	pi.registerTool({
+		name: "seed_get_extraction",
+		label: "Get Extraction",
+		description:
+			"Get a specific extraction by ID, with full 9-dimension data. Optionally include content seeds.",
+		parameters: Type.Object({
+			id: Type.String({ description: "Extraction ID" }),
+			seeds: Type.Optional(Type.Boolean({ description: "Include content seeds" })),
+		}),
+		execute: wrapExecute(getExtraction),
+	});
+}

package/package.json

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