@clubnet/seedclub 0.2.11 → 0.2.13

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

@@ -1,5 +1,8 @@
 /**
  * /extract, /clubtone, /extractions commands.
+ *
+ * Key design: the LLM responds BY calling the save tool.
+ * The tool parameters ARE the extraction. No text-then-save — saving IS responding.
  */
 
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
@@ -31,31 +34,41 @@ export function registerExtractCommand(pi: ExtensionAPI) {
 					? result.content.slice(0, 40000) + "\n\n[Content truncated at 40K chars]"
 					: result.content;
 				const prompt = buildExtractionPrompt(content, url, title);
-				pi.sendUserMessage(prompt + "\n\nAfter completing the extraction, call seed_save_extraction with the structured results so they are saved to persistent memory. Include all 9 dimensions.");
+				pi.sendUserMessage(
+					prompt +
+					"\n\nIMPORTANT: Respond ONLY by calling the seed_save_extraction tool with your complete analysis as the parameters. " +
+					"Do not write the extraction as text first. The tool call IS your response. " +
+					"Fill in every dimension directly in the tool parameters: sourceUrl, sourceTitle, sourceType, summary, claims, entities, quotes, patterns, relevance, actionable, extractionNotes. " +
+					"After the tool confirms the save, give a brief summary of what you found."
+				);
 				return;
 			}
 
 			if (!arg) {
 				pi.sendUserMessage(
-					"Look at the content shared in this conversation and run a full 9-dimension extraction:\n\n" +
-					"1. **Summary** - 2-3 sentences\n" +
-					"2. **Claims & Arguments** - every claim including implicit ones\n" +
-					"3. **Entities** - people, orgs, concepts, products, technologies\n" +
-					"4. **Temporal** - only if time-sensitive\n" +
-					"5. **Quotes** - direct quotes worth preserving\n" +
-					"6. **Patterns & Themes** - 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** - what is rich, what is thin\n\n" +
-					"Be thorough. After completing, call seed_save_extraction to persist."
+					"Look at the content shared in this conversation and extract structured knowledge from it.\n\n" +
+					"IMPORTANT: Respond ONLY by calling the seed_save_extraction tool. " +
+					"Do not write the extraction as text. The tool call IS your response.\n\n" +
+					"Fill in all 9 dimensions as tool parameters:\n" +
+					"- sourceTitle, sourceType, summary (2-3 sentences)\n" +
+					"- claims (every claim with evidence, confidence, implicit flag)\n" +
+					"- entities (people, orgs, concepts, products, technologies)\n" +
+					"- quotes (direct quotes worth preserving)\n" +
+					"- patterns (how themes connect to broader work — highest value dimension)\n" +
+					"- relevance (which areas this matters for and why)\n" +
+					"- actionable (content seeds, follow-ups, research threads)\n" +
+					"- extractionNotes (observations, schema fitness, second pass candidate)\n\n" +
+					"Be thorough. After the tool confirms the save, give a brief summary of what you found."
 				);
 				return;
 			}
 
 			pi.sendUserMessage(
-				"Explore and extract from the concept: \"" + arg + "\"\n\n" +
-				"Run a full 9-dimension extraction (summary, claims, entities, temporal, quotes, patterns, relevance, actionable, extraction notes).\n\n" +
-				"Be thorough. After completing, call seed_save_extraction to persist."
+				"Extract structured knowledge from the concept: \"" + arg + "\"\n\n" +
+				"IMPORTANT: Respond ONLY by calling the seed_save_extraction tool with your analysis as the parameters. " +
+				"Do not write the extraction as text first. The tool call IS your response. " +
+				"Fill in all 9 dimensions (sourceTitle, summary, claims, entities, quotes, patterns, relevance, actionable, extractionNotes). " +
+				"After the tool confirms the save, give a brief summary of what you found."
 			);
 		},
 	});
@@ -71,7 +84,7 @@ export function registerExtractCommand(pi: ExtensionAPI) {
 		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."
+				"Call seed_list_extractions now. Show results in a clean format with title, date, and counts of patterns/claims/actionable items."
 			);
 		},
 	});
