@clubnet/seedclub 0.2.10 → 0.2.13

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

@@ -1,169 +1,123 @@
 /**
- * /extract — the main entry point for the extraction system.
+ * /extract, /clubtone, /extractions commands.
  *
- * 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
+ * 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";
 import { capture } from "../extraction/capture.js";
-import { buildExtractionPrompt, buildContentSeedPrompt } from "../extraction/schema.js";
+import { buildExtractionPrompt } 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.`,
-				);
+			if (arg === "clubtone" || arg === "club" || arg === "tone") {
+				runClubtone(pi);
 				return;
 			}
 
-			// /extract <url> — capture + extract
 			const url = extractUrl(arg);
 			if (url) {
-				ctx.ui.notify(`Capturing ${url}...`, "info");
-
+				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");
+					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
+				ctx.ui.notify("Captured (" + result.fetchMethod + "). Running extraction...", "info");
 				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."
+					"\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;
 			}
 
-			// /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.`,
+					"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;
 			}
 
-			// /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.`,
+				"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."
 			);
 		},
 	});
 
-	// ── /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}`,
-			);
+		handler: async (args, _ctx) => {
+			runClubtone(pi, args?.trim());
 		},
 	});
-}
-
-	// ── /extractions — list saved extractions ─────────────────────────────
 
 	pi.registerCommand("extractions", {
 		description: "Browse your saved extractions",
-		handler: async (args, ctx) => {
+		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."
+				"Call seed_list_extractions now. Show results in a clean format with title, date, and counts of patterns/claims/actionable items."
 			);
 		},
 	});
+}
 
-// ── Helpers ─────────────────────────────────────────────────────────
+function runClubtone(pi: ExtensionAPI, context?: string) {
+	const extra = context ? "\n\nAdditional context: " + context : "";
+	pi.sendUserMessage(
+		"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
+	);
+}
 
 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

@@ -1,11 +1,9 @@
 /**
- * L1 Raw Capture — fetch full-fidelity content from URLs.
- *
- * Uses Jina Reader (r.jina.ai) for articles/pages.
- * Returns markdown content without LLM processing.
+ * L1 Raw Capture - fetch full-fidelity content from URLs.
+ * Uses Jina Reader for articles, FxTwitter for tweets.
  */
 
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@mariozechner/Seed Club-coding-agent";
 
 export interface CaptureResult {
 	content: string;
@@ -15,74 +13,32 @@ export interface CaptureResult {
 	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,
-	});
+	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: 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: "", contentType: "text", fetchMethod: "failed", complete: false, note: "Fetch failed for " + url };
 	}
 
-	return {
-		content: result.stdout,
-		contentType: "markdown",
-		fetchMethod: "jina-reader",
-		complete: true,
-	};
+	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 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,
-	};
+	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);

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

@@ -1,8 +1,5 @@
 /**
- * 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.
+ * L2 Extraction Schema - the 9-dimension extraction format.
  */
 
 export interface Claim {
@@ -27,7 +24,7 @@ export interface Quote {
 
 export interface Pattern {
 	pattern: string;
-	connection: string; // How it connects to operator's context/work
+	connection: string;
 	strength: "strong" | "moderate" | "emerging";
 }
 
@@ -49,20 +46,15 @@ export interface ExtractionNotes {
 	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
+	temporal?: { events: string[]; note: string };
 	quotes: Quote[];
 	patterns: Pattern[];
 	relevance: Relevance[];
@@ -70,115 +62,56 @@ export interface L2Extraction {
 	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.`;
+	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.",
+		"",
+		"### 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 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 is not 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.",
+		"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.",
+		"",
+		"## Output Format",
+		"Return a JSON object with all 9 dimensions. Be specific in patterns and relevance.",
+	].join("\n");
 }

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.10",
+  "version": "0.2.13",
   "description": "The Human+ Venture Network — AI agent for deal sourcing, research, and signal tracking",
   "license": "MIT",
   "repository": {