@@ -80,15 +93,18 @@ export function registerExtractCommand(pi: ExtensionAPI) {
 function runClubtone(pi: ExtensionAPI, context?: string) {
 	const extra = context ? "\n\nAdditional context: " + context : "";
 	pi.sendUserMessage(
-		"Look at the most recent extraction 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 would 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 would explain this to a friend in 2 sentences\n\n" +
-		"Do not be generic. My voice, not the source voice.\n\n" +
-		"After generating, call seed_save_content_seeds to persist." + extra
+		"Look at the most recent extraction in our conversation. Generate 3-5 content directions.\n\n" +
+		"IMPORTANT: Respond ONLY by calling the seed_save_content_seeds tool. " +
+		"Do not write the directions as text first. The tool call IS your response.\n\n" +
+		"For each seed, fill in the tool parameters:\n" +
+		"- extractionId (from the most recent seed_save_extraction result)\n" +
+		"- hook (opening line that stops a scroll)\n" +
+		"- coreArgument (what I would actually say, grounded in the source)\n" +
+		"- format (tweet_thread, short_post, essay, newsletter, conversation_starter)\n" +
+		"- sourceGrounding (which claims, patterns, quotes feed this)\n" +
+		"- voiceNote (how I would explain this to a friend in 2 sentences)\n\n" +
+		"Do not be generic. My voice, not the source voice. " +
+		"After the tool confirms, give a brief summary of the directions." + extra
 	);
 }
 

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

@@ -1,8 +1,12 @@
 /**
- * Extraction tools — save and retrieve extractions from the Seed Club API.
+ * Extraction tools — the full L0-L4 tool surface.
  *
- * These tools let the LLM persist extractions after running /extract,
- * and save content seeds after running /clubtone.
+ * L0: seed_register_source — register a source before extraction
+ * L2: seed_save_extraction — save a 9-dimension extraction (tool call IS the save)
+ * L3: seed_synthesize — cross-source synthesis from 2+ extractions
+ * L4: seed_distill — promote a pattern to stable concept
+ * Content: seed_save_content_seeds — save content directions from extraction or synthesis
+ * Read: seed_list_extractions, seed_get_extraction, seed_list_sources, seed_list_syntheses
  */
 
 import { Text } from "@mariozechner/pi-tui";
@@ -13,10 +17,30 @@ import { wrapExecute } from "../tool-utils.js";
 
 // ── API handlers ────────────────────────────────────────────────────────
 
+async function registerSource(args: {
+	url?: string;
+	title: string;
+	sourceType?: string;
+	author?: string;
+	provenance?: string;
+	tier?: string;
+	discoveryTrace?: string;
+	credibilityNotes?: string;
+}) {
+	try {
+		const response = await api.post<any>("/extractions/sources", args);
+		return { id: response.source.id, title: response.source.title, status: response.source.status };
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
 async function saveExtraction(args: {
 	sourceUrl?: string;
 	sourceTitle: string;
 	sourceType?: string;
+	sourceId?: string;
 	rawContent?: string;
 	fetchMethod?: string;
 	summary?: string;
@@ -44,9 +68,48 @@ async function saveExtraction(args: {
 	}
 }
 
+async function synthesize(args: {
+	title: string;
+	thesis?: string;
+	extractionIds: string[];
+	patterns?: any[];
+	entityResolution?: any[];
+	themeConvergence?: any[];
+	contradictions?: any[];
+	bridges?: any[];
+	emergentInsights?: string[];
+	trigger?: string;
+}) {
+	try {
+		const response = await api.post<any>("/extractions/syntheses", args);
+		return { id: response.synthesis.id, title: response.synthesis.title, extractionCount: response.synthesis.extractionCount };
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function distill(args: {
+	title: string;
+	concept: string;
+	evidenceSummary?: string;
+	synthesisIds: string[];
+	tags?: string[];
+	relatedEntities?: any[];
+}) {
+	try {
+		const response = await api.post<any>("/extractions/distillations", args);
+		return { id: response.distillation.id, title: response.distillation.title, synthesisCount: response.distillation.synthesisCount };
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
 async function saveContentSeeds(args: {
 	seeds: Array<{
-		extractionId: string;
+		extractionId?: string;
+		synthesisId?: string;
 		hook: string;
 		coreArgument: string;
 		format: string;
@@ -56,7 +119,7 @@ async function saveContentSeeds(args: {
 	}>;
 }) {
 	try {
-		const response = await api.post<any>("/extractions", args);
+		const response = await api.post<any>("/extractions/seeds", 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 };
@@ -89,18 +152,96 @@ async function getExtraction(args: { id: string; seeds?: boolean }) {
 	}
 }
 
+async function listSources(args: { limit?: number; status?: string }) {
+	try {
+		const params: Record<string, string | number | undefined> = {};
+		if (args.limit) params.limit = args.limit;
+		if (args.status) params.status = args.status;
+		const response = await api.get<any>("/extractions/sources", params);
+		return { sources: response.sources, total: response.total };
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function listSyntheses(args: { limit?: number }) {
+	try {
+		const params: Record<string, string | number | undefined> = {};
+		if (args.limit) params.limit = args.limit;
+		const response = await api.get<any>("/extractions/syntheses", params);
+		return { syntheses: response.syntheses, total: response.total };
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function listSeeds(args: { limit?: number; unused?: boolean; extractionId?: string; synthesisId?: string }) {
+	try {
+		const params: Record<string, string | number | undefined> = {};
+		if (args.limit) params.limit = args.limit;
+		if (args.unused) params.unused = "true";
+		if (args.extractionId) params.extractionId = args.extractionId;
+		if (args.synthesisId) params.synthesisId = args.synthesisId;
+		const response = await api.get<any>("/extractions/seeds", params);
+		return { seeds: response.seeds, total: response.total };
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function markSeedUsed(args: { id: string }) {
+	try {
+		const response = await api.post<any>("/extractions/seeds/used", { id: args.id });
+		return { id: response.seed.id, used: true };
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
 // ── Tool registration ───────────────────────────────────────────────────
 
 export function registerExtractionTools(pi: ExtensionAPI) {
+
+	// ── L0: Source Registration ───────────────────────────────────────────
+
+	pi.registerTool({
+		name: "seed_register_source",
+		label: "Register Source",
+		description: "Register a source in the L0 registry before extraction. Records provenance, credibility, and discovery trace. Returns source ID for linking to extraction.",
+		parameters: Type.Object({
+			url: Type.Optional(Type.String({ description: "Source URL" })),
+			title: Type.String({ description: "Human-readable title" }),
+			sourceType: Type.Optional(Type.String({ description: "article, tweet, essay, conversation, voice_note, code, transcript" })),
+			author: Type.Optional(Type.String({ description: "Creator(s)" })),
+			provenance: Type.Optional(Type.String({ description: "authored, licensed, public, restricted" })),
+			tier: Type.Optional(Type.String({ description: "external, internal_external, internal" })),
+			discoveryTrace: Type.Optional(Type.String({ description: "How found, who referred, what context" })),
+			credibilityNotes: Type.Optional(Type.String({ description: "Credibility assessment" })),
+		}),
+		execute: wrapExecute(registerSource),
+		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", "Registered: " + d.title + " [" + d.id + "]"), 0, 0);
+		},
+	});
+
+	// ── L2: Save Extraction ───────────────────────────────────────────────
+
 	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.",
+		description: "Save a structured 9-dimension extraction. The tool call IS the extraction — fill all dimensions as parameters. Returns extraction ID for content seeds and synthesis.",
 		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" })),
+			sourceId: Type.Optional(Type.String({ description: "L0 source registry ID if registered" })),
 			summary: Type.Optional(Type.String({ description: "2-3 sentence summary" })),
 			claims: Type.Optional(Type.Array(Type.Object({
 				claim: Type.String(),
@@ -145,23 +286,100 @@ export function registerExtractionTools(pi: ExtensionAPI) {
 			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,
-			);
+			return new Text(theme.fg("success", "Saved extraction: " + (d.sourceTitle || d.id)), 0, 0);
 		},
 	});
 
+	// ── L3: Synthesize ────────────────────────────────────────────────────
+
+	pi.registerTool({
+		name: "seed_synthesize",
+		label: "Synthesize",
+		description: "Create an L3 cross-source synthesis from 2+ extractions. Identifies patterns, contradictions, entity resolution, theme convergence, and emergent insights across sources. The tool call IS the synthesis.",
+		parameters: Type.Object({
+			title: Type.String({ description: "Synthesis title" }),
+			thesis: Type.Optional(Type.String({ description: "Core insight from crossing these sources" })),
+			extractionIds: Type.Array(Type.String({ description: "Extraction IDs to synthesize" })),
+			patterns: Type.Optional(Type.Array(Type.Object({
+				pattern: Type.String(),
+				sources: Type.Array(Type.String()),
+				strength: Type.String(),
+				connection: Type.String(),
+			}))),
+			entityResolution: Type.Optional(Type.Array(Type.Object({
+				entity: Type.String(),
+				appearances: Type.Array(Type.Object({ extractionId: Type.String(), role: Type.String() })),
+				mergedUnderstanding: Type.String(),
+			}))),
+			themeConvergence: Type.Optional(Type.Array(Type.Object({
+				theme: Type.String(),
+				supportingExtractions: Type.Array(Type.String()),
+				divergences: Type.String(),
+				synthesisNote: Type.String(),
+			}))),
+			contradictions: Type.Optional(Type.Array(Type.Object({
+				claimA: Type.String(),
+				sourceA: Type.String(),
+				claimB: Type.String(),
+				sourceB: Type.String(),
+				resolution: Type.String(),
+			}))),
+			bridges: Type.Optional(Type.Array(Type.Object({
+				fromExtraction: Type.String(),
+				toExtraction: Type.String(),
+				bridgeInsight: Type.String(),
+			}))),
+			emergentInsights: Type.Optional(Type.Array(Type.String({ description: "Insights only visible when crossing sources" }))),
+			trigger: Type.Optional(Type.String({ description: "manual, theme_cluster, project_need" })),
+		}),
+		execute: wrapExecute(synthesize),
+		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", "Synthesis: " + d.title + " (" + d.extractionCount + " sources)"), 0, 0);
+		},
+	});
+
+	// ── L4: Distill ───────────────────────────────────────────────────────
+
+	pi.registerTool({
+		name: "seed_distill",
+		label: "Distill",
+		description: "Promote a pattern to an L4 distillation — a stable concept proven across 3+ syntheses. Returns distillation ID.",
+		parameters: Type.Object({
+			title: Type.String({ description: "Concept title" }),
+			concept: Type.String({ description: "The stable pattern or mental model" }),
+			evidenceSummary: Type.Optional(Type.String({ description: "Why this graduated" })),
+			synthesisIds: Type.Array(Type.String({ description: "Synthesis IDs that support this" })),
+			tags: Type.Optional(Type.Array(Type.String({ description: "Freeform tags for routing" }))),
+			relatedEntities: Type.Optional(Type.Array(Type.Object({
+				name: Type.String(),
+				type: Type.String(),
+				role: Type.String(),
+			}))),
+		}),
+		execute: wrapExecute(distill),
+		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", "Distilled: " + d.title + " (" + d.synthesisCount + " syntheses)"), 0, 0);
+		},
+	});
+
+	// ── Content Seeds ─────────────────────────────────────────────────────
+
 	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.",
+		description: "Save content directions from an extraction or synthesis. Each seed needs either an extractionId or synthesisId (or both for cross-source seeds).",
 		parameters: Type.Object({
 			seeds: Type.Array(Type.Object({
-				extractionId: Type.String({ description: "ID of the source extraction" }),
+				extractionId: Type.Optional(Type.String({ description: "Source extraction ID" })),
+				synthesisId: Type.Optional(Type.String({ description: "Source synthesis ID" })),
 				hook: Type.String({ description: "Opening line / angle" }),
-				coreArgument: Type.String({ description: "What you'd actually say" }),
+				coreArgument: Type.String({ description: "What you would 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" }),
@@ -173,18 +391,16 @@ export function registerExtractionTools(pi: ExtensionAPI) {
 			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,
-			);
+			return new Text(theme.fg("success", "Saved " + (d.count || 0) + " content seeds"), 0, 0);
 		},
 	});
 
+	// ── Read tools ────────────────────────────────────────────────────────
+
 	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.",
+		description: "List saved extractions with summary and dimension counts.",
 		parameters: Type.Object({
 			limit: Type.Optional(Type.Number({ description: "Max results (default 20)" })),
 			search: Type.Optional(Type.String({ description: "Search by title or summary" })),
@@ -194,14 +410,14 @@ export function registerExtractionTools(pi: ExtensionAPI) {
 			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`);
+			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`,
+					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}`;
+				text += "\n  " + e.sourceTitle + (counts ? " [" + counts + "]" : "") + " - " + e.status;
 			}
 			return new Text(text, 0, 0);
 		},
@@ -210,12 +426,92 @@ export function registerExtractionTools(pi: ExtensionAPI) {
 	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.",
+		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),
 	});
+
+	pi.registerTool({
+		name: "seed_list_sources",
+		label: "List Sources",
+		description: "List registered sources from the L0 registry.",
+		parameters: Type.Object({
+			limit: Type.Optional(Type.Number({ description: "Max results (default 20)" })),
+			status: Type.Optional(Type.String({ description: "Filter by status: registered, captured, extracted, synthesized, distilled" })),
+		}),
+		execute: wrapExecute(listSources),
+		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.sources?.length) return new Text(theme.fg("dim", "No sources registered"), 0, 0);
+			let text = theme.fg("muted", d.total + " sources");
+			for (const s of d.sources) {
+				text += "\n  " + s.title + " [" + s.status + "] " + (s.provenance || "");
+			}
+			return new Text(text, 0, 0);
+		},
+	});
+
+	pi.registerTool({
+		name: "seed_list_syntheses",
+		label: "List Syntheses",
+		description: "List L3 cross-source syntheses.",
+		parameters: Type.Object({
+			limit: Type.Optional(Type.Number({ description: "Max results (default 20)" })),
+		}),
+		execute: wrapExecute(listSyntheses),
+		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.syntheses?.length) return new Text(theme.fg("dim", "No syntheses yet"), 0, 0);
+			let text = theme.fg("muted", d.total + " syntheses");
+			for (const s of d.syntheses) {
+				text += "\n  " + s.title + " (" + s.extractionCount + " sources)";
+			}
+			return new Text(text, 0, 0);
+		},
+	});
+
+	pi.registerTool({
+		name: "seed_list_seeds",
+		label: "List Content Seeds",
+		description: "List content seeds. Filter by unused, extraction, or synthesis.",
+		parameters: Type.Object({
+			limit: Type.Optional(Type.Number({ description: "Max results (default 20)" })),
+			unused: Type.Optional(Type.Boolean({ description: "Only unused seeds" })),
+			extractionId: Type.Optional(Type.String({ description: "Filter by extraction" })),
+			synthesisId: Type.Optional(Type.String({ description: "Filter by synthesis" })),
+		}),
+		execute: wrapExecute(listSeeds),
+		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.seeds?.length) return new Text(theme.fg("dim", "No content seeds yet"), 0, 0);
+			let text = theme.fg("muted", d.total + " seeds");
+			for (const s of d.seeds) {
+				const status = s.used ? "used" : "fresh";
+				text += "\n  [" + s.format + "] " + s.hook.slice(0, 60) + "... (" + status + ")";
+			}
+			return new Text(text, 0, 0);
+		},
+	});
+
+	pi.registerTool({
+		name: "seed_mark_used",
+		label: "Mark Seed Used",
+		description: "Mark a content seed as used after drafting content from it.",
+		parameters: Type.Object({
+			id: Type.String({ description: "Content seed ID" }),
+		}),
+		execute: wrapExecute(markSeedUsed),
+		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", "Marked as used"), 0, 0);
+		},
+	});
 }

package/package.json

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